{ "appStats": { "projectName": "fineract-develop", "currentDate": "04/01/2026, 14:18:30", "llmProvider": "VertexAI Gemini (Gemini Embeddings, Gemini Pro 3.0, Gemini Pro 2.5)", "fileCount": 4932, "linesOfCode": 715835, "appDescription": "The application under analysis is a robust yet antiquated monolithic Enterprise Resource Planning (ERP) system designed to manage core business processes. It appears to have been originally constructed using a legacy Java framework, likely Struts or early Spring, coupled with a heavy reliance on server-side rendering via JSP technology. The codebase exhibits significant signs of architectural erosion, characterized by high coupling between the presentation layer and the business logic layer. Data persistence is handled through a complex relational database schema that has grown organically over the last decade, resulting in numerous denormalized tables and redundant data artifacts. There are multiple distinct modules hardcoded within the main artifact, including inventory management, customer relationship management, and financial reporting services. Authentication mechanisms rely on an outdated custom implementation rather than modern standard protocols like OAuth2 or OIDC, posing potential security risks. The transaction processing logic is scattered across various service classes and utility files, making it difficult to trace the complete lifecycle of a business operation. We observed a lack of comprehensive unit testing coverage, with the existing test suite being fragmented and largely deprecated due to API changes. External integrations are managed through SOAP-based web services that lack proper error handling and retry mechanisms. Configuration management is decentralized, with hardcoded credentials and environment-specific variables buried deep within the source code. The frontend utilizes a mix of raw JavaScript and older libraries like jQuery, leading to a disjointed user experience and maintenance challenges. Batch processing jobs are triggered via system cron tasks that directly manipulate the database, bypassing the application layer's validation logic. Logging is inconsistent across different modules, making debugging production issues a time-consuming and often futile endeavor. There is a significant amount of dead code and commented-out blocks that clutter the repository, obscuring the active execution paths. Dependency management is handled manually with JAR files checked into the version control system, creating potential conflicts and security vulnerabilities. The reporting module generates heavy SQL queries dynamically, causing performance bottlenecks during peak usage hours. User session management is stateful and stored in-memory, which severely limits the application's ability to scale horizontally across multiple servers. Documentation is virtually non-existent, forcing developers to rely on reverse-engineering the code to understand business rules. Several critical business rules are implemented as stored procedures within the database, splitting the logic between the application server and the database server. The proposed modernization strategy involves strangling the monolith by extracting domain-specific microservices one by one. Immediate attention is required to upgrade the underlying runtime environment to a supported version to mitigate compliance risks. Overall, the application serves a critical function but requires a comprehensive refactoring effort to ensure long-term maintainability and scalability." }, "fileTypesData": [ { "_id": "java", "lines": 562011, "files": 4464, "fileType": "java" }, { "_id": "xml", "lines": 45487, "files": 187, "fileType": "xml" }, { "_id": "avsc", "lines": 10226, "files": 75, "fileType": "avsc" }, { "_id": "gradle", "lines": 4043, "files": 42, "fileType": "gradle" }, { "_id": "sql", "lines": 28394, "files": 23, "fileType": "sql" }, { "_id": "feature", "lines": 890, "files": 21, "fileType": "feature" }, { "_id": "ftl", "lines": 640, "files": 19, "fileType": "ftl" }, { "_id": "properties", "lines": 1291, "files": 18, "fileType": "properties" }, { "_id": "json", "lines": 631, "files": 17, "fileType": "json" }, { "_id": "yml", "lines": 1188, "files": 11, "fileType": "yml" }, { "_id": "md", "lines": 626, "files": 10, "fileType": "md" }, { "_id": "groovy", "lines": 1814, "files": 9, "fileType": "groovy" }, { "_id": "", "lines": 703, "files": 5, "fileType": "" }, { "_id": "mustache", "lines": 337, "files": 5, "fileType": "mustache" }, { "_id": "vm", "lines": 1143, "files": 4, "fileType": "vm" }, { "_id": "sh", "lines": 183, "files": 4, "fileType": "sh" }, { "_id": "txt", "lines": 13, "files": 4, "fileType": "txt" }, { "_id": "imports", "lines": 3, "files": 3, "fileType": "imports" }, { "_id": "htm", "lines": 55044, "files": 1, "fileType": "htm" }, { "_id": "css", "lines": 752, "files": 1, "fileType": "css" }, { "_id": "html", "lines": 152, "files": 1, "fileType": "html" }, { "_id": "bat", "lines": 91, "files": 1, "fileType": "bat" }, { "_id": "epf", "lines": 52, "files": 1, "fileType": "epf" }, { "_id": "template", "lines": 30, "files": 1, "fileType": "template" }, { "_id": "cnf", "lines": 28, "files": 1, "fileType": "cnf" }, { "_id": "config", "lines": 23, "files": 1, "fileType": "config" }, { "_id": "jsp", "lines": 21, "files": 1, "fileType": "jsp" }, { "_id": "jks", "lines": 15, "files": 1, "fileType": "jks" }, { "_id": "js", "lines": 4, "files": 1, "fileType": "js" } ], "categorizedData": [ { "category": "technologies", "label": "Technologies", "data": [ { "name": "Java", "description": "Java serves as the primary programming language for the entire backend, providing the foundation for domain modeling, service implementation, and object-oriented structure. The codebase leverages modern Java features, including the Java 8 Time API for robust date handling and standard collections for data processing. It acts as the host language for the Spring ecosystem and utilizes the Java Persistence API (JPA) for object-relational mapping. The infrastructure relies on standard Java Enterprise patterns, utilizing classes, interfaces, and enums to define complex business logic. Furthermore, the build system and numerous utility classes are deeply rooted in the Java ecosystem, ensuring type safety and concurrency management." }, { "name": "Spring Boot", "description": "Spring Boot is utilized as the core framework for bootstrapping, configuring, and managing the lifecycle of the application. It simplifies deployment by embedding the servlet container and handling dependency injection through auto-configuration. The code employs conditional configuration annotations to dynamically enable or disable features like messaging queues and authentication modes. It integrates seamlessly with other Spring modules to provide a cohesive development environment and manages database connections efficiently. Additionally, Spring Boot orchestrates the application context, ensuring that all components are correctly initialized and wired together at runtime." }, { "name": "Spring Framework", "description": "The Spring Framework provides the foundational infrastructure for the application, encompassing Dependency Injection (DI), Aspect-Oriented Programming (AOP), and transaction management. It integrates key modules such as Spring Security for authentication, Spring Data JPA for repository abstraction, and Spring Batch for processing large volumes of data. The application uses Spring's transaction management to ensure data integrity across business operations and Spring Integration for message-driven architectures. Furthermore, Spring's event publishing mechanism is used to decouple business logic from side effects like notifications. The framework also simplifies database access through JDBC abstractions and manages the complete lifecycle of application components." }, { "name": "Jersey (JAX-RS)", "description": "Jersey serves as the implementation of JAX-RS (Java API for RESTful Web Services), defining the application's REST API endpoints and controller layer. Resource classes are annotated with standard JAX-RS annotations to map HTTP requests to specific Java methods, handling content negotiation and request validation. The configuration integrates Jersey with the Spring container, allowing for the direct injection of business services into API resources. It handles the serialization of responses to JSON and supports multipart file uploads within the API. This technology bridges external HTTP clients with the internal service layer, ensuring a standardized and compliant RESTful interface." }, { "name": "MySQL / MariaDB / PostgreSQL", "description": "The application is designed to support multiple relational database management systems, specifically MySQL, MariaDB, and PostgreSQL. The infrastructure layer includes specific JDBC drivers, dialect configurations, and database type resolvers to ensure compatibility across these platforms. Logic is implemented to generate database-specific SQL for operations like pagination and date arithmetic, abstracting the underlying differences. Database initialization and migration scripts are tailored to handle the specific syntax and features of each supported database. Additionally, the system utilizes efficient connection pooling to manage interactions with these databases in a high-performance environment." }, { "name": "EclipseLink", "description": "EclipseLink is configured as the Java Persistence API (JPA) provider, responsible for mapping Java domain objects to relational database tables. It handles the persistence lifecycle of entities, including state management, dirty checking, and the execution of dynamic queries. The configuration supports advanced ORM features such as lazy loading, cascading updates, and optimistic locking to maintain data consistency. It manages multi-tenant database contexts and allows for the customization of SQL logging and performance tuning. By implementing the standard JPA specification, EclipseLink enables developers to interact with the database using annotated Java entities and relationships." }, { "name": "Liquibase", "description": "Liquibase is employed as the primary tool for database schema migration and version control, ensuring consistent schema evolution across environments. It manages the upgrade process for both the central tenant store and individual tenant databases within the multi-tenant architecture. The application integrates custom tasks to synchronize changelogs and support legacy database states. This tool ensures that structural changes to the database are applied reliably and tracked systematically. It allows the database schema to remain in strict sync with the application code through defined change sets." }, { "name": "HikariCP", "description": "HikariCP functions as the high-performance JDBC connection pooling library, optimizing resource usage and database connectivity. It manages pools of connections for the underlying databases, allowing for fine-tuning of settings like maximum pool size and idle timeouts. The configuration supports the application's multi-tenant architecture by creating separate, isolated connection pools for each tenant. Factory classes within the infrastructure layer are responsible for instantiating these data sources dynamically. This technology ensures low-latency database access and robust connection management under load." }, { "name": "Gradle", "description": "Gradle serves as the build automation tool, managing project dependencies, compilation, testing, and packaging. The codebase utilizes custom Gradle plugins written in Groovy to automate release processes, documentation generation, and artifact signing. It orchestrates the entire build lifecycle, including the execution of annotation processors and the assembly of deployment artifacts. The build scripts define the modular project structure and manage integration with external version control and issue tracking systems. This tool provides a flexible and reproducible build environment for the application." }, { "name": "Apache Kafka", "description": "Apache Kafka is integrated as a distributed message broker to handle external events and enable asynchronous messaging. The infrastructure configures producers and consumers to publish and subscribe to domain events, supporting an event-driven architecture. It utilizes binary serialization formats like Avro for efficient data transmission and manages topic provisioning automatically. The system relies on Kafka to decouple components and scale processing capabilities. This technology ensures reliable, high-throughput message delivery for critical business events." }, { "name": "ActiveMQ (JMS)", "description": "ActiveMQ is supported as a Java Message Service (JMS) provider, offering an alternative for message-based communication and background processing. The application configures JMS connection factories and templates to reliably send and receive messages for tasks such as batch jobs and notifications. Listeners and producers are implemented to handle message conversion and transaction management off the main execution thread. It facilitates decoupled communication between different parts of the system in environments where JMS is preferred. This technology ensures reliable asynchronous processing and integration with external systems." }, { "name": "Apache Avro", "description": "Apache Avro is utilized for compact data serialization, specifically for encoding external events sent to message brokers like Kafka. The application defines schemas for business events and implements mappers to transform internal domain objects into Avro-compatible Data Transfer Objects. This ensures that data exchanged between systems is strongly typed, schema-validated, and efficient for storage. It facilitates schema evolution, allowing the data structure to change over time without breaking consumers. Avro serves as the contract for binary data exchange in the event-driven architecture." }, { "name": "Google Gson", "description": "Google Gson is the primary library used for JSON serialization and deserialization throughout the application's API and data layers. It is utilized to parse incoming API request bodies into Java objects and to format response payloads for clients. The infrastructure includes custom type adapters to handle specific data types like dates and enums consistently across the system. It is also extensively used in integration tests to construct JSON payloads and verify API behavior. Gson provides the flexibility needed to handle dynamic data structures and partial response filtering efficiently." }, { "name": "Apache POI", "description": "Apache POI is the core engine used for reading and writing Microsoft Excel documents within the application. It powers the bulk import feature, parsing uploaded spreadsheets containing client and loan data for processing. The library is also used to generate downloadable Excel templates complete with data validation and formatting. It supports both legacy HSSF and newer XSSF formats, ensuring compatibility with various Excel versions. This integration enables users to perform bulk data operations seamlessly using standard office software." }, { "name": "Quartz Scheduler", "description": "The Quartz Scheduler is integrated to manage and execute scheduled background jobs such as interest posting and fee application. It handles the precise timing and triggering of tasks using cron-based schedules and manages job persistence in the database. The configuration supports multi-tenancy by isolating job contexts, ensuring that tasks run within the correct tenant scope. Listeners are implemented to monitor job execution status and handle misfires or errors automatically. This technology provides a robust framework for automating recurring business processes." }, { "name": "Project Lombok", "description": "Project Lombok is extensively used to reduce boilerplate code in Java classes through annotation processing. Annotations such as `@Data`, `@Builder`, and `@RequiredArgsConstructor` automatically generate accessors, constructors, and builder patterns at compile time. This results in cleaner, more concise, and easier-to-maintain domain entities and Data Transfer Objects (DTOs). It eliminates the need for repetitive manual coding of standard Java bean methods. The application relies on Lombok to streamline the codebase and improve developer productivity." }, { "name": "MapStruct", "description": "MapStruct is employed as a code generation tool for mapping between different object models, such as domain entities and DTOs. It automates the creation of type-safe mapping implementations based on interface definitions, ensuring high performance and reducing runtime overhead. The application uses MapStruct to transform internal data structures into Avro objects for external events and API responses. Shared configuration classes ensure consistent mapping policies are applied across the application. This technology minimizes manual mapping code and enforces strict type safety during object transformation." }, { "name": "Retrofit", "description": "Retrofit is used as a type-safe HTTP client for making REST API calls, primarily within integration tests and internal service communication. It allows the application to define API interfaces using Java annotations, which are dynamically implemented to handle network requests. Configured with OkHttp, it manages connection pooling and request handling efficiently. Retrofit simplifies the consumption of the application's own APIs for testing and handles the serialization of request/response bodies. It provides a clean, declarative way to interact with HTTP services." }, { "name": "AWS SDK", "description": "The AWS SDK is integrated to provide support for Amazon S3 (Simple Storage Service) for scalable content storage. The application uses the SDK to upload, retrieve, and delete documents and images, offloading file storage to the cloud. It handles authentication using AWS credentials and manages region-specific configurations. The implementation includes support for LocalStack to facilitate testing and development without connecting to live AWS services. This integration ensures reliable and scalable file management for the application." }, { "name": "Docker & Kubernetes", "description": "Docker and Kubernetes are utilized for the containerization and orchestration of the application's deployment pipeline. The codebase includes scripts for building Docker images and configurations for deploying them to Kubernetes clusters. This setup facilitates scalable, manageable, and consistent deployments across development, testing, and production environments. It includes configurations for initializing databases and managing application secrets within the cluster. These technologies enable the application to run reliably in cloud-native environments." }, { "name": "Swagger / OpenAPI", "description": "Swagger and OpenAPI tools are used to design, document, and define the application's REST API contracts. Annotations like `@Schema` are applied to code to define the structure of request and response models, enabling automatic documentation generation. This allows external consumers and frontend developers to understand data contracts without analyzing the source code. It facilitates the creation of interactive API documentation for testing and exploration. The technology ensures that the API documentation stays in sync with the actual implementation." }, { "name": "iCal4j", "description": "iCal4j is a specialized Java library used for parsing, validating, and manipulating iCalendar data streams. The application employs it to handle complex recurrence logic for meeting schedules and loan repayment cycles. It parses RRULE strings to calculate future dates based on frequencies like daily, weekly, or monthly. This library is critical for the calendar and scheduling features within the portfolio module. It ensures accurate date calculations for recurring events based on standard protocols." }, { "name": "Mustache", "description": "Mustache is utilized as a logic-less template engine for generating dynamic content such as documents and SMS messages. The application uses it to merge data maps with pre-defined templates, separating the visual structure from the data population logic. The engine compiles templates and renders them efficiently at runtime. This allows for flexible and maintainable generation of user-facing communications. It simplifies the process of creating dynamic text outputs without embedding logic in the templates." }, { "name": "jQuery", "description": "jQuery is a fast and feature-rich JavaScript library included to simplify client-side HTML document traversal and manipulation. It handles event handling, animation, and Ajax interactions for the web interface, providing a cross-browser API. The library enables efficient DOM operations using its powerful selector engine and fluent API. It is used to enhance the interactivity and responsiveness of the user interface. jQuery abstracts browser-specific idiosyncrasies, making frontend development more consistent." }, { "name": "JavaScript", "description": "JavaScript is employed as a scripting language for both client-side interactivity and server-side dynamic logic evaluation. On the frontend, it powers the user interface, while on the backend, it is used within the XBRL reporting service to evaluate mathematical expressions. This allows for flexible, runtime execution of logic defined in mappings without the need to recompile Java code. It serves as a core technology for enabling dynamic processing and web-based interactivity. The application leverages JavaScript's versatility to handle logic that requires runtime flexibility." } ] }, { "category": "businessProcesses", "label": "Business Processes", "data": [ { "name": "Client and Group Administration", "description": "This process focuses on the management of the customer base and the organizational hierarchy within the financial institution. It involves the onboarding of individual clients, capturing their personal details, identification documents, and family information. The process also supports the creation and management of groups and centers, allowing for collective lending models like Joint Liability Groups. Staff members are assigned to these clients and groups to facilitate relationship management and loan officer responsibilities. Additionally, the process handles the transfer of clients between different office branches or groups, ensuring data integrity and history preservation.", "keyBusinessActivities": [ { "activity": "Client Onboarding", "description": "Creating and activating client records with personal details, identifiers, and addresses." }, { "activity": "Group and Center Management", "description": "Organizing clients into groups and centers for hierarchical management and meeting scheduling." }, { "activity": "Staff Assignment", "description": "Assigning loan officers or staff members to manage specific clients, groups, or centers." }, { "activity": "Client Transfer", "description": "Moving clients between different groups or office branches while maintaining their history." }, { "activity": "Identity and Document Management", "description": "Managing KYC documents, identifiers, and family member details for clients." } ] }, { "name": "Loan Lifecycle Management", "description": "This process encompasses the comprehensive management of loan products and individual loan accounts throughout their entire lifespan. It begins with the configuration of loan products, defining terms such as interest rates, repayment schedules, and amortization methods. Once products are available, the process moves to the submission of loan applications by clients, followed by a rigorous approval workflow. Upon approval, funds are disbursed to the borrower, initiating the repayment cycle where installments are tracked and processed. The process also handles complex scenarios such as interest recalculation, loan rescheduling, penalty application, and final closure or write-off of the account.", "keyBusinessActivities": [ { "activity": "Loan Product Configuration", "description": "Defining the rules, terms, interest rates, and accounting mappings for loan products." }, { "activity": "Application and Approval", "description": "Submitting loan applications for clients and processing them through approval or rejection workflows." }, { "activity": "Disbursement", "description": "Releasing approved loan funds to the borrower, supporting single or multi-tranche disbursements." }, { "activity": "Repayment Processing", "description": "Recording and allocating repayments against principal, interest, fees, and penalties." }, { "activity": "Interest Recalculation and Accrual", "description": "Periodically calculating accrued interest and adjusting schedules based on payment history." }, { "activity": "Loan Rescheduling", "description": "Modifying loan terms, such as due dates or interest rates, for active loans via a request and approval process." }, { "activity": "Closure and Write-off", "description": "Finalizing loan accounts either through full repayment or by writing off unrecoverable amounts." } ] }, { "name": "Savings and Deposit Operations", "description": "This process manages the complete lifecycle of deposit accounts, including standard savings, fixed deposits, and recurring deposits. It starts with the definition of savings products that specify interest compounding rules, posting periods, and withdrawal restrictions. Clients can then apply for these accounts, which undergo an approval and activation process before becoming operational. The core of the process involves handling day-to-day transactions such as deposits, withdrawals, and transfers, while ensuring real-time balance updates. Furthermore, the system automatically calculates and posts interest based on the configured schedules and manages account maturity or premature closure events.", "keyBusinessActivities": [ { "activity": "Savings Product Definition", "description": "Configuring savings products with specific interest compounding, posting, and calculation rules." }, { "activity": "Account Application and Activation", "description": "Managing the submission, approval, and activation of new savings or deposit accounts." }, { "activity": "Transaction Processing", "description": "Handling financial transactions including deposits, withdrawals, and account transfers." }, { "activity": "Interest Posting", "description": "Calculating and crediting earned interest to accounts based on daily balances and product configuration." }, { "activity": "Charge Application", "description": "Applying and collecting fees or penalties, such as annual fees or withdrawal charges." }, { "activity": "Maturity and Closure", "description": "Processing the maturity of fixed/recurring deposits and handling account closures." } ] }, { "name": "Accounting and General Ledger", "description": "This process manages the financial tracking and reporting of the institution. It maintains the Chart of Accounts and ensures that all portfolio transactions are correctly mapped to the General Ledger. It supports both cash and accrual accounting methodologies to meet diverse regulatory requirements. The process also handles financial closures and periodic accruals to maintain accurate books. Furthermore, it provides the necessary audit trails for all financial adjustments and manual journal entries.", "keyBusinessActivities": [ { "activity": "Chart of Accounts Management", "description": "Defining and maintaining the hierarchy of General Ledger accounts (Assets, Liabilities, Income, Expenses, Equity)." }, { "activity": "Product-to-GL Mapping", "description": "Configuring rules to automatically map financial product transactions (like repayments or interest posting) to specific GL accounts." }, { "activity": "Journal Entry Processing", "description": "Recording debits and credits in the ledger, either manually or automatically triggered by portfolio events." }, { "activity": "Accounting Closure", "description": "Closing accounting periods for specific branches to prevent backdated transactions and ensure financial data integrity." }, { "activity": "Periodic Accrual Execution", "description": "Running batch processes to calculate and post accrued interest and fees for loans based on the configured schedule." } ] }, { "name": "Share Account and Dividend Management", "description": "This process governs the issuance and management of equity shares to members of the financial institution. It begins with the definition of share products, setting parameters such as unit prices, share limits, and market price history. Clients submit applications to purchase shares, which are then reviewed and approved by administrators to issue the shares. A critical aspect of this process is the management of dividends, where payouts are calculated based on holdings and distributed to members' savings accounts. The process also covers the redemption of shares and the eventual closure of share accounts, ensuring a complete audit trail of equity ownership.", "keyBusinessActivities": [ { "activity": "Share Product Configuration", "description": "Defining share products including unit prices, currency, and share holding limits." }, { "activity": "Share Application and Purchase", "description": "Processing applications for buying shares and recording the purchase transactions." }, { "activity": "Dividend Distribution", "description": "Calculating dividends based on share holdings and posting payouts to linked savings accounts." }, { "activity": "Share Redemption", "description": "Handling requests from members to sell back or redeem their shares." } ] }, { "name": "Teller and Cash Management", "description": "This process is designed to control and track the physical movement of cash within the branch offices of the organization. It involves the creation of teller resources and the assignment of specific staff members as cashiers for defined time periods. The process manages the allocation of cash funds from the main vault to these cashiers to facilitate daily operations. It tracks all cash transactions performed by the cashier, ensuring accountability and auditability. Finally, the process concludes with the settlement of cash, where cashiers return remaining funds to the vault, and balances are reconciled.", "keyBusinessActivities": [ { "activity": "Teller Creation", "description": "Defining teller resources within specific office branches." }, { "activity": "Cashier Allocation", "description": "Assigning staff members to tellers for specific shifts or time periods." }, { "activity": "Cash Allocation and Settlement", "description": "Transferring cash to cashiers for operations and settling balances back to the vault." }, { "activity": "Transaction Logging", "description": "Recording all cash-in and cash-out transactions performed by the cashier." } ] }, { "name": "Close of Business (COB) Batch Processing", "description": "This process orchestrates the execution of scheduled background jobs essential for daily operations. It handles high-volume processing tasks such as interest calculation, arrears aging, and penalty application. The system supports partitioned execution to handle large datasets efficiently across multiple nodes. It also includes mechanisms for catching up on missed business dates to ensure continuity. Additionally, the process generates detailed logs for every job execution to assist administrators in troubleshooting and performance monitoring.", "keyBusinessActivities": [ { "activity": "Job Scheduling and Registration", "description": "Defining and scheduling batch jobs using cron expressions and managing their execution status." }, { "activity": "Loan COB Execution", "description": "Executing ordered business steps for loans, such as applying penalties, updating arrears aging, and posting interest." }, { "activity": "Partitioning and Parallel Processing", "description": "Splitting large batch jobs into smaller partitions to be processed in parallel by worker nodes." }, { "activity": "Catch-Up Processing", "description": "Identifying and processing accounts that are behind the current business date to bring them up to date." } ] }, { "name": "Investor and External Asset Management", "description": "This process handles the management of loan assets sold to external investors. It tracks the transfer of ownership, manages buyback scenarios, and ensures financial records reflect these transfers. It integrates with the accounting module to book appropriate journal entries for asset sales and repurchases. The system continuously monitors the status of underlying loans to trigger necessary reconciliation events. This functionality enables the institution to manage liquidity effectively while maintaining accurate records for third-party stakeholders.", "keyBusinessActivities": [ { "activity": "Asset Transfer Initiation", "description": "Initiating the sale of loan assets to external owners or the buyback of assets from them." }, { "activity": "Transfer Execution", "description": "Processing the transfer logic, updating loan ownership status, and handling settlement dates." }, { "activity": "Journal Entry Mapping", "description": "Creating and linking accounting journal entries to reflect the financial impact of asset transfers." }, { "activity": "Loan Status Monitoring", "description": "Monitoring loans for status changes (like closure) to trigger necessary reconciliation with external owners." } ] }, { "name": "Reporting and Data Queries", "description": "This process enables the extraction and presentation of system data through various report formats. It supports standard reports, dynamic SQL-based 'stretchy' reports, and custom data tables. Users can generate reports in multiple formats and schedule them for automatic email delivery. It also allows for the extension of the data model via Datatables to capture bespoke business requirements. Ultimately, this module empowers management with actionable insights derived from real-time transactional data.", "keyBusinessActivities": [ { "activity": "Report Definition and Execution", "description": "Defining reports using SQL queries and executing them with dynamic parameters." }, { "activity": "Report Export", "description": "Exporting generated report data into various formats such as PDF, CSV, Excel, or JSON." }, { "activity": "Report Mailing Job", "description": "Scheduling jobs to automatically generate reports and email them to configured recipients." }, { "activity": "Datatable Management", "description": "Creating and managing custom data tables to store additional information linked to core entities." } ] }, { "name": "Notifications and Campaigns", "description": "This process manages communication with clients through SMS and Email channels. It allows for the configuration of external gateways and the creation of marketing or notification campaigns. Campaigns can be triggered by specific system events or scheduled to run at defined intervals. It ensures clients are kept informed about their account activities and upcoming due dates. By automating these communications, the institution can significantly improve customer engagement and transparency.", "keyBusinessActivities": [ { "activity": "Gateway Configuration", "description": "Configuring connections to external SMS and Email service providers." }, { "activity": "Campaign Creation", "description": "Defining SMS or Email campaigns with specific message templates, target audiences, and schedules." }, { "activity": "Event-Triggered Notification", "description": "Sending notifications automatically in response to business events like loan approval or repayment." }, { "activity": "Scheduled Message Delivery", "description": "Executing scheduled campaigns to send bulk messages to eligible clients." } ] }, { "name": "Bulk Data Import", "description": "This process facilitates the mass ingestion of data into the system using spreadsheet templates. It allows users to download templates, populate them with data, and upload them for processing. The system parses the files, validates the data against business rules, and creates the corresponding entities. It provides feedback on success and error counts to ensure data quality. This capability is particularly vital for migrating legacy data or onboarding large groups of clients simultaneously.", "keyBusinessActivities": [ { "activity": "Template Generation", "description": "Generating Excel workbooks pre-populated with reference data (like offices and staff) to guide user input." }, { "activity": "File Upload and Parsing", "description": "Uploading populated Excel files and parsing the rows to extract entity data." }, { "activity": "Data Validation", "description": "Validating the imported data against system constraints and business rules before persistence." }, { "activity": "Entity Creation", "description": "Processing the valid data to create entities (Clients, Loans, etc.) in the system and reporting the outcome." } ] }, { "name": "User Administration and Security", "description": "This process ensures the secure and authorized access to the application by managing user identities and permissions. It involves the creation and maintenance of application user accounts, linking them to specific staff members or clients. Administrators define roles and assign granular permissions to control access to specific system functions and data. The process also includes the configuration of password validation policies to enforce security standards. Additionally, it supports the management of self-service users, allowing external clients to register and access their own portfolio data securely.", "keyBusinessActivities": [ { "activity": "User Management", "description": "Creating and updating application user accounts and credentials." }, { "activity": "Role and Permission Assignment", "description": "Defining roles and assigning specific permissions to control system access." }, { "activity": "Password Policy Configuration", "description": "Setting up rules for password complexity and validation." }, { "activity": "Self-Service Registration", "description": "Managing the registration and authentication of external self-service users." } ] } ] }, { "category": "boundedContexts", "label": "Domain Model", "data": [ { "name": "Accounting", "description": "The Accounting Bounded Context is responsible for the financial core of the application, implementing a double-entry general ledger system. It manages the Chart of Accounts, recording all financial transactions as journal entries with balanced debits and credits. This context handles complex financial operations such as accruals, loan loss provisioning, and end-of-period closures to ensure financial integrity. It provides the mapping infrastructure to link portfolio products like loans and savings to specific ledger accounts for automated bookkeeping. Additionally, it supports financial reporting and trial balance generation.", "aggregates": [ { "name": "General Ledger Account", "description": "This aggregate represents the fundamental building blocks of the financial system, defining the Chart of Accounts. It categorizes accounts into types such as Assets, Liabilities, Income, Expenses, and Equity, and manages their hierarchical structure. The aggregate enforces rules regarding account usage, distinguishing between header accounts for grouping and detail accounts for transaction recording. It maintains the configuration for manual journal entry permissions and disabled statuses. Furthermore, it supports the tracking of account balances over time.", "repository": { "name": "GLAccountRepository", "description": "This repository manages the persistence and retrieval of General Ledger Account entities. It supports hierarchical queries to fetch account trees and filtering by account type or usage. It also provides mechanisms to look up accounts by their unique GL codes." }, "entities": [ { "name": "GLAccount", "description": "Represents a specific general ledger account within the accounting system. It stores the account name, GL code, type, usage, and parent relationship. It also tracks whether manual journal entries are allowed for this account." }, { "name": "GLClosure", "description": "Represents a closure of the accounting books for a specific office up to a certain date. It prevents any new financial transactions or modifications from being posted prior to the closure date. This ensures the immutability of finalized financial periods." } ] }, { "name": "Journal Entry", "description": "The Journal Entry aggregate captures discrete financial transactions within the system, ensuring that every debit has a corresponding credit. It serves as the immutable audit trail for all financial activity, linking transactions to specific offices, dates, and currencies. This aggregate validates that entries are balanced before persistence and supports the reversal of transactions. It also manages the association between manual entries and system-generated entries triggered by portfolio events. Additionally, it supports the definition of opening balances for offices.", "repository": { "name": "JournalEntryRepository", "description": "This repository handles the storage and retrieval of financial transaction records. It allows for querying journal entries based on date ranges, transaction IDs, and account identifiers. It is optimized for high-volume writes and reporting queries." }, "entities": [ { "name": "JournalEntry", "description": "Represents a single line item within a financial transaction, recording a debit or credit amount. It links the amount to a specific GL Account, office, and transaction date. It also stores reference information to the originating business event." } ] }, { "name": "Product Mapping", "description": "This aggregate manages the configuration rules that link portfolio products to the general ledger. It defines which GL accounts should be debited or credited for specific financial activities such as disbursements, repayments, or interest posting. The aggregate supports different accounting methodologies, including cash-based and accrual-based accounting. It ensures that financial transactions generated by the portfolio modules are automatically and correctly reflected in the accounting system. It handles mappings for various product types including loans, savings, and shares.", "repository": { "name": "ProductToGLAccountMappingRepository", "description": "This repository persists the configuration linking financial products to GL accounts. It allows for the retrieval of mapping rules based on product ID and financial activity type. It ensures that the accounting engine can resolve the correct accounts during transaction processing." }, "entities": [ { "name": "ProductToGLAccountMapping", "description": "Defines a specific rule linking a product and a financial activity to a GL Account. It stores the product type, the specific payment or charge type, and the target account. This entity drives the automated accounting logic." }, { "name": "FinancialActivityAccount", "description": "Maps system-wide financial activities, such as asset transfers, to specific GL accounts. It ensures that non-product specific financial movements are correctly recorded. It is used for system-level accounting configurations." } ] } ] }, { "name": "Infrastructure", "description": "The Infrastructure Bounded Context provides the foundational technical services and cross-cutting concerns required by the application. It manages system configuration, security, multi-tenancy, and extensibility features like data tables and hooks. This context handles the scheduling and execution of background jobs and batch processes. It also provides the audit trail mechanism to track all state-changing commands within the system. Additionally, it manages reference data codes and values used throughout the platform.", "aggregates": [ { "name": "Scheduled Job", "description": "This aggregate manages the definition, scheduling, and execution of background tasks and batch jobs. It allows administrators to configure job frequencies using cron expressions and manage job parameters. The aggregate tracks the execution history of jobs, including start times, end times, and status outcomes. It supports the handling of custom job parameters passed as JSON. It ensures that critical system processes run reliably and provides visibility into their performance.", "repository": { "name": "ScheduledJobDetailRepository", "description": "This repository manages the persistence of job configurations and their runtime states. It allows for retrieving job details by ID or name and updating their schedules. It is used to coordinate job execution across the system." }, "entities": [ { "name": "ScheduledJobDetail", "description": "Represents the configuration of a background job, including its name and cron schedule. It tracks the current status of the job and the next scheduled run time. It serves as the blueprint for job execution." }, { "name": "ScheduledJobRunHistory", "description": "Records the outcome of a specific execution instance of a scheduled job. It stores the start time, end time, status, and any error messages. This entity provides an audit log for background processing." } ] }, { "name": "Command Source", "description": "The Command Source aggregate serves as the central audit log for all state-changing operations within the system. It captures the details of every API command, including the request payload, the user who initiated it, and the result. This aggregate supports the 'Maker-Checker' workflow by tracking commands that require approval before execution. It ensures accountability and traceability for all business actions. It also handles idempotency to prevent duplicate processing of the same command.", "repository": { "name": "CommandSourceRepository", "description": "This repository stores the history of all commands executed in the system. It supports querying for audit logs based on entity, action, and user. It is essential for the maker-checker functionality and system auditing." }, "entities": [ { "name": "CommandSource", "description": "Represents a single command or action performed within the system. It stores the JSON payload, the action name, the entity affected, and the processing status. It links the action to the user and the resulting resource ID." } ] }, { "name": "Data Table", "description": "This aggregate provides the extensibility mechanism to attach custom data fields to core system entities. It manages the registration of dynamic tables and the validation rules for their usage. The aggregate allows the system to store and retrieve additional data without altering the core database schema. It supports the configuration of checks that enforce data entry in these tables during specific workflow steps. It enables the application to adapt to specific client data requirements.", "repository": { "name": "RegisteredDatatableRepository", "description": "This repository manages the metadata for registered data tables. It allows the system to look up custom tables associated with specific application entities. It supports the dynamic schema management of these extensions." }, "entities": [ { "name": "RegisteredDatatable", "description": "Stores the metadata definition of a custom data table, including its name and linked core entity. It defines the relationship between the extension table and the application table. It is used to dynamically resolve data storage locations." }, { "name": "EntityDatatableChecks", "description": "Defines validation rules that require a data table to be populated for a specific entity status. It enforces business rules by preventing workflow transitions if required data is missing. It links a data table to a product and status." } ] } ] }, { "name": "Loan Portfolio", "description": "This bounded context manages the entire lifecycle of lending products and individual loan accounts within the financial institution. It handles the definition of loan products, the processing of loan applications, and the management of active loans including disbursements, repayments, and interest calculations. The context enforces complex business rules regarding amortization schedules, interest recalculation, and delinquency tracking. It serves as the core financial engine for the lending side of the portfolio, ensuring accurate ledger updates and state transitions. Additionally, it manages the configuration of loan terms, variable installments, and associated charges.", "aggregates": [ { "name": "Loan Account", "description": "The Loan Account aggregate is the central transactional entity representing a borrower's liability. It manages the state of the loan from submission to closure, handling complex financial logic such as interest accrual, repayment allocation, and schedule generation. It enforces rules regarding valid state transitions, such as preventing disbursement before approval. The aggregate maintains consistency between the loan summary, the repayment schedule, and the history of transactions. It also integrates with collateral and charge entities to provide a complete financial picture.", "repository": { "name": "LoanRepository", "description": "This repository provides persistence and retrieval mechanisms for Loan entities. It supports complex queries to filter loans by status, client, or office hierarchy. It ensures that loan data is loaded with necessary associations for processing while managing lazy loading to optimize performance." }, "entities": [ { "name": "Loan", "description": "The root entity representing the loan agreement, holding current balances, status, and configuration. It orchestrates the behavior of child entities and enforces the loan's lifecycle state machine. It serves as the primary point of interaction for loan-related business logic." }, { "name": "LoanTransaction", "description": "Represents a financial event on the loan, such as a repayment, disbursement, or waiver. It records the amount, date, and type of transaction, linking it to the specific repayment schedule installment it affects. It provides an immutable audit trail of financial movements." }, { "name": "LoanRepaymentScheduleInstallment", "description": "Defines a specific period within the loan term, detailing the principal, interest, fees, and penalties due. It tracks the paid and outstanding amounts for that specific period. This entity is crucial for determining the delinquency status of the loan." }, { "name": "LoanCharge", "description": "Represents a fee or penalty applied to the loan account. It tracks the calculation method, amount due, and amount paid for specific charges. It links the financial charge definition to the specific loan instance." }, { "name": "LoanAccountLock", "description": "Manages concurrency locks for loan accounts during batch processing. It prevents simultaneous updates to the same loan by different processes. It ensures data integrity during Close of Business operations." } ] }, { "name": "Loan Product", "description": "The Loan Product aggregate defines the templates and configuration rules for creating new loans. It encapsulates settings for interest rates, accounting rules, repayment frequencies, and credit checks. This aggregate ensures that all loans created under a specific product adhere to the institution's policy constraints. It manages the lifecycle of the product definition itself, including valid dates and availability. It serves as a factory configuration for the Loan Account aggregate.", "repository": { "name": "LoanProductRepository", "description": "This repository handles the storage and retrieval of LoanProduct definitions. It allows for the management of product configurations and ensures that active products can be efficiently queried for loan creation. It supports filtering products based on currency and other attributes." }, "entities": [ { "name": "LoanProduct", "description": "The root entity defining the configuration parameters for a specific type of loan offering. It holds rules for interest calculation, amortization, and accounting mappings. It acts as a blueprint for instantiating individual Loan entities." }, { "name": "LoanProductInterestRecalculationDetails", "description": "Stores configuration details regarding how interest should be recalculated for loans under this product. It defines compounding frequencies and rescheduling strategies. This entity ensures that complex interest rules are persisted alongside the product." }, { "name": "LoanProductGuaranteeDetails", "description": "Defines the requirements for guarantors associated with loans of this product type. It specifies mandatory guarantee percentages and funding sources. It enforces risk management policies at the product level." } ] }, { "name": "Delinquency Management", "description": "This aggregate manages the classification and tracking of overdue loans. It defines buckets and ranges to categorize loans based on the duration of their arrears. The aggregate provides the logic to apply delinquency tags to loans, which can trigger specific workflows or reporting. It ensures that the institution can accurately assess portfolio risk. It maintains a history of delinquency state changes for audit and analysis.", "repository": { "name": "DelinquencyBucketRepository", "description": "This repository manages the persistence of delinquency classification rules. It allows for the retrieval of bucket definitions used to categorize overdue loans. It ensures that delinquency configurations are available for the loan aging processes." }, "entities": [ { "name": "DelinquencyBucket", "description": "A container entity that groups multiple delinquency ranges together. It represents a specific policy or schema for classifying overdue loans. It allows different products to use different delinquency definitions." }, { "name": "DelinquencyRange", "description": "Defines a specific time interval (e.g., 30-60 days) for classifying a loan's overdue status. It is associated with a bucket and provides a classification label. It is used to determine the specific tag applied to a loan." }, { "name": "LoanDelinquencyTagHistory", "description": "Tracks the history of delinquency tags applied to a specific loan over time. It records when a loan entered or exited a specific delinquency range. This entity provides a temporal view of the loan's risk profile." } ] } ] }, { "name": "Savings & Deposits", "description": "This bounded context handles the management of deposit accounts, including standard savings, fixed deposits, and recurring deposits. It manages the entire lifecycle of these accounts from application to maturity or closure. The context enforces rules regarding interest posting, compounding, and withdrawal limits. It integrates with the transaction processing system to handle deposits, withdrawals, and transfers. Additionally, it manages the configuration of savings products and their associated interest rate charts.", "aggregates": [ { "name": "Savings Account", "description": "The Savings Account aggregate represents the customer's deposit account and manages its financial state. It handles transactions, enforces minimum balance rules, and calculates interest based on configured schedules. It supports specialized behaviors for fixed and recurring deposits, such as lock-in periods and maturity calculations. The aggregate ensures consistency between the account balance and the transaction history. It also manages the association with clients and groups.", "repository": { "name": "SavingsAccountRepository", "description": "This repository provides data access for SavingsAccount entities and their specialized subclasses. It supports retrieving accounts by client, status, or external identifier. It handles the persistence of account state changes and transaction links." }, "entities": [ { "name": "SavingsAccount", "description": "The core entity representing a deposit account, tracking balance, status, and interest settings. It serves as the base class for specialized deposit types. It manages the list of transactions and charges associated with the account." }, { "name": "FixedDepositAccount", "description": "A specialized extension of SavingsAccount representing a fixed-term deposit. It includes logic for maturity dates, pre-closure penalties, and deposit term constraints. It enforces rules specific to time-bound investments." }, { "name": "RecurringDepositAccount", "description": "A specialized extension of SavingsAccount for recurring deposit schemes. It manages the schedule of mandatory installment payments. It tracks the progress of the recurring deposit against the agreed schedule." }, { "name": "SavingsAccountTransaction", "description": "Represents a financial movement within the savings account, such as a deposit or withdrawal. It records the amount, date, and resulting balance. It serves as the immutable ledger entry for the account." } ] }, { "name": "Interest Rate Chart", "description": "This aggregate defines the rules for calculating interest rates based on deposit amounts and terms. It manages a collection of rate slabs that determine the applicable interest rate for a given scenario. The aggregate ensures that rate definitions do not overlap and cover the necessary ranges. It supports the application of incentives based on client attributes. It is a critical component for the profitability and attractiveness of deposit products.", "repository": { "name": "InterestRateChartRepository", "description": "This repository manages the persistence of interest rate charts and their associated slabs. It allows for the retrieval of active rate configurations for products and accounts. It ensures that historical rate data is preserved." }, "entities": [ { "name": "InterestRateChart", "description": "The root entity defining a scheme of interest rates valid for a specific period. It groups multiple slabs and defines the primary grouping field (amount or term). It is linked to savings products or individual accounts." }, { "name": "InterestRateChartSlab", "description": "Defines a specific interest rate applicable for a defined range of amounts or terms. It holds the actual percentage value and the boundary conditions. It is a child entity of the InterestRateChart." }, { "name": "InterestIncentives", "description": "Represents conditional interest rate adjustments based on client attributes like gender or age. It allows for targeted marketing or social performance incentives. It modifies the base rate defined in the slab." } ] } ] }, { "name": "Client & Group Management", "description": "This bounded context is responsible for managing the customer base of the financial institution. It handles the creation and lifecycle of individual clients, groups, and centers. It manages Know Your Customer (KYC) data through client identifiers and documents. The context also handles the hierarchical relationships between clients, groups, and centers. It serves as the source of truth for customer identity and demographic information.", "aggregates": [ { "name": "Client", "description": "The Client aggregate represents the individual customer and serves as the root for all customer-related data. It manages personal details, activation status, and associations with offices and staff. It enforces business rules regarding client onboarding and state transitions. The aggregate also manages the collection of identification documents and family member details. It is the primary entity for linking financial accounts to individuals.", "repository": { "name": "ClientRepository", "description": "This repository handles the persistence and retrieval of Client entities. It supports searching clients by name, identifier, or location. It ensures that client data is securely stored and accessible for portfolio operations." }, "entities": [ { "name": "Client", "description": "The core entity representing a customer, holding demographic and status information. It manages the lifecycle state (pending, active, closed) of the customer. It serves as the anchor for all client-specific associations." }, { "name": "ClientIdentifier", "description": "Represents a specific identification document (e.g., passport, national ID) linked to a client. It stores the document type and unique key. It is used for KYC compliance and identity verification." }, { "name": "ClientNonPerson", "description": "Captures details for clients that are legal entities (e.g., businesses) rather than individuals. It stores incorporation details and other corporate attributes. It extends the client profile to support business banking." } ] }, { "name": "Group", "description": "The Group aggregate manages collections of clients organized for lending or social purposes. It handles the hierarchy of groups and centers, including staff assignments and meeting schedules. It enforces rules regarding group composition and lifecycle states. The aggregate facilitates group lending methodologies by linking clients together. It also manages the transfer of clients between groups.", "repository": { "name": "GroupRepository", "description": "This repository provides data access for Group and Center entities. It supports hierarchical queries to retrieve groups within centers or offices. It manages the persistence of group structures and memberships." }, "entities": [ { "name": "Group", "description": "Represents a collection of clients or other groups (centers). It manages the membership list and the group's status. It serves as a context for group loans and meetings." }, { "name": "GroupLevel", "description": "Defines the hierarchical level of a group entity (e.g., Center vs. Group). It configures the rules for recursion and client membership at that level. It ensures the structural integrity of the group hierarchy." }, { "name": "GroupRole", "description": "Defines a specific role assigned to a client within a group (e.g., Leader, Treasurer). It links a client to a group with a specific responsibility. It allows for the delegation of duties within the group structure." } ] } ] }, { "name": "Notifications", "description": "The Notifications Bounded Context is responsible for managing communication with clients and staff via various channels. It handles the creation, scheduling, and execution of SMS and Email campaigns. This context allows the institution to send marketing messages, transaction alerts, and account updates. It tracks the delivery status of messages and integrates with external gateways for transmission. It also manages the configuration for different notification providers.", "aggregates": [ { "name": "SMS Campaign", "description": "This aggregate manages the lifecycle of SMS marketing and notification campaigns. It allows users to define message content, target audiences, and scheduling triggers. The aggregate handles the generation of individual SMS messages based on the campaign configuration. It tracks the status of the campaign and the delivery success of generated messages. It supports both direct and event-triggered SMS dispatch.", "repository": { "name": "SmsCampaignRepository", "description": "This repository persists SMS campaign configurations and their states. It allows for retrieving active campaigns and those due for execution. It supports the management of campaign triggers and schedules." }, "entities": [ { "name": "SmsCampaign", "description": "Defines the configuration for a bulk SMS initiative, including the message template and trigger rules. It tracks the campaign's active status and schedule. It links to the report used to select recipients." }, { "name": "SmsMessage", "description": "Represents an individual SMS queued for delivery or already sent. It stores the recipient's number, the message body, and the delivery status. It provides a record of communication history." } ] }, { "name": "Email Campaign", "description": "The Email Campaign aggregate handles the definition and execution of email-based communications. It supports the configuration of email subjects, bodies, and attachment generation from reports. The aggregate manages the scheduling of emails and the tracking of their sent status. It integrates with SMTP configuration to dispatch messages. It allows for targeted communication based on business rules and reports.", "repository": { "name": "EmailCampaignRepository", "description": "This repository manages the storage of email campaign definitions. It supports querying for campaigns that need to be triggered based on time or events. It is used to persist the state of email marketing efforts." }, "entities": [ { "name": "EmailCampaign", "description": "Stores the settings for an email campaign, including subject, body, and attachment preferences. It defines the schedule or trigger for sending emails. It manages the lifecycle state of the campaign." }, { "name": "EmailMessage", "description": "Represents a specific email generated for a recipient. It contains the final message content, recipient address, and status. It tracks whether the email was successfully sent or failed." }, { "name": "EmailConfiguration", "description": "Stores the SMTP server settings and credentials required to send emails. It defines the host, port, and security protocols for the mail server. It is essential for the email service to function." } ] } ] }, { "name": "Investor", "description": "The Investor Bounded Context manages the relationship between the financial institution and external asset owners. It handles the sale and buyback of loan assets, tracking ownership transfers and their financial implications. This context ensures that loans owned by external parties are correctly identified and that payments are allocated appropriately. It maintains a history of asset transfers and integrates with the accounting system to record sale and buyback transactions. It supports the management of investor portfolios.", "aggregates": [ { "name": "External Asset Owner", "description": "This aggregate represents the external investors or entities that purchase loan assets. It manages the identity and details of these third-party owners. The aggregate serves as the parent entity for tracking which assets are currently owned by which investor. It ensures that unique external identifiers are maintained for integration purposes. It is central to the asset externalization workflow.", "repository": { "name": "ExternalAssetOwnerRepository", "description": "This repository manages the persistence of external asset owner entities. It allows for the retrieval of owner details by their internal or external identifiers. It supports the management of investor profiles." }, "entities": [ { "name": "ExternalAssetOwner", "description": "Represents an external investor entity in the system. It stores the owner's name and unique external identifier. It acts as the counterparty in asset transfer transactions." } ] }, { "name": "Asset Transfer", "description": "The Asset Transfer aggregate manages the lifecycle of transferring loan ownership to and from external investors. It records the details of sales, buybacks, and cancellations, including settlement dates and purchase prices. The aggregate links specific loans to transfer events and tracks the status of these transactions. It also maintains mappings to accounting journal entries to ensure financial traceability. It enforces business rules regarding when a loan can be transferred.", "repository": { "name": "ExternalAssetOwnerTransferRepository", "description": "This repository persists the records of asset transfer transactions. It supports querying for active transfers, transfer history, and transfers associated with specific loans. It is key to tracking asset ownership changes." }, "entities": [ { "name": "ExternalAssetOwnerTransfer", "description": "Records a specific transaction transferring ownership of assets. It includes the transfer status, settlement date, and purchase price. It links the investor to the transfer event." }, { "name": "ExternalAssetOwnerTransferLoanMapping", "description": "Maps a specific loan account to an asset transfer record. It establishes the link between the portfolio loan and the investor transaction. It is used to identify which loans are currently externalized." } ] } ] }, { "name": "Credit Bureau", "description": "The Credit Bureau Bounded Context facilitates the integration with external credit reporting agencies. It manages the configuration of credit bureau connections and the mapping of loan products to credit check requirements. This context handles the retrieval, storage, and viewing of credit reports for clients. It ensures that credit checks are performed according to configured rules during the loan origination process. It acts as a bridge between the core banking system and external credit data providers.", "aggregates": [ { "name": "Credit Bureau Configuration", "description": "This aggregate manages the setup and configuration of external credit bureaus. It stores connection details, product mappings, and organization-specific settings. The aggregate defines which loan products require credit checks and how those checks should be performed. It allows the institution to configure multiple credit bureaus and link them to different products. It ensures that the system knows how to communicate with external credit services.", "repository": { "name": "CreditBureauConfigurationRepository", "description": "This repository manages the persistence of credit bureau configuration settings. It allows for retrieving configuration parameters by bureau ID or key. It supports the dynamic setup of credit bureau integrations." }, "entities": [ { "name": "CreditBureau", "description": "Represents a credit bureau agency definition. It stores the bureau's name, country, and implementation class key. It serves as the root definition for a credit provider." }, { "name": "CreditBureauLoanProductMapping", "description": "Configures the relationship between a loan product and a credit bureau. It defines rules such as whether a credit check is mandatory. It links the product configuration to the bureau definition." } ] }, { "name": "Credit Report", "description": "The Credit Report aggregate manages the credit data retrieved from external bureaus. It stores the raw report content, often as binary data, linked to a specific client and bureau. The aggregate allows for the persistence and retrieval of historical credit reports for review. It ensures that credit information is associated with the correct national ID or client identifier. It serves as the local cache of external credit information.", "repository": { "name": "CreditReportRepository", "description": "This repository handles the storage and retrieval of credit report data. It supports fetching reports based on client identifiers and bureau IDs. It allows the system to access previously fetched credit reports." }, "entities": [ { "name": "CreditReport", "description": "Stores the actual credit report data received from a bureau. It contains the binary report file and associated metadata like the national ID. It represents a snapshot of a client's credit history." } ] } ] }, { "name": "Organization & Administration", "description": "This bounded context manages the operational structure and security of the institution. It defines the hierarchy of offices, the staff members, and the user authentication system. It also handles cash management through the teller module. The context provides the foundational configuration for currency, working days, and holidays. It ensures that the system reflects the physical and logical organization of the business.", "aggregates": [ { "name": "Teller Management", "description": "The Teller Management aggregate controls the cash handling operations within branches. It manages the assignment of cashiers to tellers and tracks cash allocations and settlements. It enforces limits and validates transaction dates to ensure cash accountability. The aggregate serves as the bridge between physical cash movements and digital transaction records. It ensures that cashiers have sufficient funds for disbursements.", "repository": { "name": "TellerRepository", "description": "This repository manages the persistence of Teller definitions. It allows for the retrieval of tellers associated with specific offices. It supports the configuration of cash management points." }, "entities": [ { "name": "Teller", "description": "Represents a physical or logical point of service for cash transactions. It is associated with a specific office and tracks its operational status. It serves as the parent entity for cashier assignments." }, { "name": "Cashier", "description": "Represents a staff member assigned to a teller for a specific period. It tracks the duration of the assignment and the type of operations allowed. It links the human resource to the cash management function." }, { "name": "CashierTransaction", "description": "Records specific cash movements (allocation, settlement) involving a cashier. It tracks the amount and type of cash transfer. It provides an audit trail for cash handling activities." } ] }, { "name": "User Administration", "description": "The User Administration aggregate manages system access and security. It handles the creation of application users, role assignments, and permission configurations. It enforces password policies and authentication rules. The aggregate ensures that only authorized personnel can access specific data and functions. It serves as the gatekeeper for the application's security model.", "repository": { "name": "AppUserRepository", "description": "This repository handles the storage and retrieval of application user accounts. It supports looking up users by username or office. It is critical for the authentication and authorization processes." }, "entities": [ { "name": "AppUser", "description": "Represents a system user who can log in and perform actions. It links to staff records and holds authentication credentials. It is the central entity for identity management." }, { "name": "Role", "description": "Defines a set of permissions that can be assigned to a user. It groups access rights into logical job functions. It simplifies the management of user privileges." }, { "name": "Permission", "description": "Represents a granular access right to a specific resource or action. It defines what operations are allowed within the system. It is the fundamental building block of the authorization model." } ] } ] }, { "name": "Shared Services", "description": "This bounded context provides cross-cutting functionality used by multiple other contexts. It includes the notification system for user alerts, the template engine for document generation, and the tax management module. It ensures that common infrastructure needs are met in a standardized way. This context decouples auxiliary services from the core business domains.", "aggregates": [ { "name": "Notification", "description": "The Notification aggregate manages the generation and tracking of system alerts. It captures events from other domains and creates notification records for users. It tracks the read status of notifications to ensure users are aware of important activities. The aggregate serves as the internal messaging backbone for user awareness. It supports different types of notifications based on business events.", "repository": { "name": "NotificationRepository", "description": "This repository manages the persistence of notification events. It allows for the retrieval of notifications for specific users. It supports the tracking of unread notifications." }, "entities": [ { "name": "Notification", "description": "Represents a specific alert or message generated by the system. It contains the content, actor, and target of the event. It serves as the persistent record of the notification." }, { "name": "NotificationMapper", "description": "Maps a notification to a specific user recipient. It tracks whether the user has read the notification. It allows a single notification event to be distributed to multiple users." } ] }, { "name": "Tax Management", "description": "The Tax Management aggregate defines the configuration for tax calculations. It groups tax components into tax groups to allow for complex tax structures. It manages the validity periods and rates for different taxes. The aggregate ensures that tax rules are applied consistently across different financial products. It serves as the central definition for tax logic.", "repository": { "name": "TaxGroupRepository", "description": "This repository handles the persistence of Tax Group definitions. It allows for the retrieval of tax configurations used by products. It ensures that tax mappings are stored correctly." }, "entities": [ { "name": "TaxGroup", "description": "Represents a collection of tax components applied together. It allows for the aggregation of multiple taxes into a single rule. It manages the lifecycle of tax associations." }, { "name": "TaxComponent", "description": "Defines a specific tax type and its rate. It includes validity dates to handle rate changes over time. It is the fundamental unit of tax calculation." } ] } ] } ] }, { "category": "potentialMicroservices", "label": "Potential Microservices", "data": [ { "name": "Loan Portfolio Service", "description": "This microservice is responsible for the end-to-end lifecycle management of loan accounts and products. It encapsulates the complex financial logic required for loan origination, approval workflows, disbursement, repayment processing, and interest calculation. The service manages loan product configurations, including amortization schedules, delinquency tracking, and penalty calculations. It also handles advanced features such as collateral management and variable installments. By isolating this domain, the system can independently scale the heavy calculation engines required for schedule generation and interest accrual without affecting other modules.", "entities": [ { "name": "Loan", "description": "The core entity representing a loan account, tracking principal, interest, and repayment schedules.", "attributes": [ "id", "accountNo", "principal", "interestRate", "termFrequency", "status", "repaymentSchedule" ] }, { "name": "LoanProduct", "description": "Defines the configuration and terms for a specific type of loan offering.", "attributes": [ "id", "name", "shortName", "currency", "amortizationMethod", "interestMethod", "minPrincipal", "maxPrincipal" ] }, { "name": "LoanTransaction", "description": "Records financial events associated with a loan, such as repayments, waivers, or disbursements.", "attributes": [ "id", "transactionDate", "amount", "transactionType", "principalPortion", "interestPortion" ] }, { "name": "LoanCollateral", "description": "Assets pledged by a borrower to secure a loan.", "attributes": [ "id", "value", "description", "collateralType", "loanId" ] } ], "endpoints": [ { "path": "/api/v1/loans", "method": "POST", "description": "Submits a new loan application for a client or group." }, { "path": "/api/v1/loans/{loanId}", "method": "GET", "description": "Retrieves detailed information about a specific loan account." }, { "path": "/api/v1/loans/{loanId}/transactions", "method": "POST", "description": "Processes a transaction (repayment, waiver, etc.) against a loan." }, { "path": "/api/v1/loanproducts", "method": "GET", "description": "Lists available loan products and their configurations." } ], "operations": [ { "operation": "Submit Loan Application", "method": "POST", "description": "Creates a new loan application with specific terms and links it to a client." }, { "operation": "Approve Loan", "method": "POST", "description": "Transitions a loan application from pending to approved status." }, { "operation": "Disburse Loan", "method": "POST", "description": "Releases funds to the borrower and activates the repayment schedule." }, { "operation": "Make Repayment", "method": "POST", "description": "Records a payment against the loan, allocating funds to principal, interest, and fees." } ] }, { "name": "Savings and Deposits Service", "description": "This microservice manages the complete lifecycle of savings accounts, fixed deposits, and recurring deposits. It handles the definition of savings products, including interest compounding rules, posting periods, and lock-in settings. The service is responsible for processing transactions such as deposits, withdrawals, and transfers, as well as calculating and posting interest to accounts. It ensures accurate balance tracking and enforces rules regarding minimum balances and withdrawal limits. This separation ensures that the distinct financial logic of liability products is decoupled from asset products.", "entities": [ { "name": "SavingsAccount", "description": "Represents a customer's savings account holding a balance and transaction history.", "attributes": [ "id", "accountNo", "accountBalance", "status", "clientId", "minRequiredBalance" ] }, { "name": "SavingsProduct", "description": "Defines the terms, interest rates, and currency for a savings offering.", "attributes": [ "id", "name", "nominalAnnualInterestRate", "currencyCode", "interestCompoundingPeriodType" ] }, { "name": "FixedDepositAccount", "description": "A specialized deposit account held for a fixed term with specific maturity rules.", "attributes": [ "id", "depositAmount", "maturityDate", "depositPeriod", "preClosurePenalInterest" ] }, { "name": "InterestRateChart", "description": "Defines interest rate slabs based on deposit amounts or periods.", "attributes": [ "id", "fromDate", "endDate", "chartSlabs" ] } ], "endpoints": [ { "path": "/api/v1/savingsaccounts", "method": "POST", "description": "Opens a new savings account for a client." }, { "path": "/api/v1/savingsaccounts/{accountId}/transactions", "method": "POST", "description": "Performs a deposit or withdrawal transaction on a savings account." }, { "path": "/api/v1/fixeddepositaccounts", "method": "GET", "description": "Retrieves a list of fixed deposit accounts." }, { "path": "/api/v1/savingsproducts", "method": "POST", "description": "Creates a new savings product definition." } ], "operations": [ { "operation": "Deposit Funds", "method": "POST", "description": "Credits an amount to a savings account." }, { "operation": "Withdraw Funds", "method": "POST", "description": "Debits an amount from a savings account, checking for sufficient funds." }, { "operation": "Post Interest", "method": "POST", "description": "Calculates and credits accrued interest to savings accounts based on the product configuration." }, { "operation": "Activate Account", "method": "POST", "description": "Transitions a savings account from pending to active status." } ] }, { "name": "Client Management Service", "description": "This microservice acts as the central registry for all customer data, managing individual clients, groups, and centers. It handles Know Your Customer (KYC) requirements, addresses, and hierarchical relationships within the organization. The service manages the organizational hierarchy of customers, including group memberships, staff assignments, and family member details. It serves as the central source of truth for customer data, supporting other services like Loans and Savings. Isolating this allows for better data governance and compliance management.", "entities": [ { "name": "Client", "description": "Represents an individual or corporate customer of the financial institution.", "attributes": [ "id", "firstname", "lastname", "accountNo", "status", "officeId", "mobileNo" ] }, { "name": "Group", "description": "Represents a collection of clients organized for joint liability or meeting purposes.", "attributes": [ "id", "name", "officeId", "staffId", "hierarchy" ] }, { "name": "ClientIdentifier", "description": "Identification documents associated with a client (e.g., Passport, National ID).", "attributes": [ "id", "documentKey", "documentType", "status" ] }, { "name": "Address", "description": "Stores physical address details for a client.", "attributes": [ "street", "city", "state", "postalCode", "country" ] } ], "endpoints": [ { "path": "/api/v1/clients", "method": "POST", "description": "Registers a new client in the system." }, { "path": "/api/v1/clients/{clientId}", "method": "GET", "description": "Retrieves client profile information." }, { "path": "/api/v1/groups", "method": "POST", "description": "Creates a new client group." }, { "path": "/api/v1/clients/{clientId}/identifiers", "method": "POST", "description": "Adds a new identification document to a client." } ], "operations": [ { "operation": "Create Client", "method": "POST", "description": "Onboards a new client into the system." }, { "operation": "Activate Client", "method": "POST", "description": "Activates a pending client, allowing them to access financial products." }, { "operation": "Assign Staff", "method": "POST", "description": "Assigns a staff member to manage a client or group." }, { "operation": "Update Address", "method": "PUT", "description": "Modifies the address details of a client." } ] }, { "name": "Accounting Service", "description": "This microservice manages the General Ledger (GL), Chart of Accounts, and financial reporting data. It processes journal entries generated by other services (like Loans and Savings) and maintains the financial health of the organization. It handles accounting closures, accruals, and financial activity mappings. This separation ensures the integrity of financial data and allows for independent scaling of reporting and ledger processing.", "entities": [ { "name": "GLAccount", "description": "Represents a General Ledger account in the Chart of Accounts.", "attributes": [ "id", "name", "glCode", "type", "usage" ] }, { "name": "JournalEntry", "description": "Represents a double-entry accounting record.", "attributes": [ "id", "transactionDate", "amount", "entryType", "glAccountId" ] }, { "name": "GLClosure", "description": "Represents the closure of an accounting period.", "attributes": [ "id", "closingDate", "isDeleted", "officeId" ] } ], "endpoints": [ { "path": "/api/v1/glaccounts", "method": "GET", "description": "Retrieves the Chart of Accounts." }, { "path": "/api/v1/journalentries", "method": "POST", "description": "Creates a manual journal entry." }, { "path": "/api/v1/glclosures", "method": "POST", "description": "Closes the accounting books for a specific period." } ], "operations": [ { "operation": "Create GL Account", "method": "POST", "description": "Adds a new account to the Chart of Accounts." }, { "operation": "Post Journal Entry", "method": "POST", "description": "Records a debit or credit transaction in the ledger." }, { "operation": "Define Opening Balances", "method": "POST", "description": "Sets the initial balances for GL accounts." } ] }, { "name": "Identity & Access Management Service", "description": "This microservice handles user authentication, authorization, and role management for the entire platform. It manages application users, roles, permissions, and security policies such as password rotation and validation. It acts as the central authority for securing access to all other microservices, ensuring consistent security enforcement. It also manages the mapping between users and clients for self-service access.", "entities": [ { "name": "AppUser", "description": "Represents a system user with login credentials.", "attributes": [ "id", "username", "email", "officeId", "staffId", "enabled" ] }, { "name": "Role", "description": "Defines a set of permissions that can be assigned to users.", "attributes": [ "id", "name", "description", "disabled" ] }, { "name": "Permission", "description": "Granular access control right to perform a specific action.", "attributes": [ "grouping", "code", "entityName", "actionName" ] }, { "name": "PasswordValidationPolicy", "description": "Configuration for password strength and security requirements.", "attributes": [ "regex", "description", "active" ] } ], "endpoints": [ { "path": "/api/v1/authentication", "method": "POST", "description": "Authenticates a user and returns a token." }, { "path": "/api/v1/users", "method": "POST", "description": "Creates a new application user." }, { "path": "/api/v1/roles", "method": "GET", "description": "Lists available user roles." }, { "path": "/api/v1/permissions", "method": "PUT", "description": "Updates the permissions associated with a role." } ], "operations": [ { "operation": "Authenticate", "method": "POST", "description": "Verifies credentials and establishes a session." }, { "operation": "Create User", "method": "POST", "description": "Provisions a new user account with specific roles and office access." }, { "operation": "Update Permissions", "method": "PUT", "description": "Modifies the access rights associated with a specific role." }, { "operation": "Update Password Policy", "method": "PUT", "description": "Changes the global password validation policy." } ] }, { "name": "Notification Service", "description": "This microservice manages both outbound communications (SMS, Email) and internal system notifications. It handles the creation and scheduling of marketing campaigns as well as transactional alerts generated by business events. The service integrates with external gateways to deliver messages and tracks the read/unread status of internal notifications for users. This separation decouples communication logic from core business processes and allows for scalable event handling.", "entities": [ { "name": "SmsCampaign", "description": "Defines a marketing or notification campaign via SMS.", "attributes": [ "id", "campaignName", "message", "triggerType", "status" ] }, { "name": "Notification", "description": "Represents a notification event generated by the system for a user.", "attributes": [ "objectType", "objectIdentifier", "action", "actor", "notificationContent" ] }, { "name": "EmailMessage", "description": "Represents an individual email to be sent.", "attributes": [ "id", "emailAddress", "subject", "body", "status" ] } ], "endpoints": [ { "path": "/api/v1/smscampaigns", "method": "POST", "description": "Creates a new SMS campaign." }, { "path": "/api/v1/notifications", "method": "GET", "description": "Retrieves a list of notifications for the authenticated user." }, { "path": "/api/v1/sms", "method": "POST", "description": "Sends a direct SMS message." } ], "operations": [ { "operation": "Create Campaign", "method": "POST", "description": "Configures a new notification campaign." }, { "operation": "Fetch Notifications", "method": "GET", "description": "Gets unread or all notifications for the current user." }, { "operation": "Send SMS", "method": "POST", "description": "Dispatches a single SMS message." }, { "operation": "Mark as Read", "method": "PUT", "description": "Updates the state of a notification to indicate it has been viewed." } ] }, { "name": "Document Management Service", "description": "This microservice handles the storage, retrieval, and management of documents and images associated with system entities. It abstracts the underlying storage mechanism (File System, S3) and provides APIs for uploading and downloading files. This allows for centralized handling of binary data and attachments, ensuring that other services remain lightweight. It supports linking documents to various parent entities like clients or loans.", "entities": [ { "name": "Document", "description": "Metadata for an uploaded file.", "attributes": [ "id", "parentEntityType", "parentEntityId", "name", "fileName", "location" ] }, { "name": "Image", "description": "Represents an image associated with a client or staff.", "attributes": [ "id", "location", "storageType" ] } ], "endpoints": [ { "path": "/api/v1/{entityType}/{entityId}/documents", "method": "POST", "description": "Uploads a document for a specific entity." }, { "path": "/api/v1/{entityType}/{entityId}/images", "method": "POST", "description": "Uploads or updates an image for an entity." }, { "path": "/api/v1/documents/{documentId}", "method": "GET", "description": "Downloads a specific document." } ], "operations": [ { "operation": "Upload Document", "method": "POST", "description": "Stores a file and links it to an entity." }, { "operation": "Retrieve Image", "method": "GET", "description": "Fetches the image associated with a client or staff." }, { "operation": "Delete Document", "method": "DELETE", "description": "Removes a document and its metadata." } ] }, { "name": "Reporting & Analytics Service", "description": "This microservice is responsible for generating reports, running ad-hoc queries, and managing data tables. It supports various output formats like PDF, CSV, and JSON and allows for the definition of dynamic 'stretchy' reports. It integrates with external reporting tools and manages custom datatables that extend core entities. Separating this ensures that heavy reporting loads do not impact the performance of transactional services.", "entities": [ { "name": "Report", "description": "Definition of a system report including SQL query.", "attributes": [ "id", "reportName", "reportType", "reportSql" ] }, { "name": "Datatable", "description": "Custom data table definition extending core entities.", "attributes": [ "applicationTableName", "registeredTableName", "columnDefinitions" ] }, { "name": "AdHoc", "description": "User-defined ad-hoc query configuration.", "attributes": [ "id", "name", "query", "tableName" ] } ], "endpoints": [ { "path": "/api/v1/runreports/{reportName}", "method": "GET", "description": "Executes a report and returns the data." }, { "path": "/api/v1/datatables/{datatable}", "method": "GET", "description": "Retrieves data from a custom datatable." }, { "path": "/api/v1/reports", "method": "POST", "description": "Creates a new report definition." } ], "operations": [ { "operation": "Run Report", "method": "GET", "description": "Generates a report based on parameters." }, { "operation": "Register Datatable", "method": "POST", "description": "Creates a new custom data table linked to an entity." }, { "operation": "Create AdHoc Query", "method": "POST", "description": "Saves a custom SQL query for future use." } ] }, { "name": "Social Performance Management Service", "description": "This service is responsible for managing surveys and scorecards related to social performance monitoring. It allows the definition of custom surveys with specific components, questions, and response options. The service enables the capture of scorecard data for clients, linking survey results to specific users and timelines. It supports the creation of lookup tables for scoring logic, distinct from financial transactions.", "entities": [ { "name": "Survey", "description": "Defines a questionnaire or survey structure.", "attributes": [ "key", "name", "countryCode", "validFrom", "validTo" ] }, { "name": "Question", "description": "A specific question within a survey.", "attributes": [ "text", "key", "sequenceNo", "componentKey" ] }, { "name": "Scorecard", "description": "Represents a completed survey for a client.", "attributes": [ "surveyId", "clientId", "userId", "submittedOnDate" ] }, { "name": "LookupTable", "description": "Reference data for scoring survey responses.", "attributes": [ "key", "score", "valueFrom", "valueTo" ] } ], "endpoints": [ { "path": "/api/v1/surveys", "method": "POST", "description": "Creates a new survey definition." }, { "path": "/api/v1/surveys", "method": "GET", "description": "Retrieves a list of active surveys." }, { "path": "/api/v1/scorecards", "method": "POST", "description": "Submits a new scorecard entry for a client." }, { "path": "/api/v1/scorecards", "method": "GET", "description": "Retrieves scorecard details for a specific survey and client." } ], "operations": [ { "operation": "Create Survey", "method": "POST", "description": "Defines a new survey with questions and options." }, { "operation": "Submit Scorecard", "method": "POST", "description": "Records the responses for a survey taken by a client." }, { "operation": "Retrieve Scorecards", "method": "GET", "description": "Fetches historical survey results for analysis." } ] } ] }, { "category": "inferredArchitecture", "label": "Inferred Architecture", "data": [ { "internalComponents": [ { "name": "User Account Management", "description": "Manages all aspects of user identity and profiles. This component is responsible for user registration, authentication, and authorization processes. It also handles profile updates, password resets, and maintains user data integrity." }, { "name": "Product Catalog Service", "description": "Provides a centralized source for all product-related information. It handles the creation, retrieval, updating, and deletion of products and their associated categories and attributes. This service also powers product search and filtering capabilities for customers." }, { "name": "Order Processing Service", "description": "Orchestrates the entire lifecycle of a customer order. Its responsibilities include managing the shopping cart, creating new orders, calculating totals, and tracking order status from placement to fulfillment. It ensures that orders are correctly recorded and communicated to other relevant systems." }, { "name": "Payment Gateway", "description": "Acts as a secure interface for handling all financial transactions. This component is responsible for processing payments, handling refunds, and communicating with external payment providers. It ensures that all payment operations are secure, reliable, and properly logged for auditing." } ], "externalDependencies": [ { "name": "Primary Database", "type": "Database", "description": "A PostgreSQL relational database used as the main persistence layer for core business entities like users, products, and orders." }, { "name": "Stripe API", "type": "External API", "description": "External payment processing service used to securely handle credit card transactions and other payment methods." }, { "name": "Search Index", "type": "Cache", "description": "An Elasticsearch cluster used to provide fast, full-text search capabilities over the product catalog." }, { "name": "Notification Queue", "type": "Message Queue", "description": "A RabbitMQ message queue used to asynchronously dispatch notifications, such as order confirmation emails and shipping updates." } ], "dependencies": [ { "from": "User Account Management", "to": "Primary Database", "description": "Stores and retrieves user account information, credentials, and profiles." }, { "from": "Product Catalog Service", "to": "Primary Database", "description": "Persists and fetches product data, including details, pricing, and inventory levels." }, { "from": "Product Catalog Service", "to": "Search Index", "description": "Pushes product data updates to the search index to keep search results current." }, { "from": "Order Processing Service", "to": "User Account Management", "description": "Retrieves customer details to associate with a new order." }, { "from": "Order Processing Service", "to": "Product Catalog Service", "description": "Fetches product information and validates availability when creating an order." }, { "from": "Order Processing Service", "to": "Payment Gateway", "description": "Initiates a payment request for the order total." }, { "from": "Order Processing Service", "to": "Primary Database", "description": "Saves the created order and its line items to the database." }, { "from": "Order Processing Service", "to": "Notification Queue", "description": "Publishes an event to send an order confirmation notification to the user." }, { "from": "Payment Gateway", "to": "Stripe API", "description": "Delegates the actual payment processing to the external Stripe service." } ] } ] } ], "dbInteractions": [ { "path": "fineract-db/multi-tenant-demo-backups/ceda/README.md", "mechanism": "DDL", "name": "CEDA Microfinance Demo Database", "description": "The text describes a database initialization package containing DDL scripts for schema creation and DML for reference data insertion. It specifically targets the customization of code tables and the addition of new tables for client and loan data.", "databaseName": "unknown", "tablesAccessed": [ "m_code", "m_code_value", "client datatables", "loan datatables" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "Schema creation (DDL) and reference data insertion (DML).", "transactionHandling": "unknown", "protocol": "SQL", "connectionInfo": "unknown", "codeExample": "n/a" }, { "path": "fineract-db/old-schema-files/0001a-mifosplatform-core-ddl-latest.sql", "mechanism": "DDL", "description": "The file is a raw SQL script used to define the database schema for a core banking application. It does not use an ORM or application code directly but is likely executed by a database migration tool or during initial system setup. It defines the structure for a relational database (MySQL/MariaDB) including tables, columns, data types, and foreign key constraints.", "databaseName": "Mifos X / Apache Fineract (Inferred)", "tablesAccessed": [ "m_currency", "m_organisation_currency", "c_configuration", "m_code", "m_code_value", "m_document", "r_enum_value", "x_registered_table", "m_calendar", "m_calendar_instance", "m_office", "m_office_transaction", "m_permission", "m_role", "m_role_permission", "m_appuser", "m_appuser_role", "m_portfolio_command_source", "m_charge", "m_fund", "m_staff", "m_group_level", "m_group", "m_client", "m_client_identifier", "m_group_client", "m_product_loan", "m_product_loan_charge", "m_loan", "m_loan_arrears_aging", "m_guarantor", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_savings_product", "m_savings_account", "m_savings_account_transaction", "m_note", "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "rpt_sequence", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter" ], "operationType": [ "DDL" ], "queryPatterns": "CREATE TABLE statements, DROP TABLE statements, Foreign Key definitions", "transactionHandling": "Implicit DDL transactions (SET foreign_key_checks)", "protocol": "MySQL / MariaDB (InnoDB)", "codeExample": "CREATE TABLE `m_currency` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `code` varchar(3) NOT NULL,\n `decimal_places` SMALLINT NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/latam-demo/README.md", "mechanism": "DDL", "name": "latam Demo Database", "description": "The documentation describes the initialization script for a demo database, including the Data Definition Language (DDL) for the schema and Data Manipulation Language (DML) for seeding reference data.", "databaseName": "latam Demo", "tablesAccessed": [ "currency", "office", "permission", "role", "app_user", "configuration", "code" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "Database schema creation and initial reference data seeding.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "DDL of latest schema\n- Minimum reference data required for deployment of platform" }, { "path": "fineract-db/multi-tenant-demo-backups/latam-demo/bk_latam.sql", "mechanism": "DDL", "name": "fineract_default", "description": "The file is a MySQL database dump that primarily uses Data Definition Language (DDL) to create the database schema for the Fineract/Mifos application. It defines tables, primary keys, and foreign key constraints. It also uses Data Manipulation Language (DML) to insert initial seed data into various tables.", "databaseName": "fineract_default", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "extra_client_details", "extra_family_details", "extra_loan_details", "m_appuser", "m_appuser_role", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_deposit_account", "m_deposit_account_transaction", "m_document", "m_fund", "m_group", "m_group_client", "m_guarantor", "m_loan", "m_loan_charge", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_deposit", "m_product_loan", "m_product_loan_charge", "m_product_savings", "m_role", "m_role_permission", "m_saving_account", "m_saving_account_transaction", "m_saving_schedule", "m_staff", "r_enum_value", "rpt_sequence", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT operations, Foreign Key constraints", "transactionHandling": "LOCK TABLES / UNLOCK TABLES for bulk inserts", "protocol": "MySQL 5.1.60", "codeExample": "DROP TABLE IF EXISTS `acc_gl_account`;\nCREATE TABLE `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(45) NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/gk-maarg/0001b-gk-datatables.sql", "mechanism": "DDL", "name": "Risk Analysis Schema", "description": "The code interacts with the database by defining structural elements using SQL DDL. It drops an existing table if present and creates a new one with specific column definitions and constraints.", "databaseName": "mifos/fineract (inferred from m_client reference)", "tablesAccessed": [ "risk_analysis", "m_client" ], "operationType": [ "DDL" ], "queryPatterns": "CREATE TABLE statements with Foreign Key constraints", "transactionHandling": "Implicit DDL transaction handling", "protocol": "MySQL / MariaDB (InnoDB)", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `risk_analysis` (\n `client_id` BIGINT NOT NULL,\n `proposed_loan_amount` decimal(19,6) DEFAULT NULL,\n ...\n CONSTRAINT `FK_risk_analysis_1` FOREIGN KEY (`client_id`) REFERENCES `m_client` (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-provider/src/test/resources/features/infrastructure/infrastructure.core.feature", "mechanism": "DDL", "name": "Liquibase / Flyway", "description": "The file contains acceptance tests for the database schema migration process, verifying that Liquibase and Flyway correctly manage schema upgrades for tenant and default databases based on instance configuration.", "databaseName": "tenant store, default tenant", "tablesAccessed": [ "schema_version (Flyway)", "databasechangelog (Liquibase)", "All Application Tables" ], "operationType": [ "DDL", "ADMIN" ], "queryPatterns": "Database schema migration execution and version verification", "transactionHandling": "Managed implicitly by the migration tools (Liquibase/Flyway) during execution", "protocol": "Database Agnostic", "connectionInfo": "n/a", "codeExample": "Given Liquibase is enabled with a default tenant\n Given Liquibase runs the very first time for the tenant store\n Given A previously Flyway migrated tenant store database on the latest version\n When The database migration process is executed\n Then The tenant store and the default tenant gets synced and then upgraded" }, { "path": "fineract-db/docker/01-databases.sql", "mechanism": "DDL", "name": "Fineract Database Setup", "description": "The file uses raw SQL DDL and DCL commands to provision the database server. It creates specific logical databases required by the application architecture and configures user access rights.", "databaseName": "fineract_tenants, fineract_default", "tablesAccessed": [], "operationType": [ "DDL", "ADMIN" ], "queryPatterns": "CREATE DATABASE statements and GRANT privilege commands", "transactionHandling": "Implicit auto-commit for DDL statements", "protocol": "MySQL", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE DATABASE IF NOT EXISTS `fineract_tenants`;\nCREATE DATABASE IF NOT EXISTS `fineract_default`;\nGRANT ALL ON *.* TO 'root'@'%';" }, { "path": "fineract-db/multi-tenant-demo-backups/bare-bones-demo/README.md", "mechanism": "DDL", "name": "Demo Database Initialization", "description": "The documentation describes the SQL DDL and DML scripts used to initialize the database schema and populate mandatory reference data.", "databaseName": "unknown", "tablesAccessed": [ "currency", "office", "permission", "role", "appuser", "code", "configuration" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "Database schema creation and initial reference data insertion.", "transactionHandling": "unknown", "protocol": "SQL", "connectionInfo": "n/a", "codeExample": "Its mandatory to have one selected currency so we default to US Dollar" }, { "path": "fineract-db/multi-tenant-demo-backups/latam-demo/datatables-on-latam-demo.sql", "mechanism": "DDL", "name": "Mifos/Fineract Database Extension", "description": "The code integrates with the database primarily through SQL scripts that execute DDL commands to define new schema objects and DML commands to seed reference data. It directly interacts with the database engine to create tables and establish foreign key relationships with existing core tables (`m_client`, `m_loan`). The script also performs write operations to insert configuration data into specific tenant schemas.", "databaseName": "mifostenant-latam", "tablesAccessed": [ "latam_extra_client_details", "latam_family_details", "latam_extra_loan_details", "m_client", "m_loan", "m_code", "m_code_value" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements with Foreign Key constraints, INSERT statements for reference data", "transactionHandling": "Implicit auto-commit per statement (standard SQL script behavior)", "protocol": "MySQL / MariaDB (InnoDB Engine)", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `latam_extra_client_details` (\n `client_id` BIGINT NOT NULL,\n `Business Description` varchar(100) DEFAULT NULL,\n PRIMARY KEY (`client_id`),\n CONSTRAINT `FK_latam_extra_client_details` FOREIGN KEY (`client_id`) REFERENCES `m_client` (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-provider/src/main/resources/sql/migrations/sample_data/tn03_interop_sample_data.sql", "mechanism": "DML", "name": "Data Initialization Script", "description": "The file is a raw SQL script containing Data Manipulation Language (DML) statements used to seed the database with initial test data. It utilizes MySQL-specific user variables to maintain referential integrity between inserted records without needing hardcoded IDs.", "databaseName": "tn03", "tablesAccessed": [ "m_client", "m_savings_product", "m_savings_account", "interop_identifier", "m_charge", "m_savings_account_charge" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "The script uses a pattern of setting variables via SELECT statements to fetch Foreign Keys, followed by INSERT statements using those variables.", "transactionHandling": "Implicit transaction handling (auto-commit) is assumed as no explicit BEGIN/COMMIT statements are present.", "protocol": "MySQL", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO interop_identifier (id, account_id, type, a_value, sub_value_or_type, created_by, created_on, modified_by, modified_on)\nVALUES (NULL, @saving_acc_id, 'IBAN', @IBAN, NULL, 'operator', CURDATE(), 'operator',\n CURDATE());" }, { "path": "fineract-db/old-schema-files/0003-mifosx-permissions-and-authorisation-utf8.sql", "mechanism": "DML", "name": "Mifos/Fineract Database Seeding", "description": "The file interacts with the database purely through SQL Data Manipulation Language (DML) scripts. It performs extensive data seeding operations using `INSERT` statements to populate permission, role, and user tables. It also utilizes `INSERT ... SELECT` patterns to dynamically generate data based on the contents of other tables (`x_registered_table`) and performs `UPDATE` operations to set default configuration flags.", "databaseName": "Mifos/Fineract (implied by username 'mifos')", "tablesAccessed": [ "m_permission", "m_role", "m_role_permission", "m_appuser", "m_appuser_role", "x_registered_table" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Bulk INSERT statements, INSERT-SELECT subqueries for dynamic data generation, and bulk UPDATE statements.", "transactionHandling": "Implicit transaction handling typical of SQL script execution (Auto-commit unless wrapped externally).", "protocol": "MySQL / MariaDB (indicated by backtick usage)", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO `m_permission`\n(`grouping`,`code`,`entity_name`,`action_name`,`can_maker_checker`) VALUES\n('special','ALL_FUNCTIONS',NULL,NULL,0),\n('special','ALL_FUNCTIONS_READ',NULL,NULL,0),\n('special', 'CHECKER_SUPER_USER', NULL, NULL, '0');" }, { "path": "fineract-db/old-schema-files/0002-mifosx-base-reference-data-utf8.sql", "mechanism": "DML", "name": "Reference Data Seeding", "description": "The file consists entirely of SQL DML statements used to insert initial seed data into the database. It interacts directly with the database tables to populate rows for configurations, enums, currencies, and organizational structures using standard INSERT syntax and INSERT-SELECT patterns.", "databaseName": "Mifos/Fineract Schema", "tablesAccessed": [ "c_configuration", "r_enum_value", "m_currency", "m_organisation_currency", "m_office", "m_group_level", "m_code", "m_code_value" ], "operationType": [ "WRITE" ], "queryPatterns": "Bulk INSERT statements and INSERT INTO ... SELECT subqueries for referential integrity.", "transactionHandling": "Implicit transaction handling typical of SQL scripts.", "protocol": "MySQL / SQL Standard", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO `c_configuration`\n(`name`, `enabled`)\nVALUES\n('maker-checker', 0);" }, { "path": "fineract-db/old-schema-files/0004-mifosx-core-reports-utf8.sql", "mechanism": "DML", "name": "Reporting Module Configuration", "description": "The file uses Data Manipulation Language (DML) to populate configuration tables that drive a dynamic reporting engine. It uses TRUNCATE to clear tables and INSERT to add report definitions. Notably, the 'stretchy_report' table stores raw SQL SELECT statements as string data within the 'report_sql' column; these stored queries perform complex joins across the master data tables (m_office, m_client, m_loan) when executed by the application layer.", "databaseName": "Mifos/Fineract Schema", "tablesAccessed": [ "stretchy_report", "stretchy_parameter", "stretchy_report_parameter", "m_permission", "m_office", "m_client", "m_loan", "m_staff", "m_product_loan", "m_fund", "r_enum_value", "m_code_value", "m_currency", "m_loan_arrears_aging", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_appuser_role", "m_role", "m_role_permission" ], "operationType": [ "WRITE", "READ" ], "queryPatterns": "The script performs bulk INSERTs containing embedded dynamic SQL queries. The embedded queries utilize complex joins, aggregations, and variable substitution (e.g., ${officeId}).", "transactionHandling": "Implicit transaction handling typical of SQL script execution.", "protocol": "MySQL / MariaDB (inferred from syntax like `concat`, `ifnull`, and backticks)", "connectionInfo": "not applicable for SQL files", "codeExample": "truncate table stretchy_report;\nINSERT INTO `stretchy_report` VALUES (1,'Client Listing','Table',NULL,'Client','select ... from m_office ...');\ninsert into m_permission(grouping, `code`, entity_name, action_name, can_maker_checker)\nselect 'report', concat('READ_', r.report_name), r.report_name, 'READ', false\nfrom stretchy_report r;" }, { "path": "org.apache.fineract.infrastructure.security.service", "mechanism": "DRIVER", "name": "Database Driver Utilities", "description": "The class interacts directly with database driver utilities (specifically PostgreSQL's core Utils) to perform SQL escaping. It also uses the DatabaseTypeResolver to determine which logic to apply.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "PostgreSQL / MySQL", "connectionInfo": "n/a", "codeExample": "Utils.escapeLiteral(null, literal, true).toString()" }, { "path": "README.md", "mechanism": "JDBC", "name": "HikariCP", "description": "The application integrates with relational databases (MariaDB, MySQL, PostgreSQL) using JDBC drivers and manages connections via the HikariCP connection pool. It supports multi-tenancy by connecting to specific databases (e.g., 'fineract_tenants') configured via environment variables or application properties. Database schemas are initialized and managed using Gradle tasks and Liquibase migrations, with strict enforcement of UTC timezones at the JDBC driver level.", "databaseName": "fineract_tenants, fineract_default", "tablesAccessed": [ "not identifiable from code" ], "operationType": [ "READ_WRITE", "DDL" ], "queryPatterns": "Database creation and schema migration scripts, partitioned batch processing for 'Close of Business' jobs, and standard CRUD operations implied by the core banking functionality.", "transactionHandling": "Spring Batch is explicitly used for partitioning large jobs like 'Close of Business' across worker nodes; general transaction management is likely handled by Spring Boot's transaction management but is not explicitly detailed in the provided text.", "protocol": "MariaDB 10.9, MySQL, PostgreSQL", "connectionInfo": "JDBC URL parameters (e.g., serverTimezone=UTC) and environment variables (e.g., FINERACT_HIKARI_*)", "codeExample": "export FINERACT_HIKARI_PASSWORD=verysecret\n./gradlew createDB -PdbName=fineract_tenants\njava -Dloader.path=. -jar fineract-provider/build/libs/fineract-provider.jar" }, { "path": "fineract-provider/src/main/resources/application.properties", "mechanism": "JDBC", "name": "HikariCP DataSource", "description": "The file configures the primary JDBC connection pool using HikariCP. It defines the database driver, connection URL, credentials, and pool sizing properties (min/max connections, timeouts). It also includes specific configuration for a multi-tenant architecture, defining parameters for a default tenant database and separate read-only connection details. Additionally, it enables Liquibase for automated database schema management and migrations.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE", "DDL" ], "queryPatterns": "Configuration for connection pooling, transaction isolation levels, and schema migration scripts.", "transactionHandling": "Configures the JDBC transaction isolation level to TRANSACTION_REPEATABLE_READ and manages auto-commit settings for the connection pool.", "protocol": "MariaDB / MySQL", "connectionInfo": "jdbc:mariadb://localhost:3306/fineract_tenants", "codeExample": "spring.datasource.hikari.driverClassName=${FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME:org.mariadb.jdbc.Driver}\nspring.datasource.hikari.jdbcUrl=${FINERACT_HIKARI_JDBC_URL:jdbc:mariadb://localhost:3306/fineract_tenants}\nspring.datasource.hikari.username=${FINERACT_HIKARI_USERNAME:root}\nspring.datasource.hikari.password=${FINERACT_HIKARI_PASSWORD:mysql}\nspring.datasource.hikari.minimumIdle=${FINERACT_HIKARI_MINIMUM_IDLE:3}" }, { "path": "fineract-provider/src/test/resources/application-test.properties", "mechanism": "JDBC", "name": "HikariCP Datasource", "description": "The file configures the primary application datasource using Spring Boot's HikariCP integration. It specifies the MariaDB JDBC driver, connection credentials, and pooling parameters (minimum idle connections, maximum pool size). It also enables specific driver-level performance optimizations including server-side prepared statements and batched statement rewriting.", "databaseName": "fineract_tenants", "tablesAccessed": [ "not identifiable from code" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Configures driver-level optimizations for prepared statement caching and batched statement rewriting.", "transactionHandling": "Configures auto-commit to true at the pool level and defines retry logic for optimistic locking exceptions.", "protocol": "MariaDB", "connectionInfo": "jdbc:mariadb://localhost:3306/fineract_tenants", "codeExample": "spring.datasource.hikari.driverClassName=org.mariadb.jdbc.Driver\nspring.datasource.hikari.jdbcUrl=jdbc:mariadb://localhost:3306/fineract_tenants\nspring.datasource.hikari.username=root\nspring.datasource.hikari.password=[REDACTED]\nspring.datasource.hikari.minimumIdle=3\nspring.datasource.hikari.maximumPoolSize=10" }, { "path": "docker-compose-postgresql-kafka.yml", "mechanism": "JDBC", "name": "Fineract PostgreSQL / HikariCP", "description": "The file configures the application services to connect to a PostgreSQL container using JDBC. It defines the connection string, credentials, and extensive HikariCP connection pool settings (such as pool size, timeouts, and auto-commit behavior) through environment variables passed to the `fineract-manager` and `fineract-worker` containers.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a (Configuration file)", "transactionHandling": "Configured as auto-commit=true via environment variable FINERACT_HIKARI_AUTO_COMMIT.", "protocol": "PostgreSQL 15.3", "connectionInfo": "jdbc:postgresql://fineractpostgresql:5432/fineract_tenants", "codeExample": " - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants\n - FINERACT_HIKARI_USERNAME=postgres\n - FINERACT_HIKARI_PASSWORD=REDACTED\n - FINERACT_HIKARI_AUTO_COMMIT=true" }, { "path": "custom/docker/docker-compose.yml", "mechanism": "JDBC", "name": "MariaDB", "description": "The file configures the application's database connection via environment variables that are passed to the Fineract server container. It specifies the MariaDB JDBC driver, connection URL, credentials, and specific HikariCP pool settings (like pool size, timeouts, and cache properties) to establish connectivity with the `fineractmysql` service.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE", "ADMIN" ], "queryPatterns": "n/a", "transactionHandling": "Configures auto-commit to true via FINERACT_HIKARI_AUTO_COMMIT environment variable.", "protocol": "MariaDB 11.0", "connectionInfo": "jdbc:mariadb://fineractmysql:3306/fineract_tenants", "codeExample": "environment:\n - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.mariadb.jdbc.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:mariadb://fineractmysql:3306/fineract_tenants\n - FINERACT_HIKARI_USERNAME=root\n - FINERACT_HIKARI_PASSWORD=[REDACTED]" }, { "path": "docker-compose.yml", "mechanism": "JDBC", "name": "MariaDB", "description": "The file configures the database infrastructure by defining a MariaDB service and passing JDBC connection parameters to the application service via environment variables. It sets up the Hikari connection pool settings, including the driver class, JDBC URL, and credentials, allowing the Fineract server to communicate with the database container.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE", "DDL", "ADMIN" ], "queryPatterns": "n/a", "transactionHandling": "Auto-commit is enabled via the environment variable FINERACT_HIKARI_AUTO_COMMIT=true.", "protocol": "MariaDB 11.0", "connectionInfo": "jdbc:mariadb://fineractmysql:3306/fineract_tenants", "codeExample": "environment:\n - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.mariadb.jdbc.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:mariadb://fineractmysql:3306/fineract_tenants\n - FINERACT_HIKARI_USERNAME=root\n - FINERACT_HIKARI_PASSWORD=[REDACTED]" }, { "path": "docker-compose-postgresql.yml", "mechanism": "JDBC", "name": "PostgreSQL / HikariCP", "description": "The file configures the database infrastructure and defines the JDBC connection parameters for the application. It spins up a PostgreSQL container and injects JDBC connection strings, credentials, and HikariCP pool settings into the application container via environment variables.", "databaseName": "fineract_tenants", "tablesAccessed": [ "not identifiable from code" ], "operationType": [ "ADMIN", "READ_WRITE" ], "queryPatterns": "n/a (Configuration file)", "transactionHandling": "HikariCP auto-commit set to true via environment variable", "protocol": "PostgreSQL 15.3", "connectionInfo": "jdbc:postgresql://fineractpostgresql:5432/fineract_tenants", "codeExample": "environment:\n - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants\n - FINERACT_HIKARI_USERNAME=postgres\n - FINERACT_HIKARI_PASSWORD=[REDACTED]" }, { "path": "kubernetes/fineract-server-deployment.yml", "mechanism": "JDBC", "name": "fineractmysql", "description": "The file configures the database integration by injecting JDBC environment variables into the container. It specifies the MariaDB JDBC driver and connection URL, linking the application to the `fineract_tenants` database hosted on the `fineractmysql` service.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a (configuration only)", "transactionHandling": "n/a (configuration only)", "protocol": "MariaDB", "connectionInfo": "jdbc:mariadb://fineractmysql:3306/fineract_tenants", "codeExample": " - name: FINERACT_HIKARI_DRIVER_CLASS_NAME\n value: org.mariadb.jdbc.Driver\n - name: FINERACT_HIKARI_JDBC_URL\n value: jdbc:mariadb://fineractmysql:3306/fineract_tenants" }, { "path": "docker-compose-postgresql-kafka-msk.yml", "mechanism": "JDBC", "name": "fineractpostgresql", "description": "The file configures the Fineract application containers to connect to the PostgreSQL database container using JDBC. It passes connection details, credentials, and HikariCP connection pool configuration settings through environment variables.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Configuration for HikariCP connection pooling, prepared statement caching, and slow query logging.", "transactionHandling": "Transaction behavior is configured via environment variables, specifically setting auto-commit to true.", "protocol": "PostgreSQL 15.3", "connectionInfo": "jdbc:postgresql://fineractpostgresql:5432/fineract_tenants", "codeExample": " - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants\n - FINERACT_HIKARI_USERNAME=postgres\n - FINERACT_HIKARI_PASSWORD=[REDACTED]\n - FINERACT_HIKARI_AUTO_COMMIT=true" }, { "path": "docker-compose-postgresql-activemq.yml", "mechanism": "JDBC", "name": "fineractpostgresql", "description": "The code configures the application to connect to a PostgreSQL database container named 'fineractpostgresql'. It uses environment variables to inject JDBC connection details, including the driver class, URL, credentials, and HikariCP connection pool settings, into the Fineract application runtime.", "databaseName": "fineract_tenants", "tablesAccessed": [ "not identifiable from configuration file" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "not identifiable from configuration file", "transactionHandling": "The configuration explicitly sets auto-commit to true via the 'FINERACT_HIKARI_AUTO_COMMIT' environment variable.", "protocol": "PostgreSQL 15.3", "connectionInfo": "jdbc:postgresql://fineractpostgresql:5432/fineract_tenants", "codeExample": "environment:\n - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver\n - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants\n - FINERACT_HIKARI_USERNAME=postgres\n - FINERACT_HIKARI_PASSWORD=[REDACTED]" }, { "path": "com.acme.fineract.loan.job", "mechanism": "JDBC", "name": "JobRepository", "description": "The class interacts with the database indirectly through the Spring Batch 'JobRepository'. This component is responsible for persisting the state of the batch job (JobInstance, JobExecution, StepExecution, etc.) to the underlying database tables (typically BATCH_JOB_INSTANCE, BATCH_JOB_EXECUTION, etc.).", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_JOB_EXECUTION_PARAMS", "BATCH_STEP_EXECUTION", "BATCH_STEP_EXECUTION_CONTEXT", "BATCH_JOB_EXECUTION_CONTEXT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal CRUD operations for job metadata", "transactionHandling": "Spring PlatformTransactionManager", "protocol": "JDBC", "connectionInfo": "Managed by Spring Context (DataSource)", "codeExample": "new JobBuilder(AcmeJobName.ACME_NOOP_JOB.name(), jobRepository)" }, { "path": "org.apache.fineract", "mechanism": "JDBC", "name": "Fineract Database Configuration", "description": "The application configures a DataSource for an external database and initializes Liquibase for schema migrations. The Javadoc explicitly mentions the use of a 'normal' external database configured via `DataSourceProperties`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE", "DDL" ], "queryPatterns": "Database migrations and connection pooling initialization", "transactionHandling": "Spring Boot default transaction management", "protocol": "JDBC", "connectionInfo": "Configured via external properties (DataSourceProperties)", "codeExample": "@Import({ FineractWebApplicationConfiguration.class, FineractLiquibaseOnlyApplicationConfiguration.class })" }, { "path": "org.apache.fineract.accounting.closure.service", "mechanism": "JDBC", "name": "GLClosureReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually constructs SQL strings that join the main closure table with user and office tables to populate data transfer objects.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_closure", "m_appuser", "m_office" ], "operationType": [ "READ" ], "queryPatterns": "SQL SELECT queries with multiple joins (acc_gl_closure, m_appuser, m_office) and dynamic WHERE clauses.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, rm, finalObjectArray);" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.service", "mechanism": "JDBC", "name": "FinancialActivityAccountReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It joins the 'acc_gl_financial_activity_account' table with 'acc_gl_account' to retrieve detailed information about financial activity mappings.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_financial_activity_account", "acc_gl_account" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with INNER JOINs", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring", "codeExample": "this.jdbcTemplate.query(sql, financialActivityAccountMapper, new Object[] {});" }, { "path": "org.apache.fineract.accounting.glaccount.jobs.updatetrialbalancedetails", "mechanism": "JDBC", "name": "RoutingDataSourceServiceFactory", "description": "The class uses Spring's JdbcTemplate for complex aggregation queries and bulk inserts, and a Spring Data repository wrapper for entity updates.", "databaseName": "m_trial_balance", "tablesAccessed": [ "acc_gl_journal_entry", "m_trial_balance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Complex aggregation queries with subqueries, bulk INSERT INTO ... SELECT statements, and standard JPA entity saves.", "transactionHandling": "Likely handled by the Spring Batch framework wrapping the Tasklet execution.", "protocol": "SQL", "connectionInfo": "Derived from RoutingDataSourceServiceFactory", "codeExample": "final StringBuilder sqlBuilder = new StringBuilder(600);\nsqlBuilder.append(\"Insert Into m_trial_balance(office_id, account_id, Amount, entry_date, created_date,closing_balance) \")\n .append(\"Select je.office_id, je.account_id, SUM(CASE WHEN je.type_enum=1 THEN (-1) * je.amount ELSE je.amount END) \")\n .append(\"as Amount, Date(je.entry_date) as Entry_Date, je.transaction_date as Created_Date,sum(je.amount) as closing_balance \")\n .append(\"from acc_gl_journal_entry je WHERE je.transaction_date = ? \")\n .append(\"group by je.account_id, je.office_id, je.transaction_date, Date(je.entry_date)\");\nfinal int result = jdbcTemplate.update(sqlBuilder.toString(), tbGap);" }, { "path": "org.apache.fineract.accounting.glaccount.service.GLAccountReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually maps ResultSets to objects using inner class RowMappers. It constructs dynamic SQL strings to handle optional filtering criteria.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_account", "m_code_value", "acc_gl_journal_entry", "acc_accounting_rule", "acc_rule_tags" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation with string concatenation, LEFT JOINs, subqueries for aggregations (max/group by), and parameter binding.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, rm, finalObjectArray);" }, { "path": "org.apache.fineract.accounting.journalentry.service.JournalEntryReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It dynamically builds SQL strings based on filter criteria and maps the results to Java objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_journal_entry", "acc_gl_account", "m_office", "m_appuser", "m_currency", "m_loan_transaction", "m_savings_account_transaction", "m_payment_detail", "m_payment_type", "m_note" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation with complex joins across multiple tables.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + rm.schema() + \" where journalEntry.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, glJournalEntryId);" }, { "path": "org.apache.fineract.accounting.journalentry.service.JournalEntryRunningBalanceUpdateServiceImpl", "mechanism": "JDBC", "name": "JournalEntryDatabaseService", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries and batch updates. It performs complex joins to calculate running balances and updates the journal entry table directly.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_journal_entry", "acc_gl_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code uses complex SQL queries involving aggregations (MIN, MAX), GROUP BY clauses, and self-joins to determine the state of balances prior to a specific date. It also uses batch UPDATE statements to modify records efficiently.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.batchUpdate(sql, params);" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service.ProductToGLAccountMappingReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ProductToGLAccountMappingReadPlatformService", "description": "The class uses Spring's JdbcTemplate to execute SQL SELECT queries. It manually constructs SQL strings involving joins between `acc_product_mapping`, `m_charge`, `acc_gl_account`, and `m_payment_type`. It uses a custom RowMapper to transform the ResultSet into a Map.", "databaseName": "unknown", "tablesAccessed": [ "acc_product_mapping", "m_charge", "acc_gl_account", "m_payment_type" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with dynamic criteria based on product type and mapping attributes.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + rm.schema() + \" and product_id = ? and payment_type is null and mapping.charge_id is null\";\nfinal List> listOfProductToGLAccountMaps = this.jdbcTemplate.query(sql, rm, new Object[] { PortfolioProductType.LOAN.getValue(), loanProductId });" }, { "path": "org.apache.fineract.accounting.provisioning.service.ProvisioningEntriesReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Provisioning Database Service", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs complex SQL strings involving joins across multiple tables (loans, clients, groups, provisioning mappings) and maps the results to Java objects using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_repayment_schedule", "m_loan", "m_loanproduct_provisioning_mapping", "m_provisioning_criteria_definition", "m_client", "m_group", "m_provisioning_history", "m_appuser", "m_loanproduct_provisioning_entry", "m_office", "m_product_loan", "m_provision_category", "acc_gl_account" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL queries with multiple LEFT JOINs, subqueries for date calculation, aggregations (SUM, MIN, MAX), and dynamic WHERE clauses.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, mapper, formattedDate, formattedDate, formattedDate);" }, { "path": "org.apache.fineract.accounting.rule.service.AccountingRuleReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's JdbcTemplate to interact directly with the relational database. It constructs SQL queries manually using StringBuilder and maps the results using custom ResultSetExtractor and RowMapper implementations. It performs READ operations involving joins across multiple tables to assemble complex domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_office", "acc_accounting_rule", "acc_gl_account", "m_code_value", "acc_rule_tags" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with manual mapping logic to handle one-to-many relationships and optional foreign keys.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + resultSetExtractor.schema() + \" and rule.id = ?\";\nfinal Map extractedData = this.jdbcTemplate.query(sql, resultSetExtractor, new Object[] { accountingRuleId });" }, { "path": "org.apache.fineract.adhocquery.service.AdHocReadPlatformServiceImpl", "mechanism": "JDBC", "name": "AdHocReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually constructs SQL strings using a schema defined in an inner RowMapper class and handles result set mapping manually.", "databaseName": "unknown", "tablesAccessed": [ "m_adhoc", "m_appuser" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with LEFT JOINs to fetch creator/modifier user details.", "transactionHandling": "None explicit (likely read-only auto-commit)", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "this.jdbcTemplate.query(sql, this.adHocRowMapper);" }, { "path": "org.apache.fineract.cob.loan", "mechanism": "JDBC", "name": "NamedParameterJdbcTemplate / LoanRepository", "description": "The class uses Spring's NamedParameterJdbcTemplate for complex partitioning queries that require window functions and dynamic SQL generation. It also uses a Spring Data JPA LoanRepository for standard retrieval operations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries (window functions for pagination) and simple CRUD operations via repository.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "sql.append(\"select min(id) as min, max(id) as max, page, count(id) as count from \");\nsql.append(\" (select floor(((row_number() over(order by id))-1) / :pageSize) as page, t.* from \");\n// ...\nreturn namedParameterJdbcTemplate.query(sql.toString(), parameters, RetrieveAllNonClosedLoanIdServiceImpl::mapRow);" }, { "path": "org.apache.fineract.cob.loan.LoanLockingServiceImpl", "mechanism": "JDBC", "name": "LoanLockingService Database Access", "description": "The class uses a mix of Spring JDBC (`JdbcTemplate`) for high-performance batch operations (inserts and updates) and Spring Data JPA (`LoanAccountLockRepository`) for standard retrieval and deletion. It interacts directly with the `m_loan_account_locks` table.", "databaseName": "m_loan_account_locks", "tablesAccessed": [ "m_loan_account_locks", "m_loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch inserts and updates using raw SQL for performance; standard JPA selects and deletes.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring", "codeExample": "jdbcTemplate.batchUpdate(\"INSERT INTO m_loan_account_locks ... VALUES (?,?,?,?,?)\", loanIds, loanIds.size(), (PreparedStatement ps, Long loanId) -> { ... });" }, { "path": "org.apache.fineract.cob.loan.RetrieveAllNonClosedLoanIdServiceImplTest", "mechanism": "JDBC", "name": "NamedParameterJdbcTemplate", "description": "Although this is a test class, it explicitly defines and verifies complex SQL queries intended for execution via Spring's NamedParameterJdbcTemplate. The queries use window functions to partition data from the m_loan table.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL queries using subqueries, aggregation (min, max, count), and window functions (row_number() over) for pagination/partitioning.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "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)..." }, { "path": "org.apache.fineract.commands.service", "mechanism": "JDBC", "name": "AuditReadPlatformService", "description": "The interface methods explicitly use `SQLBuilder`, a utility class in this application framework used to construct dynamic SQL queries for JDBC execution. This pattern indicates that the implementing class will perform direct database reads using JDBC (likely via Spring's JdbcTemplate) rather than an ORM like Hibernate, which is typical for 'ReadPlatformService' components in this architecture to ensure performance.", "databaseName": "unknown", "tablesAccessed": [ "m_portfolio_command_source" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation using SQLBuilder to filter audit logs based on variable criteria.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Collection retrieveAuditEntries(SQLBuilder extraCriteria, boolean includeJson);" }, { "path": "org.apache.fineract.commands.service.AuditReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Audit Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It dynamically builds SQL strings using StringBuilder to handle optional filtering criteria and pagination. It performs READ operations involving complex joins across multiple tables to aggregate audit information.", "databaseName": "unknown", "tablesAccessed": [ "m_portfolio_command_source", "m_appuser", "m_office", "m_group", "m_group_level", "m_client", "m_loan", "m_savings_account", "r_enum_value", "m_permission", "m_role_permission", "m_role", "m_appuser_role" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins, dynamic criteria generation, pagination, and aggregation.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, rm, extraCriteria.getArguments())" }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.service", "mechanism": "JDBC", "name": "AccountNumberFormatReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines a custom RowMapper to map columns from the 'c_account_number_format' table to the AccountNumberFormatData domain object.", "databaseName": "unknown", "tablesAccessed": [ "c_account_number_format" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with row mapping.", "transactionHandling": "None explicit (likely relies on default or upper-layer transaction management).", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + this.accountNumberFormatMapper.schema() + \" where anf.id = ?\";\nfinal AccountNumberFormatData accountNumberFormatData = this.jdbcTemplate.queryForObject(sql, this.accountNumberFormatMapper, new Object[] { id });" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "JDBC", "name": "EmailCampaignReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL schemas within inner mapper classes (EmailCampaignMapper and BusinessRuleMapper) which define the columns and joins. The queries retrieve data from tables like 'scheduled_email_campaign' and 'stretchy_report'.", "databaseName": "unknown", "tablesAccessed": [ "scheduled_email_campaign", "m_appuser", "stretchy_report", "stretchy_report_parameter", "stretchy_parameter" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries (left joins across multiple tables)", "transactionHandling": "None (Read-only operations)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, this.businessRuleMapper, searchType);" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "JDBC", "name": "EmailConfigurationReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database.", "databaseName": "unknown", "tablesAccessed": [ "scheduled_email_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with RowMapper", "transactionHandling": "NONE", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, this.emailConfigurationRowMapper);" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "JDBC", "name": "EmailReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "scheduled_email_messages_outbound" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with filtering by status, ID, and date ranges. Uses database-specific SQL generation for LIMIT clauses.", "transactionHandling": "None (Read-only operations)", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, this.emailRowMapper, EmailMessageStatusType.PENDING.getValue());" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignReadPlatformServiceImpl", "mechanism": "JDBC", "name": "SmsCampaign Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines SQL schemas within inner mapper classes to select data from the 'sms_campaign' table and join it with 'm_appuser' and 'stretchy_report' tables.", "databaseName": "unknown", "tablesAccessed": [ "sms_campaign", "m_appuser", "stretchy_report", "stretchy_report_parameter", "stretchy_parameter" ], "operationType": [ "READ" ], "queryPatterns": "Standard SELECT queries with LEFT JOINs to retrieve related entity data (users, reports). Dynamic SQL generation is used for pagination limits and offsets.", "transactionHandling": "NONE", "protocol": "JDBC", "connectionInfo": "Configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "final String sql = \"select \" + this.smsCampaignMapper.schema + \" where sc.id = ? and sc.is_visible = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, this.smsCampaignMapper, campaignId, isVisible);" }, { "path": "org.apache.fineract.infrastructure.codes.service", "mechanism": "JDBC", "name": "CodeValueReadPlatformService", "description": "The service uses Spring's JdbcTemplate to perform direct SQL SELECT operations against the database. It manually maps ResultSets to objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_code_value", "m_code" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with JOINs and WHERE clauses.", "transactionHandling": "None explicit (Read-only)", "protocol": "JDBC", "connectionInfo": "Configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "final String sql = \"select \" + rm.schema() + \"where c.code_name like ? and cv.is_active = true order by position\";\nreturn this.jdbcTemplate.query(sql, rm, new Object[] { code });" }, { "path": "org.apache.fineract.infrastructure.codes.service", "mechanism": "JDBC", "name": "CodeReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries against the database. It manually maps the ResultSet to CodeData objects using an inner RowMapper class.", "databaseName": "unknown", "tablesAccessed": [ "m_code" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with WHERE clauses and ORDER BY", "transactionHandling": "None explicit (likely read-only auto-commit)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + rm.schema() + \" where c.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, new Object[] { codeId });" }, { "path": "org.apache.fineract.infrastructure.configuration.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database to retrieve external service configurations.", "databaseName": "unknown", "tablesAccessed": [ "c_external_service" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with a WHERE clause filtering by service name.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "final String sql = \"SELECT es.name as name, es.id as id FROM c_external_service es where es.name='\" + serviceNameToUse + \"'\";\nfinal ExternalServicesData externalServicesData = this.jdbcTemplate.query(sql, resultSetExtractor);" }, { "path": "org.apache.fineract.infrastructure.configuration.service", "mechanism": "JDBC", "name": "ExternalServicesPropertiesReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to perform raw SQL read operations. It joins `c_external_service_properties` and `c_external_service` tables to retrieve key-value pairs for specific service configurations.", "databaseName": "unknown", "tablesAccessed": [ "c_external_service_properties", "c_external_service" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with INNER JOINs to filter by service name.", "transactionHandling": "None explicit (likely auto-commit or handled by caller)", "protocol": "SQL", "connectionInfo": "Managed by Spring DataSource via JdbcTemplate", "codeExample": "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 + \"'\";\nfinal S3CredentialsData s3CredentialsData = this.jdbcTemplate.query(sql, resultSetExtractor, new Object[] {});" }, { "path": "org.apache.fineract.infrastructure.configuration.service.ConfigurationReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ConfigurationReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to perform raw SQL queries against the database. It reads configuration data from the 'c_configuration' table and optionally joins with 'x_registered_table'.", "databaseName": "unknown", "tablesAccessed": [ "c_configuration", "x_registered_table" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with optional JOINs and WHERE clauses.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "final List globalConfiguration = this.jdbcTemplate.query(sql, this.rm, survey ? new Object[] { DataTableApiConstant.CATEGORY_PPI } : new Object[] {});" }, { "path": "org.apache.fineract.infrastructure.core", "mechanism": "JDBC", "name": "HikariCP Configuration", "description": "The code tests the configuration of HikariCP data sources for tenant database connections. It validates that the HikariConfig object is correctly populated with database credentials, URLs, and pool settings derived from tenant properties. While this is a test class and does not establish a real connection, it heavily utilizes JDBC and HikariCP APIs.", "databaseName": "fineract_tenants", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "MariaDB (JDBC)", "connectionInfo": "jdbc:mariadb://localhost:3306/fineract_tenants", "codeExample": "assertEquals(MASTER_DB_JDBC_URL, hikariConfig.getJdbcUrl());" }, { "path": "org.apache.fineract.infrastructure.core.LiquibaseStepDefinitions", "mechanism": "JDBC", "name": "TenantDataSourceFactory", "description": "This class tests database migration logic by mocking JDBC DataSources and Liquibase components. It does not perform actual database I/O but simulates various database states (e.g., first run, upgrade needed) to verify the upgrade service's behavior using Mockito.", "databaseName": "tenant_store_db", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC (Mocked)", "connectionInfo": "n/a", "codeExample": "given(databaseStateVerifier.isFirstLiquibaseMigration(tenantStoreDataSource)).willReturn(true);" }, { "path": "org.apache.fineract.infrastructure.core.boot.FineractLiquibaseOnlyApplicationConfiguration", "mechanism": "JDBC", "name": "Liquibase Database Migration Configuration", "description": "The class configures the application for database migrations using Liquibase. It imports JDBC and HikariCP configurations to establish the necessary database connections required for Liquibase to execute schema changes.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "DDL" ], "queryPatterns": "Database schema migrations and updates managed by Liquibase.", "transactionHandling": "Managed by Liquibase and underlying JDBC configuration.", "protocol": "unknown", "connectionInfo": "Configured via HikariCpConfig and JdbcConfig (not visible in this file)", "codeExample": "@Import({ HikariCpConfig.class, JdbcConfig.class })\n@EnableConfigurationProperties({ ... LiquibaseProperties.class })" }, { "path": "org.apache.fineract.infrastructure.core.config", "mechanism": "JDBC", "name": "JdbcConfig", "description": "This class configures the core Spring JDBC templates (JdbcTemplate and NamedParameterJdbcTemplate) which serve as the primary mechanism for executing SQL queries in the application. It integrates these templates with a RoutingDataSource, enabling dynamic database routing.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Generic JDBC template configuration supporting all SQL patterns", "transactionHandling": "Delegated to Spring transaction management (likely @Transactional used elsewhere)", "protocol": "JDBC", "connectionInfo": "Managed by RoutingDataSource", "codeExample": "@Bean\npublic JdbcTemplate jdbcTemplate(RoutingDataSource dataSource) {\n return new JdbcTemplate(dataSource);\n}" }, { "path": "org.apache.fineract.infrastructure.core.config", "mechanism": "JDBC", "name": "hikariTenantDataSource", "description": "Configures the HikariCP connection pool (HikariDataSource) which provides JDBC connections. It binds standard Spring datasource properties to the pool configuration.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "n/a", "protocol": "JDBC", "connectionInfo": "Configured via 'spring.datasource.hikari' properties", "codeExample": "return new HikariDataSource(hikariConfig);" }, { "path": "org.apache.fineract.infrastructure.core.config.CompatibilityConfig", "mechanism": "JDBC", "name": "hikariTenantDataSource", "description": "The class configures a JDBC DataSource using the HikariCP connection pool library. It sets up the connection parameters (URL, credentials, driver) and specific driver properties optimized for performance (caching prepared statements, batch rewriting).", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "n/a", "protocol": "JDBC (likely MySQL based on driver properties)", "connectionInfo": "Configured via environment variable 'fineract_tenants_url'", "codeExample": "@Bean\npublic HikariConfig hikariConfig() {\n HikariConfig hc = new HikariConfig();\n hc.setJdbcUrl(environment.getProperty(\"fineract_tenants_url\"));\n // ...\n return hc;\n}" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JDBC", "name": "FineractPlatformTenantConnection", "description": "This class is primarily a configuration holder for JDBC connections, but it also contains a utility method that directly interacts with the JDBC API. The 'toProtocol' method obtains a raw JDBC Connection from a DataSource to inspect the database metadata URL.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Metadata inspection only", "transactionHandling": "none", "protocol": "Dynamic (determined at runtime)", "connectionInfo": "Dynamic (constructed via toJdbcUrl)", "codeExample": "public static String toProtocol(DataSource dataSource) {\n try (Connection connection = dataSource.getConnection()) {\n String url = connection.getMetaData().getURL();\n return url.substring(0, url.indexOf(\"://\"));\n } catch (Exception e) {\n throw new RuntimeException(e);\n }\n}" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JDBC", "name": "JdbcSupport", "description": "This class is a low-level utility for processing JDBC ResultSets. It does not execute queries itself but is used to extract and map data from ResultSets returned by JDBC queries executed elsewhere in the application. It interacts directly with the java.sql.ResultSet API.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "final Timestamp dateValue = rs.getTimestamp(columnName);" }, { "path": "org.apache.fineract.infrastructure.core.service", "mechanism": "JDBC", "name": "JDBC DriverManager", "description": "The class interacts directly with the JDBC `DriverManager` to manage the lifecycle of database drivers. It does not perform data access (CRUD) but rather administrative cleanup by deregistering drivers to prevent memory leaks.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "ADMIN" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "Enumeration drivers = DriverManager.getDrivers();\nwhile (drivers.hasMoreElements()) {\n Driver driver = drivers.nextElement();\n java.sql.DriverManager.deregisterDriver(driver);\n}" }, { "path": "org.apache.fineract.infrastructure.core.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries provided by the caller. It performs read operations to fetch data lists and count totals.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL execution provided by caller, including count queries.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource", "codeExample": "final List items = jt.query(sqlFetchRows, rowMapper, args);" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "JdbcJavaType", "description": "The class is a core component of the database abstraction layer. It maps application-specific types to standard `java.sql.JDBCType` and generates dialect-specific SQL type strings (DDL) for MySQL and PostgreSQL. It also handles the conversion of Java values to JDBC-compatible values.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "n/a", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "public Object toJdbcValueImpl(@NotNull DatabaseType dialect, Object value) {\n return value == null ? null : (Boolean.TRUE.equals(value) ? 1 : 0);\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "RoutingDataSource", "description": "This class implements the javax.sql.DataSource interface to provide JDBC connections. It functions as a router, dynamically selecting the underlying DataSource based on tenant context, enabling multi-tenancy.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Dynamic (routed via factory)", "codeExample": "return determineTargetDataSource().getConnection();" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "PostgreSQLQueryService", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries directly against PostgreSQL system catalog tables/views to retrieve schema metadata.", "databaseName": "PostgreSQL", "tablesAccessed": [ "information_schema.tables", "information_schema.columns", "pg_indexes" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL queries targeting system information schemas with dynamic string formatting for table names.", "transactionHandling": "None observed; read-only metadata operations.", "protocol": "PostgreSQL (JDBC)", "connectionInfo": "Provided via javax.sql.DataSource argument in methods", "codeExample": "JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);\nInteger result = jdbcTemplate.queryForObject(format(\"SELECT COUNT(table_name) \" + \"FROM information_schema.tables ...\", tableName), Integer.class);" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "DatabaseIndexMapper", "description": "The class interacts with database results via the Spring JDBC SqlRowSet interface. While it does not execute queries directly, it processes the result set cursor to extract data.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Iterates over a result set", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "rowset.beforeFirst();\nwhile (rowset.next()) {\n indexes.add(new IndexDetail(rowset.getString(1)));\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "DatabaseQueryService", "description": "The class interacts directly with the JDBC DataSource to retrieve connection metadata (specifically the URL) for error reporting purposes. It primarily acts as a router for other database metadata operations, delegating them to implementations that likely use JDBC or Spring JDBC.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Metadata inspection via JDBC driver", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Derived from javax.sql.DataSource", "codeExample": "dataSource.getConnection().getMetaData().getURL()" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "DatabaseQueryService", "description": "The interface defines methods for direct database schema inspection using a JDBC DataSource. It is designed to read metadata about tables, columns, and indexes, abstracting the specific SQL or JDBC calls required.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Schema metadata queries (likely utilizing JDBC DatabaseMetaData or system tables)", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "Provided via javax.sql.DataSource parameter", "codeExample": "boolean isTablePresent(DataSource dataSource, String tableName);" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "DatabaseTypeResolver", "description": "The class interacts with the JDBC configuration (HikariCP) to identify the database driver class name, which is then used to resolve the database vendor type (MySQL or PostgreSQL).", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "MySQL or PostgreSQL (inferred from driver)", "connectionInfo": "Derived from HikariConfig", "codeExample": "DatabaseType databaseType = DRIVER_MAPPING.get(driverClassName);" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "MySQL Metadata Access", "description": "The class interacts directly with the MySQL database using Spring's JdbcTemplate to query system tables (INFORMATION_SCHEMA) and execute administrative commands (SHOW TABLES). It does not use an ORM for these operations but relies on raw SQL strings.", "databaseName": "MySQL (inferred from class name and logic)", "tablesAccessed": [ "INFORMATION_SCHEMA.COLUMNS", "INFORMATION_SCHEMA.STATISTICS" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL queries targeting system views (INFORMATION_SCHEMA) and SHOW commands.", "transactionHandling": "None explicit (read-only metadata queries)", "protocol": "MySQL", "connectionInfo": "Provided via javax.sql.DataSource argument", "codeExample": "final JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);\nfinal String sql = \"SELECT ... FROM INFORMATION_SCHEMA.COLUMNS ...\";\nfinal SqlRowSet columnDefinitions = jdbcTemplate.queryForRowSet(sql, new Object[] { tableName });" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "JDBC", "name": "TomcatJdbcDataSourcePerTenantService", "description": "This class manages the lifecycle and retrieval of JDBC `DataSource` objects for a multi-tenant application. It does not execute business queries directly but manages the connections (pools) that other components use to interact with the database. It verifies connectivity by obtaining a `Connection` object during initialization.", "databaseName": "Dynamic (Tenant Specific)", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Dynamic JDBC URL from TenantConnection", "codeExample": "try (Connection connection = tenantSpecificDataSource.getConnection()) {\n String url = connection.getMetaData().getURL();\n log.debug(\"Established database connection with URL {}\", url);\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.database.DataSourcePerTenantServiceFactory", "mechanism": "JDBC", "name": "HikariCP DataSource Factory", "description": "This class is responsible for configuring and creating JDBC DataSources using the HikariCP connection pool library. It constructs JDBC URLs dynamically and manages database credentials.", "databaseName": "Dynamic (Tenant Specific)", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "n/a", "protocol": "Dynamic (JDBC)", "connectionInfo": "Dynamic JDBC URL constructed at runtime", "codeExample": "HikariConfig config = new HikariConfig();\nconfig.setJdbcUrl(jdbcUrl);\nconfig.setUsername(schemaUsername);\nconfig.setPassword(databasePasswordEncryptor.decrypt(schemaPassword));\nreturn hikariDataSourceFactory.create(config);" }, { "path": "org.apache.fineract.infrastructure.core.service.database.HikariDataSourceFactory", "mechanism": "JDBC", "name": "HikariDataSourceFactory", "description": "This class is responsible for the creation of the JDBC Connection Pool (HikariCP). While it does not execute queries itself, it is the infrastructure component that initializes the `DataSource` used by the rest of the application to connect to the database via JDBC.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Encapsulated within the HikariConfig object passed to the create method", "codeExample": "return new HikariDataSource(config);" }, { "path": "org.apache.fineract.infrastructure.core.service.database.RoutingDataSourceService", "mechanism": "JDBC", "name": "RoutingDataSourceService", "description": "This interface is explicitly designed to facilitate JDBC database integration by providing a mechanism to retrieve a javax.sql.DataSource. While it does not execute SQL itself, it is the gateway to obtaining the connection pool required for all subsequent database operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "DataSource retrieveDataSource();" }, { "path": "org.apache.fineract.infrastructure.core.service.migration", "mechanism": "JDBC", "name": "TenantDataSourceFactory", "description": "This class is responsible for configuring the JDBC connection layer (specifically HikariCP) for dynamic tenant databases. It constructs JDBC URLs and configures DataSources programmatically.", "databaseName": "Dynamic (derived from FineractPlatformTenantConnection)", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a (Configuration only)", "transactionHandling": "none", "protocol": "JDBC (Dynamic Driver)", "connectionInfo": "Dynamic JDBC URL constructed at runtime", "codeExample": "HikariDataSource dataSource = new HikariDataSource();\ndataSource.setUsername(tenantConnection.getSchemaUsername());\ndataSource.setPassword(databasePasswordEncryptor.decrypt(tenantConnection.getSchemaPassword()));\ndataSource.setJdbcUrl(tenantJdbcUrl);\nreturn dataSource;" }, { "path": "org.apache.fineract.infrastructure.core.service.migration", "mechanism": "JDBC", "name": "TenantDatabaseStateVerifier", "description": "The class uses Spring's `NamedParameterJdbcTemplate` to execute SQL queries against the `schema_version` table to verify migration history. It also checks for the existence of `DATABASECHANGELOG`.", "databaseName": "unknown", "tablesAccessed": [ "schema_version", "DATABASECHANGELOG" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT COUNT queries with WHERE clauses to match version, script name, and checksum.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Provided dynamically via the DataSource parameter", "codeExample": "NamedParameterJdbcTemplate jdbcTemplate = new NamedParameterJdbcTemplate(dataSource);\nInteger result = jdbcTemplate.queryForObject(\n \"SELECT COUNT(script) FROM schema_version \" + \"WHERE version = :latestFlywayVersion \"\n + \"AND script = :latestFlywayScriptName \" + \"AND checksum = :latestFlywayScriptChecksum \" + \"AND success = 1\",\n paramMap, Integer.class);" }, { "path": "org.apache.fineract.infrastructure.core.service.migration", "mechanism": "JDBC", "name": "tenant_server_connections", "description": "The class interacts directly with the database using JDBC `Statement` and `ResultSet` objects obtained via the Liquibase connection wrapper. It performs a read operation to fetch plain text passwords and a write operation to update them with encrypted values.", "databaseName": "unknown", "tablesAccessed": [ "tenant_server_connections" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Iterates through a ResultSet and executes individual UPDATE statements for each row (cursor-based processing).", "transactionHandling": "Manual transaction handling via the underlying Liquibase connection (autocommit is noted as false in comments).", "protocol": "JDBC", "connectionInfo": "Derived from liquibase.database.Database object", "codeExample": "try (ResultSet rs = selectStatement.executeQuery(\"SELECT id, readonly_schema_password FROM tenant_server_connections...\")) { ... updateStatement.execute(updateSql); }" }, { "path": "org.apache.fineract.infrastructure.core.service.migration", "mechanism": "JDBC", "name": "TenantPasswordEncryptionTask", "description": "The class interacts directly with the database using the JDBC API exposed through the Liquibase 'Database' object. It executes raw SQL queries to read and update the 'tenant_server_connections' table.", "databaseName": "unknown", "tablesAccessed": [ "tenant_server_connections" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Inline SQL SELECT and UPDATE statements constructed via String formatting.", "transactionHandling": "Manual handling via the provided JdbcConnection (autocommit is noted as false in comments).", "protocol": "JDBC", "connectionInfo": "Derived from liquibase.database.Database object", "codeExample": "JdbcConnection dbConn = (JdbcConnection) database.getConnection();\ntry (Statement selectStatement = dbConn.createStatement()) {\n try (ResultSet rs = selectStatement.executeQuery(\"SELECT id, schema_password FROM tenant_server_connections\")) {\n // ...\n updateStatement.execute(updateSql);\n }\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.migration.ExtendedSpringLiquibase", "mechanism": "JDBC", "name": "Liquibase Migration Service", "description": "The class interacts with the database to manage schema migration metadata. It retrieves a raw JDBC connection from the Spring DataSource and passes it to the Liquibase library to update the changelog table.", "databaseName": "unknown", "tablesAccessed": [ "DATABASECHANGELOG" ], "operationType": [ "ADMIN", "WRITE" ], "queryPatterns": "Liquibase internal queries to update changelog lock and changelog tables.", "transactionHandling": "Managed internally by Liquibase", "protocol": "JDBC", "connectionInfo": "Derived from Spring DataSource", "codeExample": "try (Liquibase liquibase = createLiquibase(getDataSource().getConnection())) {\n liquibase.changeLogSync(getContexts());\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.migration.ExtendedSpringLiquibaseBuilder", "mechanism": "JDBC", "name": "ExtendedSpringLiquibase", "description": "This class configures the Liquibase migration tool. It holds a javax.sql.DataSource and passes it to the ExtendedSpringLiquibase instance, which is responsible for managing database schema changes (DDL).", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "DDL" ], "queryPatterns": "Database Schema Migration (DDL)", "transactionHandling": "Managed by Liquibase internally", "protocol": "JDBC", "connectionInfo": "Derived from javax.sql.DataSource", "codeExample": "public ExtendedSpringLiquibaseBuilder withDataSource(DataSource dataSource) {\n this.dataSource = dataSource;\n return this;\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.migration.ExtendedSpringLiquibaseFactory", "mechanism": "JDBC", "name": "Liquibase Migration Factory", "description": "The class configures Liquibase for database schema migration using a JDBC DataSource. It prepares the migration tool to execute DDL changes against the connected database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "DDL" ], "queryPatterns": "Database schema migrations and change set execution.", "transactionHandling": "Liquibase manages its own transactions during migration execution.", "protocol": "JDBC", "connectionInfo": "Provided via javax.sql.DataSource argument", "codeExample": "return new ExtendedSpringLiquibaseBuilder(liquibaseProperties).withDataSource(dataSource)..." }, { "path": "org.apache.fineract.infrastructure.core.service.migration.TenantDatabaseUpgradeService", "mechanism": "JDBC", "name": "TenantDatabaseUpgradeService", "description": "The service manages database schema migrations using Liquibase, interacting with databases via `javax.sql.DataSource`. It handles connections for the 'tenant store' and dynamically creates connections for individual tenants to apply DDL changes.", "databaseName": "Tenant Store DB and multiple Tenant DBs", "tablesAccessed": [ "unknown (manages full schema)" ], "operationType": [ "DDL", "READ_WRITE" ], "queryPatterns": "Database Schema Migrations (Liquibase)", "transactionHandling": "Managed by Liquibase", "protocol": "JDBC (via Liquibase)", "connectionInfo": "Dynamic JDBC URLs derived from TenantDataSourceFactory", "codeExample": "ExtendedSpringLiquibase liquibase = liquibaseFactory.create(tenantDataSource, TENANT_STORE_DB_CONTEXT, INITIAL_SWITCH_CONTEXT);\napplyInitialLiquibase(tenantDataSource, liquibase, \"tenant store\",\n (ds) -> !databaseStateVerifier.isTenantStoreOnLatestUpgradableVersion(ds));" }, { "path": "org.apache.fineract.infrastructure.core.service.tenant.JdbcTenantDetailsService", "mechanism": "JDBC", "name": "hikariTenantDataSource", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against a DataSource. It relies on a TenantMapper helper class to define the SQL schema and map the ResultSet to domain objects.", "databaseName": "unknown", "tablesAccessed": [ "unknown (hidden in TenantMapper.schema())" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries using a RowMapper", "transactionHandling": "None explicit (likely auto-commit or managed by caller)", "protocol": "JDBC", "connectionInfo": "DataSource bean: hikariTenantDataSource", "codeExample": "this.jdbcTemplate.queryForObject(sql, rm, new Object[] { tenantIdentifier });" }, { "path": "org.apache.fineract.infrastructure.core.service.tenant.TenantMapper", "mechanism": "JDBC", "name": "TenantMapper", "description": "The class defines raw SQL strings and uses Spring's `RowMapper` interface to map JDBC `ResultSet` data to domain objects. It explicitly defines a SQL query involving joins and maps specific column names to object properties.", "databaseName": "unknown", "tablesAccessed": [ "tenants", "tenant_server_connections" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL query using a LEFT JOIN between 'tenants' and 'tenant_server_connections' tables to retrieve hierarchical data.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public FineractPlatformTenant mapRow(final ResultSet rs, int rowNum) throws SQLException {\n final Long id = rs.getLong(\"id\");\n final String tenantIdentifier = rs.getString(\"identifier\");\n // ...\n return new FineractPlatformTenant(id, tenantIdentifier, name, timezoneId, connection);\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.data", "mechanism": "JDBC", "name": "CreditReportReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines a RowMapper to manually map the ResultSet columns to the domain object fields.", "databaseName": "unknown", "tablesAccessed": [ "m_creditreport" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with a WHERE clause and manual RowMapper.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { creditBureauId });" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "JDBC", "name": "CreditBureauReadConfigurationServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries against the database to retrieve credit bureau configuration data.", "databaseName": "unknown", "tablesAccessed": [ "m_creditbureau_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with WHERE clauses using a RowMapper.", "transactionHandling": "None explicit, relies on default or caller context.", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { id });" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "JDBC", "name": "CreditBureauLoanProductMappingReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries against the database. It manually maps `ResultSet` rows to domain objects using inner `RowMapper` classes. The SQL queries involve joins across multiple tables to aggregate credit bureau and loan product information.", "databaseName": "unknown", "tablesAccessed": [ "m_creditbureau_loanproduct_mapping", "m_organisation_creditbureau", "m_product_loan", "m_creditbureau" ], "operationType": [ "READ" ], "queryPatterns": "SQL queries with joins across 4 tables, filtering by ID, and ordering results.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines a RowMapper to map the result set columns to the CreditBureauData domain object.", "databaseName": "unknown", "tablesAccessed": [ "m_creditbureau" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with string concatenation for summary fields.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + rm.schema() + \" order by id\";\nreturn this.jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service.OrganisationCreditBureauReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually maps the results using a RowMapper implementation.", "databaseName": "unknown", "tablesAccessed": [ "m_organisation_creditbureau", "m_creditbureau" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with an INNER JOIN between mapping table and definition table.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Injected via Spring DataSource", "codeExample": "this.jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's JdbcTemplate and NamedParameterJdbcTemplate to perform direct SQL operations. It handles both DDL (creating/altering tables) and DML (querying/updating data) for dynamic user-defined tables ('Datatables'). It also interacts with system tables like 'x_registered_table', 'm_permission', and core entity tables.", "databaseName": "unknown", "tablesAccessed": [ "x_registered_table", "m_appuser_role", "m_role", "m_role_permission", "m_permission", "m_code_value", "c_configuration", "m_loan", "m_savings_account", "m_savings_account_transaction", "m_client", "m_group", "m_office", "m_entity_datatable_check", "information_schema.tables", "information_schema.TABLE_CONSTRAINTS", "x_table_column_code_mappings" ], "operationType": [ "READ_WRITE", "DDL" ], "queryPatterns": "Dynamic SQL generation for DDL and DML, parameterized queries, batch updates, and complex joins for permission and scoping checks.", "transactionHandling": "Spring @Transactional annotations on methods that modify data or schema.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "jdbcTemplate.queryForRowSet(sql, params); // NOSONAR\n...\nthis.namedParameterJdbcTemplate.update(registerDatatableSql, paramMap);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service", "mechanism": "JDBC", "name": "Datatable Service", "description": "The interface defines methods for interacting with dynamic 'Datatables'. The presence of methods like 'buildDataQueryEmbedded' which take StringBuilder arguments for 'select', 'from', and 'where' clauses, along with 'params' lists, strongly indicates an implementation that constructs dynamic SQL queries, likely executed via JDBC or Spring's JdbcTemplate. It handles DDL (create/drop tables) and DML (insert/update/delete entries) for these user-defined tables.", "databaseName": "unknown", "tablesAccessed": [ "unknown (dynamic datatables)" ], "operationType": [ "READ_WRITE", "DDL" ], "queryPatterns": "Dynamic SQL generation for user-defined tables, including DDL for table creation and DML for data management.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "boolean buildDataQueryEmbedded(@NotNull EntityTables entityTable, @NotNull String datatable, ... @NotNull StringBuilder select, @NotNull StringBuilder from, @NotNull StringBuilder where ...)" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service.EntityDatatableChecksReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class primarily uses Spring's `JdbcTemplate` to execute SQL queries for retrieving lists of checks and datatable definitions. It also utilizes a Spring Data JPA repository (`EntityDatatableChecksRepository`) for specific domain object retrieval.", "databaseName": "unknown", "tablesAccessed": [ "m_entity_datatable_check", "x_registered_table", "m_product_loan", "m_savings_product" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation with filtering conditions and joins.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final String sql = \"select \" + this.registerDataTableMapper.schema();\nreturn this.jdbcTemplate.query(sql, this.registerDataTableMapper);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service.GenericDataServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute dynamic SQL queries and retrieve results as SqlRowSet. It also queries system tables for metadata and specific application tables (m_code, m_code_value) for code lookups.", "databaseName": "unknown", "tablesAccessed": [ "m_code", "m_code_value" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL execution, metadata queries, and specific joins for code value lookups.", "transactionHandling": "None observed in this file (likely handled by caller or auto-commit).", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring", "codeExample": "final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service.ReadReportingServiceImpl", "mechanism": "JDBC", "name": "Stretchy Reports Database", "description": "The class interacts with the database using Spring's JdbcTemplate. It reads report definitions (SQL queries) from the 'stretchy_report' table and executes them dynamically. It also queries metadata tables for parameters.", "databaseName": "unknown", "tablesAccessed": [ "stretchy_report", "stretchy_report_parameter", "stretchy_parameter", "stretchy_{type}" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL execution where SQL strings are fetched from the database and executed. Parameter substitution is performed before execution.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource", "codeExample": "final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(inputSqlWrapped, encodedName);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.starter", "mechanism": "JDBC", "name": "ReadWriteNonCoreDataService", "description": "This configuration class wires up a service that utilizes Spring JDBC templates for database interaction. It injects JdbcTemplate and NamedParameterJdbcTemplate into the service implementation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "The service being configured likely performs dynamic SQL generation and execution based on the injected dependencies like DatabaseSpecificSQLGenerator.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "Configured via Spring Boot DataSource (injected into JdbcTemplate)", "codeExample": "return new ReadWriteNonCoreDataServiceImpl(jdbcTemplate, databaseTypeResolver, ...)" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.service", "mechanism": "JDBC", "name": "ImageReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries for retrieving image metadata. It performs joins between the image table and entity-specific tables (client or staff) to link images to their owners.", "databaseName": "unknown", "tablesAccessed": [ "m_image", "m_client", "m_staff" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with INNER JOINs based on entity ID.", "transactionHandling": "None explicitly defined in this class (likely relies on read-only default or upper-layer transaction context).", "protocol": "JDBC", "connectionInfo": "configured via JdbcTemplate bean", "codeExample": "final String sql = \"select \" + imageMapper.schema(entityType);\nfinal ImageData imageData = this.jdbcTemplate.queryForObject(sql, imageMapper, entityId);" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries against the database to retrieve document metadata.", "databaseName": "unknown", "tablesAccessed": [ "m_document" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with WHERE clauses filtering by parent entity type and ID.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, mapper, new Object[] { entityType, entityId });" }, { "path": "org.apache.fineract.infrastructure.entityaccess.service.FineractEntityAccessReadServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to domain objects using inner classes implementing RowMapper. It constructs dynamic SQL for filtering and joins multiple tables to retrieve human-readable names for entities.", "databaseName": "unknown", "tablesAccessed": [ "m_entity_to_entity_mapping", "m_entity_relation", "m_office", "m_role", "m_product_loan", "m_savings_product", "m_charge" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL queries with '?' placeholders. It includes simple SELECTs, dynamic WHERE clauses based on hierarchy, and complex JOINs with CASE statements in the 'EntityToEntityMapper' to resolve entity names based on relation types.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, mapper, new Object[] { relId, fromEntityId });" }, { "path": "org.apache.fineract.infrastructure.event.external.jobs", "mechanism": "JDBC", "name": "JobRepository", "description": "The class interacts with the database indirectly through the Spring Batch `JobRepository`. This component is responsible for persisting job metadata, including job instances, execution contexts, and step executions, typically into standard Spring Batch tables (e.g., BATCH_JOB_INSTANCE, BATCH_JOB_EXECUTION).", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_JOB_EXECUTION_PARAMS", "BATCH_STEP_EXECUTION", "BATCH_STEP_EXECUTION_CONTEXT", "BATCH_JOB_EXECUTION_CONTEXT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal CRUD operations for job metadata management", "transactionHandling": "Spring PlatformTransactionManager", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "new StepBuilder(StepName.SEND_ASYNCHRONOUS_EVENTS_STEP.name(), jobRepository).tasklet(tasklet, transactionManager)" }, { "path": "org.apache.fineract.infrastructure.event.external.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class mocks Spring's JdbcTemplate to simulate database interactions. While it does not connect to a real database, it defines the expected SQL query behavior and response structures used by the service under test.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Simulated SQL queries via Mockito", "transactionHandling": "none", "protocol": "JDBC (Mocked)", "connectionInfo": "n/a", "codeExample": "when(jdbcTemplate.queryForList(anyString(), eq(String.class))).thenReturn(configurations);" }, { "path": "org.apache.fineract.infrastructure.event.external.service", "mechanism": "JDBC", "name": "JdbcTemplateFactory", "description": "The service uses a `JdbcTemplateFactory` to create a Spring `JdbcTemplate` configured for a specific tenant's database connection. It executes raw SQL queries to retrieve configuration data.", "databaseName": "Tenant-specific database", "tablesAccessed": [ "m_external_event_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query to fetch a list of strings.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Managed via JdbcTemplateFactory per tenant", "codeExample": "jdbcTemplate.queryForList(\"select me.type as type from m_external_event_configuration me\", String.class)" }, { "path": "org.apache.fineract.infrastructure.event.external.service.JdbcTemplateFactory", "mechanism": "JDBC", "name": "JdbcTemplateFactory", "description": "This class acts as a configuration factory that prepares JDBC connections. It does not execute queries itself but creates the Spring JdbcTemplate and NamedParameterJdbcTemplate objects that are used by other components to interact with the database via JDBC.", "databaseName": "Dynamic (Tenant Specific)", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Managed via TenantDataSourceFactory", "codeExample": "DataSource tenantDataSource = tenantDataSourceFactory.create(tenant);\nreturn new JdbcTemplate(tenantDataSource);" }, { "path": "org.apache.fineract.infrastructure.gcm.service", "mechanism": "JDBC", "name": "DeviceRegistrationReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines a custom RowMapper (DeviceRegistrationDataMapper) to map the result set columns to the DeviceRegistrationData domain object. The queries involve joining the 'client_device_registration' table with the 'm_client' table.", "databaseName": "unknown", "tablesAccessed": [ "client_device_registration", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with a LEFT JOIN.", "transactionHandling": "unknown", "protocol": "SQL", "connectionInfo": "unknown", "codeExample": "String sql = \"select \" + drm.schema() + \" where cdr.id = ? \";\nreturn this.jdbcTemplate.queryForObject(sql, drm, id);" }, { "path": "org.apache.fineract.infrastructure.hooks.data", "mechanism": "JDBC", "name": "EventResultSetExtractor", "description": "Implements Spring's ResultSetExtractor to map SQL results to Java objects manually.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "The code processes a flat result set likely resulting from a JOIN query, aggregating the data in memory.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "final String groupingName = rs.getString(\"grouping\");\nfinal String entityName = rs.getString(\"entity_name\");" }, { "path": "org.apache.fineract.infrastructure.hooks.service", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's `JdbcTemplate` for the majority of its read operations, executing raw SQL queries with joins across multiple tables. It also utilizes a Spring Data JPA repository (`HookRepository`) for one specific cached query.", "databaseName": "unknown", "tablesAccessed": [ "m_hook", "m_hook_templates", "m_template", "m_hook_registered_events", "m_hook_configuration", "m_hook_schema", "m_permission" ], "operationType": [ "READ" ], "queryPatterns": "The code uses raw SQL strings with string concatenation for schema definitions within inner Mapper classes. It performs `SELECT` operations involving `LEFT JOIN` and `INNER JOIN` to aggregate data from parent and child tables (e.g., hooks and their events/configurations).", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final HookMapper rm = new HookMapper(jdbcTemplate);\nfinal String sql = \"select \" + rm.schema() + \" order by h.name\";\nreturn jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.infrastructure.jobs.ScheduledJobRunnerConfig", "mechanism": "JDBC", "name": "Spring Batch Repository", "description": "The class configures the Spring Batch JobRepository and JobExplorer, which interact directly with the database to store and retrieve batch execution metadata (JobInstances, JobExecutions, StepExecutions). It uses a `RoutingDataSource` to connect to the database and a custom `ExtendedJpaTransactionManager` for transaction handling. The `JobRepositoryFactoryBean` internally uses JDBC to perform CRUD operations on the batch meta-tables.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_JOB_EXECUTION_PARAMS", "BATCH_STEP_EXECUTION", "BATCH_STEP_EXECUTION_CONTEXT", "BATCH_JOB_EXECUTION_CONTEXT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard Spring Batch JDBC queries for managing job state.", "transactionHandling": "Spring @Transactional via PlatformTransactionManager", "protocol": "JDBC", "connectionInfo": "Configured via RoutingDataSource", "codeExample": "JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();\nfactory.setDataSource(routingDataSource);\nfactory.setTransactionManager(transactionManager);\nfactory.setIsolationLevelForCreate(\"ISOLATION_READ_COMMITTED\");" }, { "path": "org.apache.fineract.infrastructure.jobs.config.FineractDataFieldMaxValueIncrementerFactory", "mechanism": "JDBC", "name": "FineractDataFieldMaxValueIncrementerFactory", "description": "The class interacts with the database via Spring JDBC support classes to manage sequence generation. It uses a `DataSource` to instantiate specific incrementer implementations (`MySQLMaxValueIncrementer`, `PostgresSequenceMaxValueIncrementer`) which execute SQL to retrieve or update sequence values.", "databaseName": "unknown", "tablesAccessed": [ "unknown (dynamic based on incrementerName)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Sequence generation (SELECT/UPDATE for MySQL, Sequence calls for Postgres)", "transactionHandling": "unknown", "protocol": "MySQL, MariaDB, PostgreSQL", "connectionInfo": "DataSource injected via constructor", "codeExample": "MySQLMaxValueIncrementer mySQLMaxValueIncrementer = new MySQLMaxValueIncrementer(dataSource, incrementerName, incrementerColumnName);\nmySQLMaxValueIncrementer.setUseNewConnection(true);\nreturn mySQLMaxValueIncrementer;" }, { "path": "org.apache.fineract.infrastructure.jobs.domain", "mechanism": "JDBC", "name": "CustomJobParameterRepositoryImpl", "description": "The class interacts directly with the database using Spring's JDBC abstraction (NamedParameterJdbcTemplate). It performs CRUD operations on the 'batch_custom_job_parameters' table. It specifically handles JSON data types by serializing objects before insertion and retrieving them as strings. It relies on a 'DatabaseSpecificSQLGenerator' helper to abstract away vendor-specific SQL differences for JSON casting and identity retrieval.", "databaseName": "unknown", "tablesAccessed": [ "batch_custom_job_parameters" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations involving INSERT with JSON casting and SELECT by primary key.", "transactionHandling": "unknown", "protocol": "JDBC (Generic)", "connectionInfo": "n/a", "codeExample": "final String insertSQL = \"INSERT INTO batch_custom_job_parameters (parameter_json) VALUES (%s)\"\n .formatted(databaseSpecificSQLGenerator.castJson(\":jsonString\"));\nfinal String jsonString = gson.toJson(customJobParameters);\nSqlParameterSource parameters = new MapSqlParameterSource(\"jsonString\", jsonString);\nnamedParameterJdbcTemplate.update(insertSQL, parameters);" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.JobExecutionRepository", "mechanism": "JDBC", "name": "JobExecutionRepository", "description": "The class uses `NamedParameterJdbcTemplate` to execute raw SQL queries against Spring Batch metadata tables and a custom parameter table. It explicitly handles SQL dialect differences for JSON operations.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION", "BATCH_JOB_EXECUTION_PARAMS", "batch_custom_job_parameters" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Complex joins involving subqueries, aggregations (COUNT, GROUP BY), and database-specific JSON parsing (json_array_elements, json_table).", "transactionHandling": "unknown", "protocol": "PostgreSQL, MySQL", "connectionInfo": "n/a", "codeExample": "namedParameterJdbcTemplate.update(\"\"\"\n UPDATE BATCH_JOB_EXECUTION\n SET STATUS = :status, START_TIME = null\n WHERE JOB_EXECUTION_ID = :jobExecutionId\n\"\"\", Map.of(\"status\", FAILED.name(), \"jobExecutionId\", stuckJobId));" }, { "path": "org.apache.fineract.infrastructure.jobs.service", "mechanism": "JDBC", "name": "JobExecutionRepository", "description": "The class interacts with the database to identify stuck batch jobs. It uses a 'JdbcTemplateFactory' to create a 'NamedParameterJdbcTemplate' specific to each tenant, which is then passed to the 'JobExecutionRepository' to execute the query.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ" ], "queryPatterns": "Selects job names based on status (stuck/running) via a repository helper.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "Derived dynamically per tenant via JdbcTemplateFactory", "codeExample": "NamedParameterJdbcTemplate namedParameterJdbcTemplate = jdbcTemplateFactory.createNamedParameterJdbcTemplate(tenant);\nList stuckJobNames = jobExecutionRepository.getStuckJobNames(namedParameterJdbcTemplate);" }, { "path": "org.apache.fineract.infrastructure.jobs.service.SchedulerJobRunnerReadServiceImpl", "mechanism": "JDBC", "name": "SchedulerJobRunnerReadServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL strings dynamically using a StringBuilder and a DatabaseSpecificSQLGenerator to handle dialect-specific syntax (like limits and escaping). It maps results to Java objects using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "job", "job_run_history" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL queries for selecting data. It employs simple SELECTs with WHERE clauses for single entity retrieval and JOINs (LEFT JOIN, JOIN) to link job details with run history. It also dynamically appends ORDER BY and LIMIT clauses for pagination.", "transactionHandling": "Spring @Transactional annotations (readOnly = true) are used at the class level.", "protocol": "JDBC", "connectionInfo": "Injected via DataSource/JdbcTemplate (not visible in code)", "codeExample": "final String sql = detailMapper.schema() + \" where job.id=?\";\nreturn this.jdbcTemplate.queryForObject(sql, detailMapper, new Object[] { jobId });" }, { "path": "org.apache.fineract.infrastructure.jobs.service.executealldirtyjobs", "mechanism": "JDBC", "name": "JobRepository", "description": "The class injects and uses a Spring Batch 'JobRepository'. This component is responsible for interacting with the database to persist batch metadata (JobInstances, JobExecutions, StepExecutions, etc.). While the SQL is abstracted away by the framework, the configuration here explicitly wires up the persistence mechanism for the batch job.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal metadata management (CRUD on batch tables)", "transactionHandling": "Spring @Transactional via PlatformTransactionManager", "protocol": "JDBC", "connectionInfo": "Managed by Spring Context (DataSource)", "codeExample": "new StepBuilder(JobName.EXECUTE_DIRTY_JOBS.name(), jobRepository).tasklet(executeAllDirtyJobsTasklet, transactionManager)" }, { "path": "org.apache.fineract.infrastructure.jobs.service.updatenpa", "mechanism": "JDBC", "name": "RoutingDataSourceServiceFactory", "description": "The code interacts with the database using Spring's JdbcTemplate to execute raw SQL UPDATE statements. It manually constructs SQL strings to handle complex joins between 'm_loan', 'm_loan_arrears_aging', and 'm_product_loan' tables. It specifically handles database portability by checking the database type (MySQL vs others) and adjusting the SQL syntax for UPDATE joins accordingly.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_arrears_aging", "m_product_loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Complex UPDATE statements with inner joins and subqueries; dynamic SQL generation based on DB vendor.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "Derived from dataSourceServiceFactory.determineDataSourceService().retrieveDataSource()", "codeExample": "jdbcTemplate.update(resetNPASqlBuilder.toString(), user.getId(), DateUtils.getOffsetDateTimeOfTenantWithMostPrecision());" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.service", "mechanism": "JDBC", "name": "ReportMailingJobConfigurationReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database to read configuration data.", "databaseName": "unknown", "tablesAccessed": [ "m_report_mailing_job_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with basic filtering.", "transactionHandling": "None explicit (likely read-only or auto-commit)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { name });" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.service", "mechanism": "JDBC", "name": "ReportMailingJobRunHistoryReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It constructs SQL strings dynamically to support filtering and pagination.", "databaseName": "unknown", "tablesAccessed": [ "m_report_mailing_job_run_history" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL construction with pagination and sorting logic.", "transactionHandling": "None explicit (likely read-only context)", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "sqlStringBuilder.append(\"select \" + sqlGenerator.calcFoundRows() + \" \");\nsqlStringBuilder.append(this.reportMailingJobRunHistoryMapper.reportMailingJobRunHistorySchema());\nif (reportMailingJobId != null) {\n sqlStringBuilder.append(\" where rmjrh.job_id = ? \");\n queryParameters.add(reportMailingJobId);\n}" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.service.ReportMailingJobReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ReportMailingJobReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually constructs SQL strings, including joins between the mailing job, app user, and stretchy report tables. It uses a custom RowMapper to map the ResultSet to domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_report_mailing_job", "m_appuser", "stretchy_report" ], "operationType": [ "READ" ], "queryPatterns": "The code uses dynamic SQL generation for pagination and sorting, and static SQL for single-record retrieval. It performs INNER and LEFT JOINs to fetch related user and report information.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + mapper.reportMailingJobSchema() + \" where rmj.id = ? and rmj.is_deleted = false\";\nreturn this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { reportMailingJobId });" }, { "path": "org.apache.fineract.infrastructure.security.exception.EscapeSqlLiteralException", "mechanism": "JDBC", "name": "SQLExceptionWrapper", "description": "This class does not perform direct database operations but is tightly coupled to the JDBC API by wrapping `java.sql.SQLException`. It is used to handle errors originating from database interactions, specifically regarding SQL literal escaping.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC API", "connectionInfo": "n/a", "codeExample": "public EscapeSqlLiteralException(String message, SQLException e) {\n super(message, e);\n}" }, { "path": "org.apache.fineract.infrastructure.security.service", "mechanism": "JDBC", "name": "BasicAuthTenantDetailsServiceJdbc", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries against the tenant database to retrieve tenant configuration.", "databaseName": "unknown", "tablesAccessed": [ "unknown (dynamic schema via TenantMapper)" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with a WHERE clause to fetch a single record by ID.", "transactionHandling": "None explicit (likely auto-commit or managed by caller)", "protocol": "JDBC", "connectionInfo": "hikariTenantDataSource", "codeExample": "this.jdbcTemplate.queryForObject(sql, rm, new Object[] { tenantIdentifier });" }, { "path": "org.apache.fineract.infrastructure.security.utils.ColumnValidator", "mechanism": "JDBC", "name": "DatabaseMetaData Inspection", "description": "The class interacts with the database primarily to inspect metadata rather than to manipulate data. It obtains a raw JDBC connection from the Spring `JdbcTemplate` to access `DatabaseMetaData`. It uses this metadata to verify the existence of tables and columns referenced in dynamic SQL strings.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Metadata inspection using DatabaseMetaData.getColumns()", "transactionHandling": "Manual connection release using DataSourceUtils", "protocol": "JDBC", "connectionInfo": "Derived from JdbcTemplate DataSource", "codeExample": "connection = this.jdbcTemplate.getDataSource().getConnection();\nDatabaseMetaData dbMetaData = connection.getMetaData();\nresultSet = dbMetaData.getColumns(null, null, entry.getKey(), null);" }, { "path": "org.apache.fineract.infrastructure.sms.service.SmsReadPlatformServiceImpl", "mechanism": "JDBC", "name": "SmsReadPlatformService", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually constructs SQL strings, often concatenating parameters or using placeholders, and maps the results to Java objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "sms_messages_outbound", "sms_campaign" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL construction with string concatenation for filtering and pagination limits. Uses JOINs between message and campaign tables.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final String sql = \"select \" + this.smsRowMapper.schema() + \" where smo.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, this.smsRowMapper, new Object[] { resourceId });" }, { "path": "org.apache.fineract.infrastructure.springbatch.messagehandler", "mechanism": "JDBC", "name": "Spring Batch JobRepository", "description": "The class interacts with the underlying database used by Spring Batch to persist job and step execution metadata. It uses 'JobExplorer' for reading execution state and 'JobRepository' for updating it. While the specific database technology is abstracted, Spring Batch typically uses JDBC.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_STEP_EXECUTION", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION_CONTEXT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal metadata queries (Select by ID, Update status)", "transactionHandling": "Managed by Spring Batch JobRepository implementation", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "StepExecution stepExecution = jobExplorer.getStepExecution(jobExecutionId, stepExecutionId);\n// ...\njobRepository.update(stepExecution);" }, { "path": "org.apache.fineract.infrastructure.survey.service", "mechanism": "JDBC", "name": "PovertyLineServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It retrieves data using SqlRowSet to allow for cursor manipulation (scrolling) during the mapping process.", "databaseName": "unknown", "tablesAccessed": [ "ppi_likelihoods", "ppi_likelihoods_ppi", "ppi_poverty_line", "ppi_scores" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving 3 to 4 tables to link poverty lines, likelihoods, and scores.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring", "codeExample": "this.jdbcTemplate.queryForRowSet(sql, new Object[] { ppiName });" }, { "path": "org.apache.fineract.infrastructure.survey.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It interacts with system configuration tables and dynamic application tables (surveys). It manually maps SqlRowSet results to Java objects.", "databaseName": "unknown", "tablesAccessed": [ "x_registered_table", "c_configuration", "m_appuser_role", "m_role", "m_role_permission", "m_permission", "ppi_likelihoods_ppi", "ppi_scores", "ppi_poverty_line", "ppi_likelihoods" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving system metadata tables and dynamic tables determined at runtime. Contains potential N+1 query patterns when retrieving scores for all surveys.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final String sql = \"select application_table_name... from x_registered_table...\";\nfinal SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);" }, { "path": "org.apache.fineract.infrastructure.survey.service.ReadLikelihoodServiceImpl", "mechanism": "JDBC", "name": "ReadLikelihoodServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute parameterized SQL queries directly against the database. It constructs SQL strings that join multiple tables to retrieve the required survey likelihood data.", "databaseName": "unknown", "tablesAccessed": [ "ppi_poverty_line", "ppi_likelihoods_ppi", "ppi_likelihoods" ], "operationType": [ "READ" ], "queryPatterns": "SQL queries involving INNER JOINs across three tables with GROUP BY clauses and WHERE filtering.", "transactionHandling": "NONE", "protocol": "SQL", "connectionInfo": "Managed by Spring JdbcTemplate", "codeExample": "return this.jdbcTemplate.queryForRowSet(sql, new Object[] { ppiName });" }, { "path": "org.apache.fineract.mix.service", "mechanism": "JDBC", "name": "MixTaxonomyReadPlatformServiceImpl", "description": "The service interacts with the database using Spring's JdbcTemplate to execute inline SQL queries. It performs read operations involving joins between taxonomy and namespace tables.", "databaseName": "unknown", "tablesAccessed": [ "mix_taxonomy", "mix_xbrl_namespace" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL SELECT statements with LEFT JOINs.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, this.mixTaxonomyMapper);" }, { "path": "org.apache.fineract.mix.service.MixTaxonomyMappingReadPlatformServiceImpl", "mechanism": "JDBC", "name": "MixTaxonomyMappingReadPlatformServiceImpl", "description": "The class interacts with the database using Spring's JdbcTemplate to execute raw SQL queries. It reads configuration data from a specific table.", "databaseName": "unknown", "tablesAccessed": [ "mix_taxonomy_mapping" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query fetching specific columns from a single table.", "transactionHandling": "None explicit (likely read-only or auto-commit)", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate", "codeExample": "this.jdbcTemplate.queryForObject(sqlString, rm);" }, { "path": "org.apache.fineract.mix.service.NamespaceReadPlatformServiceImpl", "mechanism": "JDBC", "name": "NamespaceReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute parameterized SQL SELECT queries directly against the database. It defines a RowMapper to map the columns 'id', 'prefix', and 'url' to the NamespaceData object.", "databaseName": "unknown", "tablesAccessed": [ "mix_xbrl_namespace" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD SELECT queries using parameterized SQL.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (injected into JdbcTemplate)", "codeExample": "this.jdbcTemplate.queryForObject(sql, this.namespaceMapper, new Object[] { id });" }, { "path": "org.apache.fineract.mix.service.XBRLResultServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries directly against the database. It constructs a large SQL string with unions and joins to aggregate accounting data.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_journal_entry", "acc_gl_account" ], "operationType": [ "READ" ], "queryPatterns": "Complex aggregation query using UNION, LEFT/RIGHT OUTER JOIN, and GROUP BY to calculate debits and credits.", "transactionHandling": "None observed (likely read-only or auto-commit)", "protocol": "SQL", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);" }, { "path": "org.apache.fineract.notification.service.NotificationReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Notification Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It performs SELECT operations with joins to retrieve notification data and UPDATE operations to change read status.", "databaseName": "unknown", "tablesAccessed": [ "notification_mapper", "notification_generator" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Inline SQL strings with joins between mapper and generator tables, utilizing dynamic pagination and sorting logic.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, notificationMapperRow, appUserId);" }, { "path": "org.apache.fineract.organisation.holiday.service", "mechanism": "JDBC", "name": "HolidayReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_holiday", "m_holiday_office" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL construction with joins and parameter binding.", "transactionHandling": "None (Read-only operations, likely relies on default auto-commit or higher-level transaction management)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, rm, finalObjectArray);" }, { "path": "org.apache.fineract.organisation.monetary.service.CurrencyReadPlatformServiceImpl", "mechanism": "JDBC", "name": "CurrencyReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It maps results to objects using a custom RowMapper implementation.", "databaseName": "unknown", "tablesAccessed": [ "m_organisation_currency", "m_currency" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with ORDER BY clauses.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.query(sql, this.currencyRowMapper);" }, { "path": "org.apache.fineract.organisation.office.service.OfficeReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class primarily uses Spring's `JdbcTemplate` to execute raw SQL SELECT queries. It constructs SQL strings dynamically to handle hierarchy filtering and sorting. It also uses `OfficeRepository` (Spring Data JPA) for one specific lookup by External ID.", "databaseName": "unknown", "tablesAccessed": [ "m_office", "m_office_transaction", "m_currency" ], "operationType": [ "READ" ], "queryPatterns": "The code uses dynamic SQL generation for filtering by hierarchy (using 'like' clauses) and sorting. It employs complex string concatenation in SQL for visual hierarchy representation (dots). It performs joins between office and currency tables.", "transactionHandling": "Read-only operations, implicit transaction management (likely non-transactional or read-only transaction at service boundary, though not explicitly annotated with @Transactional in this file).", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sqlBuilder.toString(), rm, new Object[] { hierarchySearchString });" }, { "path": "org.apache.fineract.organisation.provisioning.service", "mechanism": "JDBC", "name": "ProvisioningCategoryReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to perform direct SQL queries against the relational database. It manually maps the result set to domain objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_provision_category" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with ORDER BY clause", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "final String sql = \"select \" + this.provisionCategoryRowMapper.schema() + \" from m_provision_category pc order by pc.id\";\nreturn this.jdbcTemplate.query(sql, this.provisionCategoryRowMapper);" }, { "path": "org.apache.fineract.organisation.provisioning.service", "mechanism": "JDBC", "name": "ProvisioningCriteriaReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries. It manually maps ResultSets to Java objects using inner RowMapper classes.", "databaseName": "unknown", "tablesAccessed": [ "m_provisioning_criteria", "m_appuser", "m_loanproduct_provisioning_mapping", "m_provisioning_criteria_definition", "acc_gl_account", "m_provision_category" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD SELECT queries with LEFT JOINs to fetch related entity names (e.g., usernames, category names, GL account names).", "transactionHandling": "None (Read-only service)", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, mapper);" }, { "path": "org.apache.fineract.organisation.staff.service.StaffReadPlatformServiceImpl", "mechanism": "JDBC", "name": "StaffReadPlatformService", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to domain objects using inner RowMapper classes. It constructs dynamic SQL based on filter criteria.", "databaseName": "unknown", "tablesAccessed": [ "m_staff", "m_office", "m_client", "m_group", "m_loan", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL SELECT queries with JOINS (inner and left outer). It uses dynamic criteria building for filtering and hierarchy-based security checks using 'like' operators.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, LOOKUP_MAPPER, defaultOfficeId, hierarchy);" }, { "path": "org.apache.fineract.organisation.teller.data", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the 'm_cashiers' table. It constructs SQL strings dynamically to check for overlapping time ranges and to retrieve cashier IDs based on staff IDs and current timestamps.", "databaseName": "unknown", "tablesAccessed": [ "m_cashiers" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL queries with string concatenation for dynamic criteria (dates, times, IDs).", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "String sql = \"select count(*) from m_cashiers c where c.staff_id = \" + staffId ...;\nint count = this.jdbcTemplate.queryForObject(sql, Integer.class);" }, { "path": "org.apache.fineract.organisation.teller.service", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries. It manually maps `ResultSet` data to Java objects using inner `RowMapper` classes. It constructs SQL strings dynamically using `StringBuilder` to handle optional search criteria and complex unions across multiple tables.", "databaseName": "unknown", "tablesAccessed": [ "m_tellers", "m_office", "m_cashiers", "m_staff", "m_cashier_transactions", "m_savings_account_transaction", "m_loan_transaction", "m_client_transaction", "m_savings_account", "m_client", "m_appuser", "m_payment_detail", "m_payment_type", "m_account_transfer_transaction", "r_enum_value", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL queries involving multiple UNIONs to aggregate transaction data from different modules (savings, loans, client). Dynamic WHERE clause generation based on search parameters.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, this.lookupMapper, new Object[] { defaultOfficeId });" }, { "path": "org.apache.fineract.organisation.workingdays.service", "mechanism": "JDBC", "name": "WorkingDaysReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries against the 'm_working_days' table. It maps the result set manually using a RowMapper implementation.", "databaseName": "unknown", "tablesAccessed": [ "m_working_days" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with column mapping", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "final String sql = \" select \" + rm.schema();\nWorkingDaysData data = this.jdbcTemplate.queryForObject(sql, rm);" }, { "path": "org.apache.fineract.portfolio.account.jobs.executestandinginstructions", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's `JdbcTemplate` to perform direct SQL updates and inserts. It updates the `last_run_date` of standing instructions and inserts audit logs into a history table. It also relies on `StandingInstructionReadPlatformService` for reading data, which likely uses a different mechanism (JPA/Spring Data) internally, but this file specifically uses JDBC.", "databaseName": "unknown", "tablesAccessed": [ "m_account_transfer_standing_instructions", "m_account_transfer_standing_instructions_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Inline SQL INSERT and UPDATE statements with parameter binding.", "transactionHandling": "Manual/Implicit via JdbcTemplate (likely part of a larger Spring Batch transaction context).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final String updateQuery = \"UPDATE m_account_transfer_standing_instructions SET last_run_date = ? where id = ?\";\njdbcTemplate.update(updateQuery, transactionDate, data.getId());" }, { "path": "org.apache.fineract.portfolio.account.jobs.executestandinginstructions", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class injects a Spring JdbcTemplate and a DatabaseSpecificSQLGenerator, which are then passed to the Tasklet bean. While this configuration class does not execute queries directly, it wires the components that perform direct database access via JDBC.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "The actual queries are encapsulated within the Tasklet and Services injected here, likely involving reading standing instructions and writing transfer records.", "transactionHandling": "Spring Batch Step configured with PlatformTransactionManager", "protocol": "JDBC", "connectionInfo": "DataSource configured in Spring Context (injected via JdbcTemplate)", "codeExample": "return new ExecuteStandingInstructionsTasklet(standingInstructionReadPlatformService, jdbcTemplate, sqlGenerator,\n accountTransfersWritePlatformService);" }, { "path": "org.apache.fineract.portfolio.account.service", "mechanism": "JDBC", "name": "StandingInstructionHistoryReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It dynamically builds SQL strings with multiple joins to retrieve standing instruction history data.", "databaseName": "unknown", "tablesAccessed": [ "m_account_transfer_standing_instructions_history", "m_account_transfer_standing_instructions", "m_account_transfer_details", "m_office", "m_client", "m_savings_account", "m_savings_product", "m_loan", "m_product_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across 9 tables with dynamic WHERE clauses based on filter criteria.", "transactionHandling": "None explicit (likely read-only transaction managed at a higher layer)", "protocol": "SQL", "connectionInfo": "n/a", "codeExample": "final StringBuilder sqlBuilder = new StringBuilder(200);\nsqlBuilder.append(\"select \" + sqlGenerator.calcFoundRows() + \" \");\nsqlBuilder.append(this.standingInstructionHistoryMapper.schema());\nif (standingInstructionDTO.transferType() != null) {\n sqlBuilder.append(\" and atd.transfer_type=? \");\n paramObj.add(standingInstructionDTO.transferType());\n}\nreturn this.paginationHelper.fetchPage(this.jdbcTemplate, sqlBuilder.toString(), finalObjectArray, this.standingInstructionHistoryMapper);" }, { "path": "org.apache.fineract.portfolio.account.service", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses Spring's JdbcTemplate to interact directly with the database. It constructs SQL queries dynamically for search and filtering operations and uses RowMappers to convert ResultSet rows into Java objects.", "databaseName": "unknown", "tablesAccessed": [ "m_account_transfer_standing_instructions", "m_account_transfer_details", "m_office", "m_client", "m_savings_account", "m_savings_product", "m_loan", "m_product_loan", "m_loan_repayment_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation for search filters; complex joins across multiple tables (office, client, accounts, products); aggregation queries for loan dues.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sqlBuilder.toString(), this.standingInstructionMapper, status);" }, { "path": "org.apache.fineract.portfolio.account.service.AccountAssociationsReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to domain objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_portfolio_account_associations", "m_loan", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL queries with joins and filtering by IDs and Enum values.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (not visible in file)", "codeExample": "this.jdbcTemplate.queryForObject(\"select ... where aa.loan_account_id = ?\", mapper, loanId, ...)" }, { "path": "org.apache.fineract.portfolio.account.service.AccountTransfersReadPlatformServiceImpl", "mechanism": "JDBC", "name": "AccountTransfersReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually constructs SQL strings, often concatenating clauses for dynamic filtering and pagination. It uses a custom RowMapper to transform ResultSet rows into domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_account_transfer_transaction", "m_account_transfer_details", "m_currency", "m_office", "m_client", "m_savings_account", "m_loan", "m_savings_account_transaction", "m_loan_transaction", "m_account_transfer_standing_instructions" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple tables (transfers, clients, offices, accounts), dynamic SQL generation for search/filtering, and aggregation queries.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.queryForObject(sql, this.accountTransfersMapper, new Object[] { transferId });" }, { "path": "org.apache.fineract.portfolio.account.service.PortfolioAccountReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Portfolio Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It constructs SQL strings dynamically and maps results using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_product", "m_currency", "m_client", "m_group", "m_staff", "m_loan", "m_product_loan", "m_loan_repayment_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL construction with joins and subqueries (for refund calculations).", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "accountData = this.jdbcTemplate.queryForObject(sql, this.loanAccountMapper, sqlParams);" }, { "path": "org.apache.fineract.portfolio.accountdetails.service", "mechanism": "JDBC", "name": "AccountDetailsReadPlatformService", "description": "The service uses Spring's `JdbcTemplate` to execute raw SQL SELECT queries. It constructs these queries by appending WHERE clauses to base schemas defined in inner `RowMapper` classes. The schemas involve complex joins across multiple tables to aggregate account information.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_savings_account", "m_share_account", "m_guarantor", "m_client", "m_product_loan", "m_loan_arrears_aging", "glim_accounts", "m_savings_product", "m_currency", "m_appuser", "m_share_product", "m_code_value", "m_savings_account_transaction" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL SELECT statements with multiple LEFT JOINs to fetch related entity data (products, users, currency, arrears). Includes subqueries in some mappers.", "transactionHandling": "None explicit in this class (Read-only operations).", "protocol": "JDBC", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, rm, inputs);" }, { "path": "org.apache.fineract.portfolio.address.service.AddressReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It employs custom RowMapper implementations (AddFieldsMapper and AddMapper) to map the ResultSet to the AddressData domain object. The SQL is constructed via string concatenation in the mapper classes.", "databaseName": "unknown", "tablesAccessed": [ "m_address", "m_client", "m_code_value", "m_client_address" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SELECT queries with multiple JOINs (LEFT JOIN, JOIN) to link address data with client data and code values (dictionaries).", "transactionHandling": "none", "protocol": "SQL", "connectionInfo": "configured via Spring DataSource (not visible in file)", "codeExample": "final String sql = \"select \" + rm.schema() + \" where client.id=?\";\nreturn this.jdbcTemplate.query(sql, rm, new Object[] { clientid });" }, { "path": "org.apache.fineract.portfolio.address.service.FieldConfigurationReadPlatformServiceImpl", "mechanism": "JDBC", "name": "FieldConfigurationReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to perform direct SQL SELECT operations on the configuration table.", "databaseName": "unknown", "tablesAccessed": [ "m_field_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with a WHERE clause filtering by entity name.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource (injected JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { entity });" }, { "path": "org.apache.fineract.portfolio.calendar.service.CalendarReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually maps ResultSets to objects using inner class RowMappers. It interacts with calendar definition and instance tables, as well as user and entity tables for joins.", "databaseName": "unknown", "tablesAccessed": [ "m_calendar", "m_calendar_instance", "m_appuser", "m_calendar_history", "m_client", "m_group", "m_group_client" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL SELECT queries with joins. It constructs some SQL fragments dynamically (e.g., IN clauses for lists, hierarchy conditions). It uses subqueries for hierarchical data retrieval.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring (details not in file)", "codeExample": "this.jdbcTemplate.queryForObject(sql, rm, new Object[] { calendarId, entityId, entityTypeId });" }, { "path": "org.apache.fineract.portfolio.charge.service.ChargeReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ChargeReadPlatformServiceImpl", "description": "This class directly interacts with the database using Spring's `JdbcTemplate` and `NamedParameterJdbcTemplate`. It constructs raw SQL strings to perform read-only queries for charge data. A private inner `RowMapper` class, `ChargeMapper`, is used to map the `ResultSet` from the database into `ChargeData` DTOs. Queries involve joins across multiple tables to gather comprehensive charge information.", "databaseName": "not identifiable from code", "tablesAccessed": [ "m_charge", "m_organisation_currency", "acc_gl_account", "m_tax_group", "m_payment_type", "m_product_loan_charge", "m_savings_product_charge", "m_share_product_charge", "m_loan", "m_product_loan", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "The class uses direct SQL SELECT queries with JOINs and dynamic WHERE clauses. It does not use stored procedures, complex aggregations, or subqueries. The pattern is primarily fetching entities and their related data.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.jdbcTemplate.query(sql, rm, new Object[] { currencyCode }); // NOSONAR" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JDBC", "name": "JdbcTemplate and ClientTransactionRepository", "description": "The class primarily uses Spring's `JdbcTemplate` to execute raw SQL SELECT queries involving complex joins across multiple tables. It maps the results to data objects using a custom `RowMapper`. It also uses a Spring Data JPA repository (`ClientTransactionRepository`) for one specific lookup method.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_client_transaction", "m_currency", "m_payment_detail", "m_payment_type", "m_office", "m_client_charge_paid_by" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL joins across 7 tables, dynamic filtering, and pagination logic.", "transactionHandling": "none (read-only operations, no explicit transaction management in this file)", "protocol": "Relational Database (SQL)", "connectionInfo": "Injected via DataSource/JdbcTemplate", "codeExample": "final String sql = \"select \" + this.clientTransactionMapper.schema() + \" where c.id = ? and tr.id= ?\";\nreturn this.jdbcTemplate.queryForObject(sql, this.clientTransactionMapper, clientId, transactionId);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually constructs SQL strings and uses a RowMapper to transform the ResultSet into domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_field_configuration" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with a WHERE clause filtering by an entity column.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "this.jdbcTemplate.query(sql, rm, entity);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JDBC", "name": "ClientIdentifierReadPlatformServiceImpl", "description": "The class interacts directly with the database using Spring's `JdbcTemplate`. It constructs raw SQL queries involving joins across multiple tables (`m_client_identifier`, `m_client`, `m_office`, `m_code_value`) to assemble the client identifier data. It uses a custom `RowMapper` to map the result set columns to the `ClientIdentifierData` object.", "databaseName": "unknown", "tablesAccessed": [ "m_client_identifier", "m_client", "m_office", "m_code_value" ], "operationType": [ "READ" ], "queryPatterns": "SQL SELECT queries with implicit joins across 4 tables, filtered by client ID and office hierarchy.", "transactionHandling": "NONE", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, rm, clientId, hierarchySearchString);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JDBC", "name": "ClientFamilyMembersReadPlatformServiceImpl", "description": "The class interacts with the database using Spring's JdbcTemplate. It executes parameterized SQL SELECT queries to fetch data from the 'm_family_members' table and joins it with 'm_code_value' to retrieve descriptive values for foreign keys.", "databaseName": "unknown", "tablesAccessed": [ "m_family_members", "m_code_value" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with LEFT JOINs to resolve code values.", "transactionHandling": "None (Read-only operations)", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, rm, clientId);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JDBC", "name": "ClientChargeReadPlatformServiceImpl", "description": "The class interacts directly with the database using Spring's `JdbcTemplate`. It constructs raw SQL SELECT statements that join the `m_charge`, `m_organisation_currency`, and `m_client_charge` tables to assemble the required data view.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_organisation_currency", "m_client_charge" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with JOINs, dynamic WHERE clauses based on filter criteria, and pagination logic.", "transactionHandling": "None explicitly defined in this read-only service.", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.queryForObject(sql, rm, clientId, clientChargeId);" }, { "path": "org.apache.fineract.portfolio.client.service.ClientReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class primarily uses Spring's `JdbcTemplate` to perform read-only operations against the database. It constructs complex SQL queries dynamically to handle search criteria, joins multiple tables (client, office, staff, code_value, etc.) to aggregate data, and uses `RowMapper` classes to transform `ResultSet` data into DTOs. It also utilizes `ClientRepositoryWrapper` (likely JPA/Spring Data) for retrieving domain entities in specific cases like `retrieveOne`.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_office", "m_staff", "m_code_value", "m_savings_product", "m_client_non_person", "m_group_client", "m_group", "m_appuser", "m_selfservice_user_client_mapping", "m_client_identifier" ], "operationType": [ "READ" ], "queryPatterns": "The code uses dynamic SQL generation for search filters (building WHERE clauses based on input), complex joins to fetch related data (office, staff, code values) in a single query, and pagination logic.", "transactionHandling": "Not explicitly annotated with @Transactional in this file, relying on the service layer or default read-only behavior of the underlying connection for select statements.", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate", "codeExample": "final String sql = \"select \" + this.membersOfGroupMapper.schema() + \" where o.hierarchy like ? and pgc.group_id = ?\";\nreturn this.jdbcTemplate.query(sql, this.membersOfGroupMapper, hierarchySearchString, groupId);" }, { "path": "org.apache.fineract.portfolio.collateral.service", "mechanism": "JDBC", "name": "CollateralReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually maps the ResultSet to domain objects using a custom RowMapper. The queries involve joins across multiple tables to aggregate collateral, code value, loan, and currency information.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_collateral", "m_code_value", "m_loan", "m_organisation_currency" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with JOINs to retrieve related entity data.", "transactionHandling": "None explicit (likely relies on auto-commit for read-only operations)", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate (DataSource)", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { loanId });" }, { "path": "org.apache.fineract.portfolio.collectionsheet.service", "mechanism": "JDBC", "name": "Fineract Core Database", "description": "The class uses Spring's NamedParameterJdbcTemplate to execute raw SQL queries. It manually maps ResultSets to domain objects using inner class RowMappers. The SQL is constructed dynamically to handle different hierarchy levels (Group vs Center) and filtering options.", "databaseName": "unknown", "tablesAccessed": [ "m_group", "m_office", "m_group_level", "m_staff", "m_group_client", "m_client", "m_loan", "m_product_loan", "m_currency", "m_loan_repayment_schedule", "m_calendar_instance", "m_meeting", "m_client_attendance", "m_loan_charge", "m_savings_account", "m_savings_product", "m_deposit_account_recurring_detail", "m_mandatory_savings_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple tables to aggregate financial data (loans, savings) with structural data (groups, clients). Uses dynamic SQL generation.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.namedParameterJdbcTemplate.query(mapper.collectionSheetSchema(false), namedParameters, mapper);" }, { "path": "org.apache.fineract.portfolio.floatingrates.service.FloatingRatesReadPlatformServiceImpl", "mechanism": "JDBC", "name": "FloatingRatesReadPlatformServiceImpl", "description": "The class interacts directly with the database using Spring's JdbcTemplate. It constructs SQL queries manually using StringBuilder within inner RowMapper classes to select data from multiple tables.", "databaseName": "unknown", "tablesAccessed": [ "m_floating_rates", "m_appuser", "m_floating_rates_periods", "m_product_loan", "m_product_loan_floating_rates" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL queries with multiple LEFT JOINs and subqueries, particularly in FloatingInterestRatePeriodRowMapper.", "transactionHandling": "None explicitly defined (likely relies on default read-only behavior or non-transactional reads).", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + rateMapper.schema() + \" where rate.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, rateMapper, new Object[] { floatingRateId });" }, { "path": "org.apache.fineract.portfolio.fund.service", "mechanism": "JDBC", "name": "FundReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It maps the results manually using a RowMapper implementation.", "databaseName": "unknown", "tablesAccessed": [ "m_fund" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with basic filtering and ordering.", "transactionHandling": "None explicit (likely auto-commit for reads)", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.portfolio.group.service", "mechanism": "JDBC", "name": "AllGroupTypesDataMapper", "description": "The class interacts with the database by defining a raw SQL schema and mapping the resulting JDBC ResultSet to Java objects. It uses Spring's RowMapper interface to facilitate this within the Spring JDBC framework.", "databaseName": "unknown", "tablesAccessed": [ "m_group", "m_office", "m_staff", "m_appuser" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving multiple tables (m_group, m_office, m_staff, m_appuser) to enrich the core entity data.", "transactionHandling": "None", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "sqlBuilder.append(\"g.id as id, g.account_no as accountNumber... from m_group g \");\n// ...\nfinal Long id = rs.getLong(\"id\");" }, { "path": "org.apache.fineract.portfolio.group.service", "mechanism": "JDBC", "name": "GroupLevelReadPlatformServiceImpl", "description": "The service interacts with the database using Spring's JdbcTemplate to execute a raw SQL SELECT query. It manually maps the ResultSet to domain objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_group_level" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL SELECT statement using LEFT JOINs to retrieve self-referencing hierarchical data (parent and child levels).", "transactionHandling": "No explicit transaction management (likely read-only or auto-commit).", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate", "codeExample": "final String sql = \"select \" + rm.groupLevelSchema();\nreturn this.jdbcTemplate.query(sql, rm);" }, { "path": "org.apache.fineract.portfolio.group.service", "mechanism": "JDBC", "name": "GroupReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL strings dynamically using StringBuilder and a custom SQLBuilder utility to manage WHERE clauses and arguments safely.", "databaseName": "unknown", "tablesAccessed": [ "m_group", "m_office" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation with joins, filtering criteria, and pagination.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sqlBuilder.toString(), ALL_GROUP_TYPES_DATA_MAPPER, extraCriteria.getArguments());" }, { "path": "org.apache.fineract.portfolio.group.service.CenterReadPlatformServiceImpl", "mechanism": "JDBC", "name": "CenterReadPlatformService Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It defines SQL schemas in inner RowMapper classes and constructs dynamic WHERE clauses using a SQLBuilder helper. It interacts with tables related to groups, offices, staff, calendars, and loans.", "databaseName": "unknown", "tablesAccessed": [ "m_group", "m_office", "m_staff", "m_appuser", "m_calendar", "m_calendar_instance", "m_group_client", "m_client", "m_loan", "m_loan_repayment_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries, aggregations for loan totals, and dynamic criteria generation.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, this.centerMapper, new Object[] { centerId });" }, { "path": "org.apache.fineract.portfolio.group.service.GroupRolesReadPlatformServiceImpl", "mechanism": "JDBC", "name": "GroupRolesReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually maps ResultSets to domain objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_group_roles", "m_code_value", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with JOINs", "transactionHandling": "None (Read-only operations)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql, mapper, new Object[] { groupId });" }, { "path": "org.apache.fineract.portfolio.interestratechart.service", "mechanism": "JDBC", "name": "InterestRateChartSlabReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL strings dynamically to handle database-specific syntax via DatabaseSpecificSQLGenerator. It reads from multiple joined tables to assemble complex objects.", "databaseName": "unknown", "tablesAccessed": [ "m_interest_rate_slab", "m_interest_incentives", "m_code_value", "m_currency" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving left joins to fetch parent entities (slabs) and child entities (incentives) in a single result set.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, this.chartSlabExtractor, new Object[] { chartId });" }, { "path": "org.apache.fineract.portfolio.interestratechart.service.InterestRateChartReadPlatformServiceImpl", "mechanism": "JDBC", "name": "InterestRateChart Database Access", "description": "The class uses Spring JdbcTemplate to execute raw SQL queries. It constructs complex SQL strings involving multiple joins (charts, slabs, incentives, codes, currencies) and uses custom ResultSetExtractors to map the flat result set into a hierarchical object structure.", "databaseName": "unknown", "tablesAccessed": [ "m_interest_rate_chart", "m_interest_rate_slab", "m_interest_incentives", "m_code_value", "m_currency", "m_deposit_product_interest_rate_chart", "m_savings_product" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with sub-entities (slabs, incentives) and dynamic ordering.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "final String sql = \"select \" + CHART_ROW_MAPPER.schema() + \" where irc.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, CHART_ROW_MAPPER, chartId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.service.GuarantorReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Guarantor Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It constructs SQL strings dynamically using inner helper classes (Mappers) that define the schema and column selection. It uses PreparedStatement to bind parameters safely.", "databaseName": "unknown", "tablesAccessed": [ "m_guarantor", "m_code_value", "m_guarantor_funding_details", "m_portfolio_account_associations", "m_savings_account", "m_guarantor_transaction", "m_deposit_account_on_hold_transaction", "m_client", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving multiple tables (guarantor, funding, transactions, accounts) with grouping and ordering. Uses scroll-sensitive ResultSets to handle one-to-many mapping logic manually in Java.", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "JDBC", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(con -> {\n PreparedStatement preparedStatement = con.prepareStatement(finalSql, ResultSet.TYPE_SCROLL_SENSITIVE,\n ResultSet.CONCUR_UPDATABLE);\n preparedStatement.setInt(1, AccountAssociationType.GUARANTOR_ACCOUNT_ASSOCIATION.getValue());\n preparedStatement.setLong(2, loanId);\n return preparedStatement;\n}, rm);" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.applyholidaystoloans", "mechanism": "JDBC", "name": "JobRepository", "description": "The class configures a Spring Batch Job which relies on a `JobRepository`. This repository persists the state of batch job executions, steps, and contexts to the database (typically tables like BATCH_JOB_INSTANCE, BATCH_JOB_EXECUTION) using JDBC or a similar datasource connection managed by the `PlatformTransactionManager`.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION", "BATCH_JOB_EXECUTION_CONTEXT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal CRUD operations for job metadata management", "transactionHandling": "Spring PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "new StepBuilder(JobName.APPLY_HOLIDAYS_TO_LOANS.name(), jobRepository)\n .tasklet(applyHolidaysToLoansTasklet, transactionManager).build();" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.updateloanarrearsageing.LoanArrearsAgeingUpdateHandler", "mechanism": "JDBC", "name": "LoanArrearsAgeingUpdateHandler", "description": "The class uses Spring's JdbcTemplate and NamedParameterJdbcTemplate to perform direct SQL operations. It constructs complex SQL strings dynamically to handle aggregations and filtering logic for loan arrears calculations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_arrears_aging", "m_loan", "m_loan_repayment_schedule", "m_product_loan_recalculation_details", "m_loan_repayment_schedule_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Complex SQL generation involving joins, aggregations (SUM, MIN), and subqueries. Uses batch updates for performance.", "transactionHandling": "Manual/Implicit (relies on Spring context or caller transaction)", "protocol": "SQL", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "jdbcTemplate.update(\"delete from m_loan_arrears_aging where loan_id=?\", loanId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.service", "mechanism": "JDBC", "name": "LoanScheduleHistoryReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It reads from the loan repayment schedule history tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_repayment_schedule_history", "m_loan_repayment_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with aggregations (MAX) and filtering by ID.", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "Integer max = this.jdbcTemplate.queryForObject(sql, new Object[] { loanId }, Integer.class);" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.service.LoanRescheduleRequestReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually maps ResultSets to Java objects using inner RowMapper classes. It constructs SQL strings dynamically for filtering.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_reschedule_request", "m_code_value", "m_appuser", "m_loan", "m_client", "m_loan_reschedule_request_term_variations_mapping", "m_loan_term_variations" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries and dynamic criteria", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, LOAN_RESCHEDULE_REQUEST_ROW_MAPPER, loanId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "JDBC", "name": "LoanChargePaidByReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute direct SQL queries. It performs a read operation involving joins across three tables to link paid charges to their definitions and the transaction.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_charge_paid_by", "m_loan_charge", "m_charge" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with INNER JOINs to retrieve related entity data.", "transactionHandling": "None explicit (likely relies on auto-commit for reads or caller transaction).", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + rm.loanChargePaidBySchema() + \" where lcpd.loan_transaction_id = ?\";\nreturn this.jdbcTemplate.query(sql, rm, transactionId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "JDBC", "name": "GLIMAccountInfoReadPlatformService", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It defines custom RowMappers (GLIMFieldsMapper, GLIMMapper, GLIMRepaymentMapper) to map the ResultSets to Java POJOs.", "databaseName": "unknown", "tablesAccessed": [ "glim_accounts", "m_loan", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL queries constructed by concatenating schema strings from inner classes with WHERE clauses. It performs joins between glim_accounts, m_loan, and m_client tables.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + rm.schema() + \" and glim.id=?\";\nreturn this.jdbcTemplate.query(sql, rm, glimId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class primarily uses Spring's `JdbcTemplate` and `NamedParameterJdbcTemplate` to execute raw SQL queries for data retrieval. This is done to optimize performance for read operations, avoiding the overhead of JPA entity management for complex reporting views. It also uses `LoanRepositoryWrapper` (JPA) for some domain logic and entity retrieval where necessary.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_office", "m_client", "m_group", "m_product_loan", "m_loan_recalculation_details", "m_currency", "m_loan_arrears_aging", "m_fund", "m_staff", "m_appuser", "m_code_value", "m_product_loan_variable_installment_config", "m_loan_topup", "m_loan_repayment_schedule", "m_loan_transaction", "m_payment_detail", "m_payment_type", "m_account_transfer_transaction", "glim_parent_child_mapping", "m_loan_disbursement_detail", "m_loan_tranche_disbursement_charge", "m_loan_charge", "m_loan_term_variations", "m_loan_interest_recalculation_additional_details", "m_product_loan_floating_rates", "m_floating_rates", "m_floating_rates_periods", "m_loan_reschedule_request" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL SELECT statements with multiple JOINs, subqueries, aggregations, and dynamic WHERE clauses based on search parameters.", "transactionHandling": "Spring @Transactional(readOnly = true) annotation at the class level.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final String sql = \"select \" + rm.loanSchema() + \" where l.account_no=?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, loanAccountNumber);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It defines inner class RowMappers to map SQL result sets to Java objects.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_group", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "SQL queries involving joins between entity tables (m_client, m_group) and the loan table (m_loan) with filtering by ID and status.", "transactionHandling": "None explicit (likely read-only or handled by caller)", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(clientSql, staffClientMapper, loanOfficerId, ClientStatus.ACTIVE.getValue());" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanAccrualWritePlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Database", "description": "The class uses a mix of Spring Data JPA (via `LoanRepository`, `LoanTransactionRepository`) for object retrieval and persistence, and raw Spring `JdbcTemplate` for specific updates to the `m_loan_charge_paid_by`, `m_loan_repayment_schedule`, and `m_loan` tables. This hybrid approach allows for domain-driven design where appropriate and optimized SQL execution for batch or specific field updates.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_transaction", "m_loan_charge_paid_by", "m_loan_repayment_schedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs JPA save/flush operations for transactions and uses inline SQL UPDATE and INSERT statements via JdbcTemplate for updating loan schedules and charge associations.", "transactionHandling": "Spring @Transactional annotations are used on public methods to ensure atomicity of the database operations.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "String repaymentUpdateSql = \"UPDATE m_loan_repayment_schedule SET accrual_interest_derived=?, accrual_fee_charges_derived=?, \"\n + \"accrual_penalty_charges_derived=? WHERE id=?\";\nthis.jdbcTemplate.update(repaymentUpdateSql, totalAccInterest, totalAccFee, totalAccPenalty,\n scheduleAccrualData.getRepaymentScheduleId());" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanArrearsAgingServiceImpl", "mechanism": "JDBC", "name": "LoanArrearsAgingDatabase", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries and updates. It interacts with the 'm_loan_arrears_aging' table to store calculated overdue metrics and reads from 'm_loan' and 'm_loan_repayment_schedule_history' to derive these metrics.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_arrears_aging", "m_loan", "m_loan_repayment_schedule_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code uses SELECT COUNT queries to check existence, SELECT queries with joins to fetch schedule history, and manually constructed INSERT/UPDATE/DELETE strings for data persistence.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.update(\"DELETE FROM m_loan_arrears_aging WHERE loan_id=?\", loan.getId());" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanChargeReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate & LoanChargeRepository", "description": "The class primarily uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It constructs SQL strings manually, often using inner class RowMappers to define the schema and map ResultSet rows to DTOs. It also uses a Spring Data JPA repository (LoanChargeRepository) for a single ID lookup method.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_organisation_currency", "m_loan_charge", "m_loan_tranche_disbursement_charge", "m_loan_disbursement_detail", "m_loan", "m_loan_installment_charge", "m_loan_repayment_schedule", "m_loan_charge_paid_by", "m_loan_transaction" ], "operationType": [ "READ" ], "queryPatterns": "The code uses raw SQL with complex joins (INNER JOIN, LEFT JOIN) across multiple tables. It includes subqueries for calculating accrued amounts and unrecognized income portions. Queries are dynamically constructed in some methods based on input parameters.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final LoanChargeMapper rm = new LoanChargeMapper();\nfinal String sql = \"select \" + rm.schema() + \" where lc.id=? and lc.loan_id=?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, id, loanId);" }, { "path": "org.apache.fineract.portfolio.loanproduct.productmix.service", "mechanism": "JDBC", "name": "ProductMixReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database. It joins the `m_product_mix` and `m_product_loan` tables to retrieve product mix configurations.", "databaseName": "unknown", "tablesAccessed": [ "m_product_mix", "m_product_loan" ], "operationType": [ "READ" ], "queryPatterns": "Simple SQL SELECT with JOINs", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "final String sql = \"Select \" + extractor.schema() + \" where pm.product_id=?\";\nfinal Map productMixData = this.jdbcTemplate.query(sql, extractor, productId);" }, { "path": "org.apache.fineract.portfolio.loanproduct.service.LoanProductReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Fineract Core Database", "description": "The class relies heavily on Spring's JdbcTemplate to perform read operations. It constructs raw SQL strings, often using string concatenation for dynamic clauses (like security scoping). It maps the results using custom RowMapper implementations (LoanProductMapper, LoanProductLookupMapper, etc.). One method uses Spring Data JPA (LoanProductRepository).", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan", "m_fund", "m_product_loan_recalculation_details", "m_product_loan_guarantee_details", "m_product_loan_configurable_attributes", "m_product_loan_floating_rates", "m_floating_rates", "m_product_loan_variable_installment_config", "m_delinquency_bucket", "m_currency", "m_loan_product_payment_allocation_rule", "m_product_loan_variations_borrower_cycle", "m_product_mix" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple configuration tables, dynamic WHERE clause generation for data scoping, UNION queries for product mix logic.", "transactionHandling": "None explicitly defined in this class (likely read-only or handled by caller)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource", "codeExample": "final String sql = \"select \" + rm.loanProductSchema() + \" where lp.id = ?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, loanProductId);" }, { "path": "org.apache.fineract.portfolio.meeting.attendance.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries directly against the database. It manually maps the result set to Java objects using a RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_meeting", "m_client_attendance", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL with INNER JOINs across three tables", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { meetingId });" }, { "path": "org.apache.fineract.portfolio.meeting.service", "mechanism": "JDBC", "name": "MeetingReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually maps ResultSets to objects using a RowMapper implementation.", "databaseName": "unknown", "tablesAccessed": [ "m_meeting", "m_calendar_instance", "m_calendar" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD SELECT queries with inner joins and filtering by foreign keys.", "transactionHandling": "None (Read-only operations, likely relying on auto-commit or higher-level transaction management)", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.queryForObject(sql, rm, new Object[] { meetingId, entityId, entityTypeId });" }, { "path": "org.apache.fineract.portfolio.note.service", "mechanism": "JDBC", "name": "NoteReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries. It manually maps `ResultSet` data to Java objects using a custom `RowMapper`. It constructs dynamic SQL strings to handle different filtering criteria based on the entity type (Client, Loan, etc.).", "databaseName": "unknown", "tablesAccessed": [ "m_note", "m_appuser" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD SELECT queries with LEFT JOINs to user tables.", "transactionHandling": "none", "protocol": "SQL", "connectionInfo": "not identifiable from code", "codeExample": "return this.jdbcTemplate.queryForObject(sql, rm, paramList.toArray());" }, { "path": "org.apache.fineract.portfolio.rate.service", "mechanism": "JDBC", "name": "RateReadServiceImpl", "description": "The class interacts with the database using Spring's JdbcTemplate. It constructs SQL SELECT statements by concatenating schema strings defined in the inner RateMapper class. It maps the ResultSet to RateData POJOs.", "databaseName": "unknown", "tablesAccessed": [ "m_rate", "m_loan_rate", "m_product_loan_rate" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries, some involving INNER JOINs to link rates with loans or products.", "transactionHandling": "None explicit (likely read-only auto-commit)", "protocol": "JDBC", "connectionInfo": "DataSource injected via Spring", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { loanId });" }, { "path": "org.apache.fineract.portfolio.savings.jobs.generateadhocclientschhedule", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute dynamic SQL queries. It performs data insertion based on ad-hoc definitions and updates metadata in the 'm_adhoc' table.", "databaseName": "unknown", "tablesAccessed": [ "m_adhoc", "dynamic_tables_defined_in_adhoc_config" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Dynamic SQL construction (INLINE SQL) for inserts, and standard parameterized updates for metadata.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "configured in Spring Context", "codeExample": "jdbcTemplate.update(\"UPDATE m_adhoc SET last_run=? WHERE id=?\", new Date(), adhoc.getId());" }, { "path": "org.apache.fineract.portfolio.savings.jobs.generateadhocclientschhedule.GenerateAdhocClientScheduleConfig", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The configuration class injects a Spring JdbcTemplate and passes it to the GenerateAdhocClientScheduleTasklet. While this configuration file does not execute queries itself, it explicitly wires the JDBC access component into the job's execution logic.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "The actual queries are encapsulated within the Tasklet class, but the injection of JdbcTemplate suggests raw SQL or JDBC-based operations.", "transactionHandling": "Transactions are managed by the Spring Batch Step using the injected PlatformTransactionManager.", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "return new GenerateAdhocClientScheduleTasklet(adHocReadPlatformService, jdbcTemplate);" }, { "path": "org.apache.fineract.portfolio.savings.jobs.generaterdschedule", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL INSERT statements constructed via string concatenation. It writes directly to the `m_mandatory_savings_schedule` table.", "databaseName": "unknown", "tablesAccessed": [ "m_mandatory_savings_schedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch INSERT operations using manually constructed inline SQL strings.", "transactionHandling": "Manual batch execution within the tasklet context", "protocol": "JDBC", "connectionInfo": "Derived from RoutingDataSourceServiceFactory", "codeExample": "jdbcTemplate.update(insertSql + sb);" }, { "path": "org.apache.fineract.portfolio.savings.jobs.postinterestforsavings.PostInterestForSavingConfig", "mechanism": "JDBC", "name": "JobRepository and Savings Data Access", "description": "The class interacts with the database primarily through the Spring Batch 'JobRepository' for managing job state and metadata. Additionally, it injects 'JdbcTemplate' and 'SavingsAccountRepositoryWrapper', indicating that the underlying tasklet or the configuration context interacts with savings account tables, although these fields are not explicitly used in the configuration methods shown.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "m_savings_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch metadata management and Savings Account CRUD operations", "transactionHandling": "Spring PlatformTransactionManager used in Step configuration", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Autowired\nprivate JobRepository jobRepository;\n@Autowired\nprivate JdbcTemplate jdbcTemplate;" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL strings dynamically using StringBuilder and maps the results to Java objects using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_product", "m_deposit_product_term_and_preclosure", "m_currency", "m_tax_group", "m_deposit_product_recurring_detail" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving multiple tables (product, terms, currency, tax groups) to assemble a complete view of a deposit product.", "transactionHandling": "NONE", "protocol": "SQL", "connectionInfo": "configured in Spring DataSource", "codeExample": "this.jdbcTemplate.query(sqlBuilder.toString(), depositProductMapper, depositAccountType.getValue());" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JDBC", "name": "DepositAccountOnHoldTransactionReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL queries. It manually constructs SQL strings involving multiple joins to retrieve transaction details and maps the results to Java objects using a custom `RowMapper`.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_deposit_account_on_hold_transaction", "m_client", "m_guarantor_transaction", "m_guarantor_funding_details", "m_portfolio_account_associations", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple tables (savings, transactions, clients, guarantors, loans) with dynamic filtering and pagination.", "transactionHandling": "None explicit (Read-only operations likely relying on auto-commit or higher-level transaction management).", "protocol": "SQL", "connectionInfo": "n/a", "codeExample": "sqlBuilder.append(\"select \" + sqlGenerator.calcFoundRows() + \" \");\nsqlBuilder.append(this.mapper.schema());\nsqlBuilder.append(\" where tr.savings_account_id = ? \");\nparamObj.add(savingsId);" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually constructs SQL strings, including dynamic WHERE clauses for security scoping, and maps the results to Java objects using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_product", "m_currency", "m_tax_group" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL with dynamic WHERE clauses and joins", "transactionHandling": "None explicit in this file (likely read-only or handled by container)", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql, this.savingsProductRowMapper, new Object[] { DepositAccountType.SAVINGS_DEPOSIT.getValue() });" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It manually maps ResultSets to domain objects using inner classes that implement RowMapper and ResultSetExtractor. It handles complex joins to retrieve hierarchical data (Chart -> Slabs -> Incentives).", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account_interest_rate_chart", "m_savings_account_interest_rate_slab", "m_savings_interest_incentives", "m_code_value", "m_currency", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins involving multiple tables (charts, slabs, incentives, codes, currency) to reconstruct hierarchical object graphs. Uses conditional ordering in SQL.", "transactionHandling": "None explicit (Read-only service)", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(sql.toString(), this.chartExtractor, chartId);" }, { "path": "org.apache.fineract.portfolio.savings.service.DepositAccountReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It constructs SQL strings dynamically using StringBuilder and maps the results to Java objects using custom RowMapper implementations.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_deposit_account_term_and_preclosure", "m_savings_product", "m_currency", "m_client", "m_group", "m_staff", "m_appuser", "m_tax_group", "m_deposit_account_recurring_detail", "m_savings_account_transaction", "m_account_transfer_transaction", "m_payment_detail", "m_payment_type", "m_deposit_product_term_and_preclosure", "m_deposit_product_recurring_detail", "m_mandatory_savings_schedule", "m_calendar_instance", "m_calendar", "m_savings_account_charge", "m_charge", "m_portfolio_account_associations" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple tables, dynamic SQL generation based on parameters, pagination support, aggregation queries.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final StringBuilder sqlBuilder = new StringBuilder(400);\nsqlBuilder.append(\"select \");\nsqlBuilder.append(depositAccountMapper.schema());\nsqlBuilder.append(\" where sa.deposit_type_enum = ? \");\nreturn jdbcTemplate.query(sqlBuilder.toString(), depositAccountMapper, new Object[] { depositAccountType.getValue() });" }, { "path": "org.apache.fineract.portfolio.savings.service.GSIMReadPlatformServiceImpl", "mechanism": "JDBC", "name": "GSIM Database Access", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It defines custom RowMappers (GSIMFieldsMapper, GSIMMapper, SavingsAccountSummaryDataMapper) to map ResultSets to domain objects. It constructs SQL strings dynamically in some cases and uses ColumnValidator to prevent SQL injection.", "databaseName": "unknown", "tablesAccessed": [ "gsim_accounts", "m_savings_account", "m_savings_product", "m_currency", "m_appuser", "m_client", "m_savings_account_transaction" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries, specifically in the SavingsAccountSummaryDataMapper which joins multiple tables (products, currency, users, clients) and includes a subquery for transaction dates.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.jdbcTemplate.query(sql, rm, new Object[] { gsimId });" }, { "path": "org.apache.fineract.portfolio.savings.service.SavingsAccountChargeReadPlatformServiceImpl", "mechanism": "JDBC", "name": "SavingsAccountChargeReadPlatformServiceImpl", "description": "The class interacts with the database using Spring's JdbcTemplate. It constructs raw SQL queries to read data from the 'm_savings_account_charge' table and joins it with 'm_charge', 'm_organisation_currency', and 'm_savings_account' tables. It uses custom RowMapper implementations to map the ResultSet to domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_organisation_currency", "m_savings_account_charge", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with multiple tables, dynamic filtering based on status, and date-based criteria.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "final String sql = \"select \" + rm.schema() + \" where sc.id=? and sc.savings_account_id=?\";\nreturn this.jdbcTemplate.queryForObject(sql, rm, new Object[] { id, savingsAccountId });" }, { "path": "org.apache.fineract.portfolio.savings.service.SavingsAccountReadPlatformServiceImpl", "mechanism": "JDBC", "name": "SavingsAccount Database Access", "description": "The class primarily uses Spring's `JdbcTemplate` to perform read-only operations against the database. It constructs SQL queries dynamically using `StringBuilder` to handle optional search parameters and joins multiple tables (account, product, client, group, transactions, etc.) to assemble rich DTOs. It uses custom `RowMapper` and `ResultSetExtractor` implementations to map the relational data to object structures. There is minor usage of `SavingsAccountRepositoryWrapper` (Spring Data) for external ID lookup.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_product", "m_currency", "m_client", "m_group", "m_staff", "m_appuser", "m_savings_account_transaction", "m_payment_detail", "m_payment_type", "m_tax_group", "m_tax_component", "acc_product_mapping", "m_account_transfer_transaction", "m_note", "m_savings_account_charge", "m_savings_account_charge_paid_by", "m_savings_account_transaction_tax_details" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with subqueries, dynamic SQL generation based on search criteria, keyset pagination for batch jobs.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final StringBuilder sqlBuilder = new StringBuilder(\"select \" + this.savingAccountMapper.schema());\nsqlBuilder.append(\" where sa.client_id = ? and sa.status_enum = 300 \");\nfinal Object[] queryParameters = new Object[] { clientId };\nreturn this.jdbcTemplate.query(sqlBuilder.toString(), this.savingAccountMapper, queryParameters);" }, { "path": "org.apache.fineract.portfolio.savings.service.SavingsSchedularInterestPoster", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's `JdbcTemplate` to perform batch SQL operations for performance efficiency. It constructs raw SQL `INSERT` and `UPDATE` statements for savings transactions, account summaries, and general ledger journal entries, executing them in batches rather than individually.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction", "acc_gl_journal_entry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch operations with inline SQL for inserts and updates", "transactionHandling": "Spring @Transactional with Isolation.READ_UNCOMMITTED", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.batchUpdate(queryForJGLUpdate, paramsForGLInsertion);" }, { "path": "org.apache.fineract.portfolio.savings.service.search.SavingsAccountTransactionsSearchServiceImpl", "mechanism": "JDBC", "name": "SavingsAccountTransactionsSearchServiceImpl", "description": "The class interacts with the database using Spring's `JdbcTemplate`. It dynamically constructs SQL strings (SELECT, FROM, WHERE, ORDER BY) based on input filters and executes them. It uses `DatabaseSpecificSQLGenerator` to handle SQL dialect differences.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account_transaction" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation with complex filtering and optional joins to datatables.", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "JDBC", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "List results = this.jdbcTemplate.query(query.toString(), tm, args);" }, { "path": "org.apache.fineract.portfolio.search.service", "mechanism": "JDBC", "name": "SearchUtil", "description": "This class acts as a utility for JDBC-based database interactions. It does not execute queries itself but prepares SQL fragments (WHERE clauses) and processes JDBC `SqlRowSet` results. It bridges the gap between API search parameters and raw SQL execution, handling dialect differences via `DatabaseSpecificSQLGenerator`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation for filtering (WHERE clauses)", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "public static void buildCondition(...) {\n where.append(operator.formatPlaceholder(sqlGenerator, definition, paramCount, alias));\n if (values != null) {\n params.addAll(values);\n }\n}" }, { "path": "org.apache.fineract.portfolio.search.service.SearchReadPlatformServiceImpl", "mechanism": "JDBC", "name": "NamedParameterJdbcTemplate", "description": "The class uses Spring's NamedParameterJdbcTemplate to execute raw SQL queries. It manually constructs SQL strings involving multiple joins and unions to aggregate data from various tables.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_office", "m_loan", "m_group", "m_product_loan", "m_savings_account", "m_savings_product", "m_share_account", "m_share_product", "m_client_identifier" ], "operationType": [ "READ" ], "queryPatterns": "Complex dynamic SQL generation using StringBuilder, UNIONs across multiple entity tables, and dynamic WHERE clauses based on filter criteria.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "return namedParameterJdbcTemplate.query(searchSchema(searchConditions), params, rm);" }, { "path": "org.apache.fineract.portfolio.search.starter", "mechanism": "JDBC", "name": "SearchReadPlatformService Configuration", "description": "This configuration class injects the 'NamedParameterJdbcTemplate' into the 'SearchReadPlatformService', enabling the service to perform database operations. While this file does not execute SQL directly, it is responsible for wiring the database access component.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Configured via NamedParameterJdbcTemplate", "codeExample": "public SearchReadPlatformService searchReadPlatformService(NamedParameterJdbcTemplate namedParameterJdbcTemplate, ...) { return new SearchReadPlatformServiceImpl(namedParameterJdbcTemplate, ...); }" }, { "path": "org.apache.fineract.portfolio.self.account.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the application database. It performs complex read operations involving joins across multiple tables and a UNION of two select statements.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser", "m_selfservice_user_client_mapping", "m_client", "m_office", "m_savings_account", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Complex SQL query using INNER JOINs across 5 tables and a UNION operator to combine results from savings and loan tables.", "transactionHandling": "None explicit (likely relies on default auto-commit for read operations or higher-level transaction management).", "protocol": "SQL", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.query(sql.toString(), mapper, new Object[] { user.getId(), user.getId() });" }, { "path": "org.apache.fineract.portfolio.self.account.service.SelfBeneficiariesTPTReadPlatformServiceImpl", "mechanism": "JDBC", "name": "SelfBeneficiariesTPTReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries. It constructs complex SQL strings involving joins and unions within inner mapper classes and executes them to retrieve data mapped to Java objects.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_beneficiaries_tpt", "m_office", "m_client", "m_savings_account", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "The code uses parameterized SQL queries constructed via StringBuilder. It features complex patterns including INNER JOINs across multiple tables (office, client, savings/loan) and UNION ALL to combine results for different account types (savings vs loans).", "transactionHandling": "No explicit transaction handling is observed in this read-only service; it likely relies on the default auto-commit behavior or a higher-level transaction context.", "protocol": "SQL", "connectionInfo": "n/a", "codeExample": "this.jdbcTemplate.query(this.mapper.schema(), this.mapper, new Object[] { user.getId(), user.getId() });" }, { "path": "org.apache.fineract.portfolio.self.client.service.AppuserClientMapperReadServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database to verify user-client mappings.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_user_client_mapping" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT count query with a case statement to return a boolean.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "this.jdbcTemplate.queryForObject(\n \"select case when (count(*) > 0) then true else false end \"\n + \" from m_selfservice_user_client_mapping where client_id = ? and appuser_id = ?\",\n Boolean.class, clientId, appUserId);" }, { "path": "org.apache.fineract.portfolio.self.loanaccount.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries directly against the database to check for data existence.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_user_client_mapping", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Simple SQL SELECT with a LEFT JOIN and a CASE statement to return a boolean based on row count.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.queryForObject(\"select case when (count(*) > 0) then true else false end ...\", Boolean.class, loanId, appUserId);" }, { "path": "org.apache.fineract.portfolio.self.loanaccount.starter.SelfLoanAccountConfiguration", "mechanism": "JDBC", "name": "AppuserLoansMapperReadService", "description": "The class configures a service that interacts with the database using Spring's JdbcTemplate. While this specific file does not contain SQL queries, it injects the JdbcTemplate into the service implementation (AppuserLoansMapperReadServiceImpl) which performs the actual database operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public AppuserLoansMapperReadService appuserLoansMapperReadService(JdbcTemplate jdbcTemplate) {\n return new AppuserLoansMapperReadServiceImpl(jdbcTemplate);\n}" }, { "path": "org.apache.fineract.portfolio.self.pockets.service", "mechanism": "JDBC", "name": "PocketAccountMappingReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate for direct SQL execution to validate mappings and Repository wrappers (likely wrapping JPA/Spring Data) for retrieving domain entities.", "databaseName": "unknown", "tablesAccessed": [ "m_pocket_accounts_mapping" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT count query and repository finders.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "final String sql = \"select count(id) from m_pocket_accounts_mapping mapping where pocket_id = ? and account_id = ? and account_type = ?\";\nint count = this.jdbcTemplate.queryForObject(sql, Integer.class, pocketId, accountId, accountType);" }, { "path": "org.apache.fineract.portfolio.self.registration.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database.", "databaseName": "unknown", "tablesAccessed": [ "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT COUNT query with dynamic filtering criteria.", "transactionHandling": "unknown", "protocol": "JDBC", "connectionInfo": "configured via Spring DataSource", "codeExample": "String sql = \"select count(*) from m_client where account_no = ? ...\";\nint count = this.jdbcTemplate.queryForObject(sql, Integer.class, params);" }, { "path": "org.apache.fineract.portfolio.self.savings.service", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries directly against the database to check for the existence of a relationship between users and savings accounts.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_user_client_mapping", "m_savings_account" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL query using joins and aggregation (count) to return a boolean.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.queryForObject(\"select case when (count(*) > 0) then true else false end ...\", Boolean.class, savingsId, appUserId);" }, { "path": "org.apache.fineract.portfolio.self.savings.starter.SelfSavingsConfiguration", "mechanism": "JDBC", "name": "AppuserSavingsMapperReadService", "description": "The configuration class injects a Spring `JdbcTemplate` and passes it to the `AppuserSavingsMapperReadServiceImpl`. This indicates that the underlying service performs database operations using the JDBC template abstraction, likely executing raw SQL queries to read data.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ" ], "queryPatterns": "The configuration itself does not contain queries, but it wires up a service that likely performs SQL SELECT operations via JdbcTemplate.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "configured via Spring Boot DataSource (injected)", "codeExample": "public AppuserSavingsMapperReadService appuserSavingsMapperReadService(JdbcTemplate jdbcTemplate) {\n return new AppuserSavingsMapperReadServiceImpl(jdbcTemplate);\n}" }, { "path": "org.apache.fineract.portfolio.self.shareaccounts.service", "mechanism": "JDBC", "name": "AppUserShareAccountsMapperReadPlatformServiceImpl", "description": "Uses Spring JdbcTemplate to execute a raw SQL SELECT query to verify data existence.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_user_client_mapping", "m_share_account" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL query with a LEFT JOIN and WHERE clause to count records.", "transactionHandling": "None explicit, likely relies on caller or default auto-commit for reads.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.jdbcTemplate.queryForObject(\"select case when (count(*) > 0) then true else false end ...\", Boolean.class, accountId, appUserId);" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service", "mechanism": "JDBC", "name": "ShareAccountChargeReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries. It manually constructs SQL strings involving joins between charge, currency, and share account charge tables and maps the results to Data Transfer Objects (DTOs).", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_organisation_currency", "m_share_account_charge" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with JOINs and dynamic WHERE clauses based on status.", "transactionHandling": "None (Read-only operations, likely relying on default auto-commit or higher-level transaction scope)", "protocol": "SQL", "connectionInfo": "DataSource injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sqlBuilder.toString(), rm, new Object[] { accountId });" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service", "mechanism": "JDBC", "name": "PurchasedSharesReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL queries against the database.", "databaseName": "unknown", "tablesAccessed": [ "m_share_account_transactions" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT query with WHERE clause filtering by account_id and is_active status.", "transactionHandling": "None (Read-only operation, relies on default auto-commit or surrounding transaction context)", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, mapper, new Object[] { accountId });" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service.ShareAccountDividendReadPlatformServiceImpl", "mechanism": "JDBC", "name": "Share Account Dividend Database Access", "description": "The class interacts directly with the database using Spring's JdbcTemplate. It constructs SQL queries manually to join multiple tables related to share accounts and dividends. It uses a custom RowMapper to map the result set to domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_share_account_dividend_details", "m_share_product_dividend_pay_out", "m_share_account", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins with dynamic filtering and pagination logic constructed via StringBuilder.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "sb.append(\"select \");\n sb.append(\" sadd.id as id, \");\n sb.append(\" sa.savings_account_id as savingsAccountId \");\n sb.append(\" from m_share_account_dividend_details sadd\");\n // ... joins ...\n return this.jdbcTemplate.queryForList(sb.toString(), ...);" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service.ShareAccountReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ShareAccountReadPlatformServiceImpl", "description": "The class uses Spring's JdbcTemplate to execute raw SQL SELECT queries against the database. It constructs SQL strings manually (often using StringBuilder) and maps the ResultSets to Java objects using inner class RowMappers. This approach is used for read-only operations to optimize performance and avoid the overhead of JPA entities.", "databaseName": "unknown", "tablesAccessed": [ "m_share_account", "m_share_product", "m_currency", "m_client", "m_appuser", "m_savings_account", "m_share_account_transactions", "m_share_account_dividend_details", "m_share_product_dividend_pay_out" ], "operationType": [ "READ" ], "queryPatterns": "Complex joins across multiple tables (account, product, client, currency, users) with dynamic filtering and pagination.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "String query = \"select \" + mapper.schema() + \"where sa.id=?\";\nShareAccountData data = (ShareAccountData) this.jdbcTemplate.queryForObject(query, mapper, id);" }, { "path": "org.apache.fineract.portfolio.shareproducts.service", "mechanism": "JDBC", "name": "ShareProductDividendReadPlatformService", "description": "The class uses Spring's JdbcTemplate to execute SQL queries directly against the database. It constructs SELECT statements with joins between 'm_share_product_dividend_pay_out' and 'm_share_product' tables.", "databaseName": "unknown", "tablesAccessed": [ "m_share_product_dividend_pay_out", "m_share_product" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL construction with inner joins and conditional filtering based on input parameters.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final StringBuilder sqlBuilder = new StringBuilder(200);\nsqlBuilder.append(\"select \" + sqlGenerator.calcFoundRows() + \" \");\nsqlBuilder.append(shareProductDividendMapper.schema());\nsqlBuilder.append(\" where sp.id = ? \");\n// ...\nreturn this.paginationHelper.fetchPage(this.jdbcTemplate, sqlBuilder.toString(), paramsObj, shareProductDividendMapper);" }, { "path": "org.apache.fineract.portfolio.shareproducts.service.ShareProductReadPlatformServiceImpl", "mechanism": "JDBC", "name": "shareReadPlatformService", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries against the database. It manually maps ResultSets to Java objects using custom RowMapper implementations. It constructs SQL strings dynamically for pagination and filtering.", "databaseName": "unknown", "tablesAccessed": [ "m_share_product", "m_share_product_market_price", "m_currency", "m_appuser" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations using SELECT statements with LEFT JOINs. Pagination is handled via LIMIT/OFFSET.", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + mapper.schema() + \" where shareproduct.id = ?\";\nShareProductData data = (ShareProductData) this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { productId });" }, { "path": "org.apache.fineract.portfolio.tax.service.TaxReadPlatformServiceImpl", "mechanism": "JDBC", "name": "JdbcTemplate", "description": "The class uses Spring's JdbcTemplate to execute raw SQL queries. It defines SQL schemas within private static inner classes (RowMappers) using StringBuilder. It performs READ operations on tax-related tables.", "databaseName": "unknown", "tablesAccessed": [ "m_tax_component", "acc_gl_account", "m_tax_component_history", "m_tax_group", "m_tax_group_mappings" ], "operationType": [ "READ" ], "queryPatterns": "The code uses raw SQL SELECT statements constructed via StringBuilders. It performs complex joins (LEFT JOIN, INNER JOIN) to link tax components with GL accounts and history, and tax groups with their mappings. The RowMappers contain logic to handle one-to-many relationships by iterating the ResultSet.", "transactionHandling": "NONE", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "String sql = \"select \" + TAX_COMPONENT_MAPPER.getSchema();\nreturn this.jdbcTemplate.query(sql, TAX_COMPONENT_MAPPER);" }, { "path": "org.apache.fineract.spm.service.ScorecardReadPlatformServiceImpl", "mechanism": "JDBC", "name": "ScorecardReadPlatformServiceImpl", "description": "The service uses Spring's JdbcTemplate to execute raw SQL SELECT queries. It manually maps ResultSets to objects using inner RowMapper classes.", "databaseName": "unknown", "tablesAccessed": [ "m_survey_scorecards", "m_surveys", "m_appuser" ], "operationType": [ "READ" ], "queryPatterns": "Standard SELECT queries with LEFT JOINs and GROUP BY clauses.", "transactionHandling": "None explicit (likely read-only or auto-commit)", "protocol": "JDBC", "connectionInfo": "Injected via JdbcTemplate", "codeExample": "this.jdbcTemplate.query(sql, scm, new Object[] { surveyId });" }, { "path": "org.apache.fineract.useradministration.service", "mechanism": "JDBC", "name": "RoleReadPlatformServiceImpl", "description": "The class interacts directly with the database using Spring's JdbcTemplate. It constructs raw SQL strings for SELECT operations and maps the results to Java objects using a custom RowMapper.", "databaseName": "unknown", "tablesAccessed": [ "m_role", "m_appuser_role" ], "operationType": [ "READ" ], "queryPatterns": "Inline SQL SELECT statements with simple WHERE clauses and one INNER JOIN.", "transactionHandling": "None explicitly defined in this class (likely read-only auto-commit or handled by caller).", "protocol": "SQL", "connectionInfo": "Managed by Spring JdbcTemplate (DataSource injected)", "codeExample": "this.jdbcTemplate.query(sql, this.roleRowMapper);" }, { "path": "org.apache.fineract.useradministration.service", "mechanism": "JDBC", "name": "PermissionReadPlatformServiceImpl", "description": "The class uses Spring's `JdbcTemplate` to execute raw SQL SELECT queries. It manually maps the results to objects using a custom `RowMapper`.", "databaseName": "unknown", "tablesAccessed": [ "m_permission", "m_role_permission" ], "operationType": [ "READ" ], "queryPatterns": "Standard SQL SELECT statements with filtering (WHERE clauses using LIKE and inequality) and LEFT JOINs. Uses COALESCE for sorting.", "transactionHandling": "None explicit (likely relies on default read-only transaction or auto-commit context)", "protocol": "JDBC", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "return this.jdbcTemplate.query(sql, mapper, new Object[] {});" }, { "path": "org.apache.fineract.useradministration.service", "mechanism": "JDBC", "name": "AppUserReadPlatformService Database Access", "description": "The class uses a hybrid approach. It primarily uses Spring JDBC (JdbcTemplate) for read-heavy operations (lists, lookups, existence checks) by executing raw SQL queries against the 'm_appuser' and 'm_office' tables. It also uses Spring Data JPA (AppUserRepository) to retrieve full domain entities for detailed single-user views.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser", "m_office", "m_role", "m_staff", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "The code uses raw SQL SELECT statements with joins for list retrieval and JPA findById for single entity retrieval. It includes hierarchy-based filtering using 'like' clauses.", "transactionHandling": "No explicit transaction annotations are present on this class, implying read-only operations or reliance on the service layer default transaction configuration.", "protocol": "JDBC / JPA", "connectionInfo": "Managed by Spring DataSource (injected via JdbcTemplate)", "codeExample": "final String sql = \"select \" + mapper.schema();\nreturn this.jdbcTemplate.query(sql, mapper, new Object[] { hierarchySearchString });" }, { "path": "org.apache.fineract.useradministration.service.PasswordValidationPolicyReadPlatformServiceImpl", "mechanism": "JDBC", "name": "PasswordValidationPolicyReadPlatformServiceImpl", "description": "The class interacts directly with the database using Spring's JdbcTemplate to execute SQL queries. It reads from the 'm_password_validation_policy' table.", "databaseName": "unknown", "tablesAccessed": [ "m_password_validation_policy" ], "operationType": [ "READ" ], "queryPatterns": "Simple SELECT queries with basic filtering and ordering.", "transactionHandling": "None (Read-only operations, likely relies on auto-commit or upper-layer transaction management)", "protocol": "JDBC", "connectionInfo": "Managed by Spring JdbcTemplate (DataSource injected)", "codeExample": "this.jdbcTemplate.query(sql, this.passwordValidationPolicyMapper);" }, { "path": "fineract-provider/dependencies.gradle", "mechanism": "JPA", "name": "EclipseLink JPA", "description": "The build file defines the database technology stack by importing `spring-boot-starter-data-jpa` and explicitly swapping the default Hibernate provider for EclipseLink (`org.eclipse.persistence.jpa`). It also includes the `liquibase-core` library for database schema migrations and the `mysql-socket-factory-connector-j-8` for connecting to MySQL databases (specifically Google Cloud SQL).", "databaseName": "n/a", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional (inferred from spring-boot-starter-data-jpa dependency)", "protocol": "MySQL (Google Cloud SQL)", "connectionInfo": "n/a", "codeExample": "implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {\n exclude group: 'org.hibernate'\n}\nimplementation('org.eclipse.persistence:org.eclipse.persistence.jpa') {\n exclude group: 'org.eclipse.persistence', module: 'jakarta.persistence'\n}\n// ...\nimplementation 'com.google.cloud.sql:mysql-socket-factory-connector-j-8'" }, { "path": "fineract-core/dependencies.gradle", "mechanism": "JPA", "name": "EclipseLink JPA via Spring Data", "description": "The build file defines the persistence stack by importing 'spring-boot-starter-data-jpa' while explicitly excluding the default 'org.hibernate' group. It simultaneously adds 'org.eclipse.persistence.jpa', thereby configuring the application to use the Java Persistence API (JPA) with EclipseLink as the underlying ORM provider instead of Hibernate.", "databaseName": "not identifiable from code", "tablesAccessed": [ "not identifiable from code" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The dependencies suggest the use of JPA Entities and Repositories (Spring Data), likely involving JPQL or Criteria API, but specific patterns are not visible in this build file.", "transactionHandling": "Spring @Transactional (implied by the inclusion of spring-boot-starter-data-jpa)", "protocol": "not identifiable from code", "connectionInfo": "not identifiable from code", "codeExample": "implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {\n exclude group: 'org.hibernate'\n}\nimplementation('org.eclipse.persistence:org.eclipse.persistence.jpa') {\n exclude group: 'org.eclipse.persistence', module: 'jakarta.persistence'\n}" }, { "path": "fineract-investor/dependencies.gradle", "mechanism": "JPA", "name": "Spring Data JPA with EclipseLink", "description": "The build file configures the project's database integration layer by importing the Spring Boot Data JPA starter. Crucially, it explicitly excludes the default Hibernate provider and includes the EclipseLink JPA library instead, establishing EclipseLink as the ORM provider for the application.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM capabilities provided via libraries (no actual queries in build file)", "transactionHandling": "Spring @Transactional (implied by dependencies)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {\n exclude group: 'org.hibernate'\n}\nimplementation('org.eclipse.persistence:org.eclipse.persistence.jpa')" }, { "path": "org.apache.fineract.accounting.closure.domain", "mechanism": "JPA", "name": "GLClosure", "description": "The class is a JPA entity annotated with @Entity, mapping to the 'acc_gl_closure' table. It uses @ManyToOne for the relationship with the Office entity and defines a unique constraint on office_id and closing_date.", "databaseName": "acc_gl_closure", "tablesAccessed": [ "acc_gl_closure" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"acc_gl_closure\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"office_id\", \"closing_date\" }, name = \"office_id_closing_date\") })\npublic class GLClosure extends AbstractAuditableCustom {" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.domain.FinancialActivityAccount", "mechanism": "JPA", "name": "FinancialActivityAccount", "description": "The class is a JPA entity that maps to a relational database table. It defines the schema for storing financial activity account mappings, including a foreign key relationship to the GL Account table.", "databaseName": "acc_gl_financial_activity_account", "tablesAccessed": [ "acc_gl_financial_activity_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"acc_gl_financial_activity_account\")\npublic class FinancialActivityAccount extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.accounting.glaccount.domain", "mechanism": "JPA", "name": "TrialBalance", "description": "The class is a JPA Entity that maps directly to a relational database table. It defines column mappings for financial data.", "databaseName": "m_trial_balance", "tablesAccessed": [ "m_trial_balance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping for standard CRUD operations", "transactionHandling": "JPA EntityTransaction (implicit via container or framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_trial_balance\")\npublic class TrialBalance extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.accounting.glaccount.domain.GLAccount", "mechanism": "JPA", "name": "GLAccount Entity", "description": "The class is a JPA Entity annotated with @Entity and @Table. It maps to the 'acc_gl_account' table. It defines relationships using @ManyToOne for the parent account and tag, and @OneToMany for child accounts. It uses @Column annotations to define constraints like nullability and length.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with lazy loading for parent/child relationships.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"acc_gl_account\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"gl_code\" }, name = \"acc_gl_code\") })\npublic class GLAccount extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.accounting.journalentry.domain", "mechanism": "JPA", "name": "JournalEntry", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the relational database table 'acc_gl_journal_entry'. It uses @ManyToOne annotations to define foreign key relationships with Office, PaymentDetail, and GLAccount tables.", "databaseName": "acc_gl_journal_entry", "tablesAccessed": [ "acc_gl_journal_entry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"acc_gl_journal_entry\")\npublic class JournalEntry extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.domain.ProductToGLAccountMapping", "mechanism": "JPA", "name": "ProductToGLAccountMapping", "description": "The class is a JPA Entity mapped to the 'acc_product_mapping' table. It uses Jakarta Persistence annotations to define the table structure, columns, and foreign key relationships to other tables (GL Accounts, Charges, Payment Types).", "databaseName": "acc_product_mapping", "tablesAccessed": [ "acc_product_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"acc_product_mapping\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"product_id\", \"product_type\",\n \"financial_account_type\", \"payment_type\" }, name = \"financial_action\") })\npublic class ProductToGLAccountMapping extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service", "mechanism": "JPA", "name": "ProductToGLAccountMappingHelpers", "description": "The service uses Spring's `@Transactional` annotation to manage transaction boundaries. It delegates actual database persistence operations to helper classes (`LoanProductToGLAccountMappingHelper`, etc.), which likely use JPA or Spring Data Repositories to save mapping entities to the database.", "databaseName": "unknown", "tablesAccessed": [ "acc_product_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations via helper classes", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.loanProductToGLAccountMappingHelper.saveLoanToAssetOrLiabilityAccountMapping(element, LoanProductAccountingParams.FUND_SOURCE.getValue(), loanProductId, CashAccountsForLoan.FUND_SOURCE.getValue());" }, { "path": "org.apache.fineract.accounting.provisioning.domain", "mechanism": "JPA", "name": "ProvisioningEntry Entity", "description": "The class is a JPA entity that maps to the 'm_provisioning_history' table. It defines columns for journal entry status and audit dates, and manages relationships to other entities.", "databaseName": "m_provisioning_history", "tablesAccessed": [ "m_provisioning_history", "m_loanproduct_provisioning_entry", "m_appuser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_provisioning_history\")\npublic class ProvisioningEntry extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.accounting.provisioning.domain.LoanProductProvisioningEntry", "mechanism": "JPA", "name": "LoanProductProvisioningEntry", "description": "The class is a JPA Entity that maps directly to the 'm_loanproduct_provisioning_entry' database table. It defines Many-to-One relationships with other entities such as ProvisioningEntry, Office, LoanProduct, ProvisioningCategory, and GLAccount.", "databaseName": "unknown", "tablesAccessed": [ "m_loanproduct_provisioning_entry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loanproduct_provisioning_entry\")\npublic class LoanProductProvisioningEntry extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"history_id\", referencedColumnName = \"id\", nullable = false)\n private ProvisioningEntry entry;" }, { "path": "org.apache.fineract.accounting.rule.domain", "mechanism": "JPA", "name": "AccountingTagRule", "description": "The class is a JPA entity mapped to the 'acc_rule_tags' table using Jakarta Persistence annotations. It defines the schema structure including unique constraints and foreign key relationships.", "databaseName": "acc_rule_tags", "tablesAccessed": [ "acc_rule_tags" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping for CRUD operations.", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"acc_rule_tags\"...)\npublic class AccountingTagRule extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.accounting.rule.domain.AccountingRule", "mechanism": "JPA", "name": "AccountingRule", "description": "The class is a JPA Entity mapped to the 'acc_accounting_rule' table. It defines relationships with 'Office' (ManyToOne), 'GLAccount' (ManyToOne for debit/credit accounts), and 'AccountingTagRule' (OneToMany).", "databaseName": "acc_accounting_rule", "tablesAccessed": [ "acc_accounting_rule", "acc_accounting_tag_rule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with standard CRUD operations managed by the persistence context.", "transactionHandling": "JPA EntityTransaction (implicitly managed by container/framework)", "protocol": "JPA 3.0 / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"acc_accounting_rule\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"name\" }, name = \"accounting_rule_name_unique\") })\npublic class AccountingRule extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.adhocquery.domain.AdHoc", "mechanism": "JPA", "name": "AdHoc", "description": "The class is a JPA entity mapped to the 'm_adhoc' database table using Jakarta Persistence annotations.", "databaseName": "m_adhoc", "tablesAccessed": [ "m_adhoc" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_adhoc\")\npublic class AdHoc extends AbstractAuditableCustom {" }, { "path": "org.apache.fineract.batch.service.BatchApiServiceImpl", "mechanism": "JPA", "name": "BatchApiServiceImpl", "description": "The class directly manages database interactions through programmatic transaction control using Spring's 'PlatformTransactionManager' and 'TransactionTemplate'. It injects a 'jakarta.persistence.EntityManager' via '@PersistenceContext' to interact with the persistence layer. Transactions are not managed declaratively with '@Transactional' annotations, but are instead explicitly started and controlled within the 'callInTransaction' method. This allows for two distinct modes: one where the entire batch runs in a single transaction, and another where each root request gets a new transaction. Before executing a command, it explicitly calls 'entityManager.flush()' to synchronize the persistence context with the database within an active transaction.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The class itself does not contain specific queries. It orchestrates the execution of 'CommandStrategy' objects, which are responsible for performing the actual database operations. The interaction is at the ORM level through the JPA EntityManager, implying that the underlying queries are likely JPQL or generated by JPA provider.", "transactionHandling": "Programmatic transaction management using Spring's 'TransactionTemplate' and 'PlatformTransactionManager'. The 'callInTransaction' method creates a 'TransactionTemplate', which executes a block of code within a transaction, handling commit and rollback. One mode uses a single transaction for the whole batch, while the other uses 'PROPAGATION_REQUIRES_NEW' to create a new transaction for each root request.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return transactionTemplate.execute(status -> {\n BatchRequestContextHolder.setEnclosingTransaction(Optional.of(status));\n try {\n responseList.addAll(request.get());\n return responseList;\n } catch (BatchExecutionException ex) {\n status.setRollbackOnly();\n return List.of(buildErrorResponse(ex.getCause(), ex.getRequest()));\n } catch (RuntimeException ex) {\n status.setRollbackOnly();\n return buildErrorResponses(ex, responseList);\n }\n});" }, { "path": "org.apache.fineract.cob.domain", "mechanism": "JPA", "name": "LoanAccountLock", "description": "The class is a JPA Entity that maps directly to the 'm_loan_account_locks' table. It uses standard Jakarta Persistence annotations to define the schema mapping, including primary key, columns, and optimistic locking version.", "databaseName": "m_loan_account_locks", "tablesAccessed": [ "m_loan_account_locks" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_account_locks\")\npublic class LoanAccountLock {\n @Id\n @Column(name = \"loan_id\", nullable = false)\n private Long loanId;\n..." }, { "path": "org.apache.fineract.cob.domain", "mechanism": "JPA", "name": "BatchBusinessStep", "description": "The class is a JPA Entity mapped to the 'm_batch_business_steps' table. It uses annotations to define column mappings for job configuration data.", "databaseName": "m_batch_business_steps", "tablesAccessed": [ "m_batch_business_steps" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_batch_business_steps\")\npublic class BatchBusinessStep extends AbstractPersistableCustom {\n @Column(name = \"job_name\", nullable = false)\n private String jobName;\n}" }, { "path": "org.apache.fineract.cob.domain", "mechanism": "JPA", "name": "CustomLoanAccountLockRepositoryImpl", "description": "The class uses the JPA EntityManager to execute a native SQL UPDATE statement. It interacts directly with the 'm_loan' and 'm_loan_account_locks' tables to perform a bulk update based on complex criteria involving subqueries.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_account_locks" ], "operationType": [ "WRITE" ], "queryPatterns": "Native SQL UPDATE with subqueries and database-specific date functions", "transactionHandling": "Implicit (likely managed by Spring service layer calling this repository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "entityManager.createNativeQuery(sql).executeUpdate();" }, { "path": "org.apache.fineract.cob.service", "mechanism": "JPA", "name": "PersistenceContext", "description": "This interface is explicitly designed to manage the lifecycle of JPA entities (indicated by the extension of AbstractPersistableCustom). Implementations will interact with the database to refresh entity states.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Entity refresh/reload by ID", "transactionHandling": "Likely managed by Spring @Transactional in implementations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "S reload(S input);" }, { "path": "org.apache.fineract.commands.domain.CommandSource", "mechanism": "JPA", "name": "CommandSource Entity", "description": "The class is a JPA Entity annotated with @Entity and @Table(name = 'm_portfolio_command_source'). It maps Java fields to database columns using @Column, @ManyToOne, and @JoinColumn annotations. It relies on a JPA provider (like Hibernate) to handle persistence operations.", "databaseName": "unknown", "tablesAccessed": [ "m_portfolio_command_source" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA 3.0 / Hibernate", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_portfolio_command_source\")\npublic class CommandSource extends AbstractPersistableCustom {\n @Column(name = \"action_name\", nullable = true, length = 100)\n private String actionName;\n // ..." }, { "path": "org.apache.fineract.commands.service", "mechanism": "JPA", "name": "DummyCommandSource", "description": "The file defines a static inner class `DummyCommandSource` annotated as a JPA entity, likely used to simulate database persistence objects during the test execution without hitting a real database.", "databaseName": "unknown", "tablesAccessed": [ "m_portfolio_command_source" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "ORM mapping definition only", "transactionHandling": "Mocked via FineractRequestContextHolder", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n @Table(name = \"m_portfolio_command_source\")\n public static class DummyCommandSource extends CommandSource {" }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.domain", "mechanism": "JPA", "name": "AccountNumberFormat", "description": "The class is a JPA Entity mapped to a database table. It uses Jakarta Persistence annotations to define the table name, unique constraints, and column mappings for account type, prefix type, and prefix character.", "databaseName": "unknown", "tablesAccessed": [ "AccountNumberFormatConstants.ACCOUNT_NUMBER_FORMAT_TABLE_NAME" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = AccountNumberFormatConstants.ACCOUNT_NUMBER_FORMAT_TABLE_NAME...)\npublic class AccountNumberFormat extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.bulkimport.domain.ImportDocument", "mechanism": "JPA", "name": "ImportDocument", "description": "The class is a JPA Entity mapped to the 'm_import_document' table. It uses annotations to define column mappings, relationships (OneToOne, ManyToOne), and table configuration.", "databaseName": "m_import_document", "tablesAccessed": [ "m_import_document" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_import_document\")\npublic class ImportDocument extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"document_id\")\n private Document document;\n // ..." }, { "path": "org.apache.fineract.infrastructure.businessdate.domain.BusinessDate", "mechanism": "JPA", "name": "BusinessDate Entity", "description": "The class is a JPA entity mapped to the relational database table 'm_business_date'. It uses standard Jakarta Persistence annotations to define the mapping, including column definitions and unique constraints.", "databaseName": "m_business_date", "tablesAccessed": [ "m_business_date" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_business_date\", uniqueConstraints = { @UniqueConstraint(name = \"uq_business_date_type\", columnNames = { \"type\" }) })\npublic class BusinessDate extends AbstractAuditableWithUTCDateTimeCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.cache.domain.PlatformCache", "mechanism": "JPA", "name": "PlatformCache", "description": "The class is a JPA Entity that maps to the 'c_cache' database table. It uses standard Jakarta Persistence annotations to define the table name and column mappings for the cache configuration.", "databaseName": "unknown", "tablesAccessed": [ "c_cache" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"c_cache\")\npublic class PlatformCache extends AbstractPersistableCustom {\n @Column(name = \"cache_type_enum\")\n private Integer cacheType;" }, { "path": "org.apache.fineract.infrastructure.cache.service", "mechanism": "JPA", "name": "ConfigurationDomainService", "description": "The class participates in database transactions via the Spring `@Transactional` annotation. While it does not execute SQL directly, it delegates persistence operations to `ConfigurationDomainService`, which updates the cache configuration in the database.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to domain service for updates", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic Map switchToCache(final CacheType toCacheType) {\n // ...\n if (!changes.isEmpty()) {\n this.configurationDomainService.updateCache(toCacheType);\n }\n return changes;\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain", "mechanism": "JPA", "name": "EmailConfiguration", "description": "This class is a JPA Entity that maps directly to a relational database table named 'scheduled_email_configuration'. It defines the schema for storing email configuration settings, specifically a name and a value column.", "databaseName": "scheduled_email_configuration", "tablesAccessed": [ "scheduled_email_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for simple CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container or framework)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"scheduled_email_configuration\")\npublic class EmailConfiguration extends AbstractPersistableCustom {\n @Column(name = \"name\", nullable = false)\n private String name;\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain.EmailCampaign", "mechanism": "JPA", "name": "EmailCampaign Entity", "description": "The class is a JPA Entity mapped to the 'scheduled_email_campaign' table. It uses Jakarta Persistence annotations to define the table mapping, column definitions, and relationships (ManyToOne) with other entities like AppUser and Report.", "databaseName": "unknown", "tablesAccessed": [ "scheduled_email_campaign" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"scheduled_email_campaign\")\npublic class EmailCampaign extends AbstractPersistableCustom {\n @Column(name = \"campaign_name\", nullable = false)\n private String campaignName;\n ..." }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain.EmailMessage", "mechanism": "JPA", "name": "EmailMessage", "description": "The class is a JPA Entity mapped to the 'scheduled_email_messages_outbound' table. It uses standard Jakarta Persistence annotations to define the table mapping, columns, and relationships (ManyToOne) with other entities like Group, Client, and Staff.", "databaseName": "scheduled_email_messages_outbound", "tablesAccessed": [ "scheduled_email_messages_outbound" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"scheduled_email_messages_outbound\")\npublic class EmailMessage extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler", "mechanism": "JPA", "name": "EmailCampaignWritePlatformService", "description": "The class defines a transactional boundary using Spring's `@Transactional` annotation for a database write operation. While it does not execute SQL or JPA calls directly, it delegates to `EmailCampaignWritePlatformService` which performs the persistence logic (likely using JPA/Hibernate given the Fineract context).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for deletion", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.emailCampaignWritePlatformService.delete(command.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler", "mechanism": "JPA", "name": "EmailWritePlatformService", "description": "The class manages database transactions via the `@Transactional` annotation while delegating the actual data modification (deletion) to the `EmailWritePlatformService`. Although direct SQL or Repository calls are not present in this file, it orchestrates the transactional context for the database operation.", "databaseName": "unknown", "tablesAccessed": [ "EMAIL" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.delete(command.entityId());\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.domain.SmsCampaign", "mechanism": "JPA", "name": "SmsCampaign Entity", "description": "The class is a standard JPA Entity mapped to the 'sms_campaign' table. It uses Jakarta Persistence annotations to define the table structure, columns, and relationships (ManyToOne with Report and AppUser).", "databaseName": "unknown", "tablesAccessed": [ "sms_campaign" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"sms_campaign\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"campaign_name\" }, name = \"campaign_name_UNIQUE\") })\npublic class SmsCampaign extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.codes.domain.Code", "mechanism": "JPA", "name": "Code", "description": "The class is a JPA Entity mapped to the 'm_code' table. It defines columns for 'code_name' and 'is_system_defined'. It also manages a One-to-Many relationship with the 'CodeValue' entity.", "databaseName": "m_code", "tablesAccessed": [ "m_code" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_code\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"code_name\" }, name = \"code_name\") })\npublic class Code extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.codes.domain.CodeValue", "mechanism": "JPA", "name": "CodeValue", "description": "The class is a JPA Entity mapped to the 'm_code_value' table. It defines columns for code values, ordering, and relationships to the parent 'Code' entity.", "databaseName": "m_code_value", "tablesAccessed": [ "m_code_value" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_code_value\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"code_id\", \"code_value\" }, name = \"code_value_duplicate\") })\npublic class CodeValue extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.configuration.domain", "mechanism": "JPA", "name": "GlobalConfigurationProperty", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'c_configuration' table in the database. It uses standard Jakarta Persistence annotations to define column mappings.", "databaseName": "c_configuration", "tablesAccessed": [ "c_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"c_configuration\")\npublic class GlobalConfigurationProperty extends AbstractPersistableCustom {\n @Column(name = \"name\", nullable = false)\n private String name;\n}" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.ExternalService", "mechanism": "JPA", "name": "ExternalService", "description": "The class is a JPA entity mapped to the 'c_external_service' table. It defines a unique constraint on the 'name' column and inherits persistence capabilities from a base class.", "databaseName": "c_external_service", "tablesAccessed": [ "c_external_service" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA 3.0 / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"c_external_service\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"name_UNIQUE\") })\npublic class ExternalService extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.ExternalServicePropertiesPK", "mechanism": "JPA", "name": "ExternalServicePropertiesPK", "description": "This class is a JPA Embeddable type that maps a composite primary key to database columns. It defines the structure of the key used to access specific rows in the associated table.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Column(name = \"external_service_id\")\nprivate Long externalServiceId;" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.ExternalServicesProperties", "mechanism": "JPA", "name": "ExternalServicesProperties Entity", "description": "This class is a JPA Entity that maps directly to the 'c_external_service_properties' table. It uses an embedded composite ID for the primary key.", "databaseName": "unknown", "tablesAccessed": [ "c_external_service_properties" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"c_external_service_properties\")\npublic class ExternalServicesProperties {\n @EmbeddedId\n ExternalServicePropertiesPK externalServicePropertiesPK;\n @Column(name = \"value\", length = 250)\n private String value;" }, { "path": "org.apache.fineract.infrastructure.core.config.jpa", "mechanism": "JPA", "name": "JPA Configuration", "description": "This class configures the JPA layer using EclipseLink. It sets up the EntityManagerFactory, defines the persistence unit 'jpa-pu', and enables Spring Data JPA repositories. It uses a RoutingDataSource, implying support for dynamic or multi-tenant database connections.", "databaseName": "unknown", "tablesAccessed": [ "unknown (scans packages org.apache.fineract.**.domain)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM configuration for entity scanning and persistence unit management.", "transactionHandling": "Configures PlatformTransactionManager and provides a TransactionTemplate for programmatic transactions.", "protocol": "EclipseLink JPA", "connectionInfo": "DataSource provided by RoutingDataSource", "codeExample": "return factoryBuilder.dataSource(getDataSource()).properties(vendorProperties).persistenceUnit(\"jpa-pu\").packages(packagesToScan).jta(false).build();" }, { "path": "org.apache.fineract.infrastructure.core.config.jpa.EntityManagerFactoryCustomizer", "mechanism": "JPA", "name": "EntityManagerFactoryCustomizer", "description": "This interface is a configuration hook for the JPA layer. While it does not execute queries itself, it is integral to the setup of the database interaction layer by defining how the EntityManagerFactory is customized (e.g., scanning for entities, setting vendor properties).", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "JPA (EclipseLink)", "connectionInfo": "n/a", "codeExample": "default Map additionalVendorProperties() {\n return Collections.emptyMap();\n}" }, { "path": "org.apache.fineract.infrastructure.core.data.GenericEnumListConverter", "mechanism": "JPA", "name": "JPA AttributeConverter", "description": "This class implements the JPA `AttributeConverter` interface to handle the conversion of Java types to JDBC types automatically. It is used to map a `List` in a Java Entity to a single `VARCHAR` or `TEXT` column in the database containing comma-separated values.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping logic", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA 3.0+ (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "public abstract class GenericEnumListConverter> implements AttributeConverter, String> { ... return valueStream.map(Enum::name).collect(Collectors.joining(SPLIT_CHAR)); }" }, { "path": "org.apache.fineract.infrastructure.core.diagnostics.jpa", "mechanism": "JPA", "name": "EntityManager", "description": "The class interacts directly with the JPA EntityManager infrastructure to provide diagnostic information. It specifically relies on the EclipseLink implementation (EntityManagerImpl) to access internal details like the UnitOfWork and ChangeSets.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "n/a", "transactionHandling": "Relies on existing Spring managed transactions via EntityManagerFactoryUtils", "protocol": "EclipseLink JPA", "connectionInfo": "unknown", "codeExample": "EntityManagerFactory emf = applicationContext.getBean(EntityManagerFactory.class);\nreturn (EntityManagerImpl) EntityManagerFactoryUtils.getTransactionalEntityManager(emf);" }, { "path": "org.apache.fineract.infrastructure.core.diagnostics.jpa.StatementLoggingCustomizer", "mechanism": "JPA", "name": "EclipseLink Configuration", "description": "Configures the EclipseLink JPA provider to output SQL statements and parameters to the logs. It does not perform data access itself but modifies the behavior of the persistence unit to enable diagnostic logging.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "EclipseLink JPA", "connectionInfo": "n/a", "codeExample": "return Map.of(\"eclipselink.logging.level.sql\", SessionLog.FINE_LABEL, PersistenceUnitProperties.LOGGING_PARAMETERS, Boolean.TRUE.toString());" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JPA", "name": "AbstractAuditableCustom", "description": "The class uses Jakarta Persistence (JPA) annotations to define a mapped superclass. It maps Java fields to specific database columns (e.g., 'createdby_id', 'created_date') to store audit information. Subclasses of this class will include these columns in their respective database tables.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Column(name = \"createdby_id\")\nprivate Long createdBy;" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JPA", "name": "ExternalIdConverter", "description": "This class is a JPA AttributeConverter that automatically maps the 'ExternalId' Java type to a database column (likely VARCHAR) and vice versa.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM type conversion", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA 3.0", "connectionInfo": "n/a", "codeExample": "@Override\npublic String convertToDatabaseColumn(ExternalId externalId) {\n return externalId != null ? externalId.getValue() : null;\n}" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JPA", "name": "AbstractPersistableCustom", "description": "The class acts as a JPA MappedSuperclass, defining the common database identity column and persistence lifecycle behavior for inheriting entities.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping definition", "transactionHandling": "JPA lifecycle callbacks", "protocol": "JPA 3.0+ (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Id\n@GeneratedValue(strategy = GenerationType.IDENTITY)\nprivate Long id;" }, { "path": "org.apache.fineract.infrastructure.core.domain", "mechanism": "JPA", "name": "AbstractAuditableWithUTCDateTimeCustom", "description": "The class uses Jakarta Persistence API (JPA) annotations to define a mapped superclass. It maps Java fields to specific database columns for auditing purposes (created/modified by/date). It does not access the database directly but defines the schema for subclasses.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Column(name = CREATED_BY_DB_FIELD, nullable = false)\n@Setter(onMethod = @__(@Override))\nprivate Long createdBy;" }, { "path": "org.apache.fineract.infrastructure.core.jpa", "mechanism": "JPA", "name": "EntityManager", "description": "The class interacts directly with the Jakarta Persistence API (JPA) EntityManager to construct and execute dynamic queries. It uses the Criteria API to build queries programmatically based on Spring Data Specifications and Pageable objects.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic criteria queries constructed at runtime based on Specifications and Pageable inputs. Includes count queries for pagination.", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "CriteriaBuilder builder = entityManager.getCriteriaBuilder();\nCriteriaQuery query = builder.createQuery(Long.class);\nRoot root = query.from(domainClass);" }, { "path": "org.apache.fineract.infrastructure.core.persistence", "mechanism": "JPA", "name": "ExtendedJpaTransactionManager", "description": "This class acts as the Transaction Manager for JPA operations. It interacts directly with the Jakarta Persistence `EntityManager` to manage transaction states, specifically optimizing read-only operations by manipulating flush modes and clearing the persistence context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "EntityManager entityManager = getCurrentEntityManager();\nif (entityManager != null) {\n entityManager.setFlushMode(FlushModeType.COMMIT);\n}" }, { "path": "org.apache.fineract.infrastructure.core.persistence", "mechanism": "JPA", "name": "DatabaseSelectingPersistenceUnitPostProcessor", "description": "This class configures the JPA provider (EclipseLink) to use the correct SQL dialect for the connected database (MySQL or PostgreSQL). It does not execute queries itself but ensures the ORM layer is correctly configured to do so.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "n/a", "protocol": "MySQL or PostgreSQL", "connectionInfo": "n/a", "codeExample": "pui.addProperty(PersistenceUnitProperties.TARGET_DATABASE, targetDatabase);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "JPA", "name": "CreditBureauToken", "description": "The class is a JPA Entity that maps to the 'm_creditbureau_token' table. It uses standard Jakarta Persistence annotations to define the table name and column mappings for token properties.", "databaseName": "unknown", "tablesAccessed": [ "m_creditbureau_token" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC/JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_creditbureau_token\")\npublic class CreditBureauToken extends AbstractPersistableCustom {\n @Column(name = \"token\")\n private String accessToken;\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "JPA", "name": "CreditBureauConfiguration", "description": "The class is a JPA Entity mapped to a relational database table. It defines columns for configuration keys, values, and descriptions, and establishes a Many-to-One relationship with the OrganisationCreditBureau entity.", "databaseName": "m_creditbureau_configuration", "tablesAccessed": [ "m_creditbureau_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_creditbureau_configuration\")\npublic class CreditBureauConfiguration extends AbstractPersistableCustom {\n @Column(name = \"configkey\")\n private String configurationKey;\n // ...\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.CreditBureau", "mechanism": "JPA", "name": "CreditBureau", "description": "This class is a JPA Entity that maps directly to a database table using Jakarta Persistence annotations.", "databaseName": "m_creditbureau", "tablesAccessed": [ "m_creditbureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Managed by the JPA provider and Spring context (likely @Transactional in service layer).", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_creditbureau\")\npublic class CreditBureau extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.CreditBureauLoanProductMapping", "mechanism": "JPA", "name": "CreditBureauLoanProductMapping", "description": "The class is a JPA Entity mapped to the 'm_creditbureau_loanproduct_mapping' table. It defines columns for configuration settings and relationships to other entities.", "databaseName": "unknown", "tablesAccessed": [ "m_creditbureau_loanproduct_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with relationships (ManyToOne, OneToOne).", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_creditbureau_loanproduct_mapping\")\npublic class CreditBureauLoanProductMapping extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.CreditReport", "mechanism": "JPA", "name": "CreditReport", "description": "The class is a JPA Entity mapped to the relational database. It defines the schema for storing credit reports, including a lazy-loaded BLOB column for the report data.", "databaseName": "m_creditreport", "tablesAccessed": [ "m_creditreport" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping with lazy loading for binary data", "transactionHandling": "Managed by the JPA Persistence Context", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_creditreport\")\npublic class CreditReport extends AbstractPersistableCustom {\n @Column(name = \"credit_bureau_id\")\n private Long creditBureauId;\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.OrganisationCreditBureau", "mechanism": "JPA", "name": "OrganisationCreditBureau", "description": "The class is a JPA entity mapped to the 'm_organisation_creditbureau' table. It manages persistence for organisation-specific credit bureau configurations.", "databaseName": "m_organisation_creditbureau", "tablesAccessed": [ "m_organisation_creditbureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_organisation_creditbureau\")\npublic class OrganisationCreditBureau extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.creditbureau.handler", "mechanism": "JPA", "name": "CreditBureauConfigurationWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation. While it does not execute SQL directly, it orchestrates a write operation via the injected service, ensuring that the underlying database updates performed by the service are committed or rolled back atomically.", "databaseName": "unknown", "tablesAccessed": [ "CREDITBUREAU_CONFIGURATION" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateCreditBureauConfiguration(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.EntityDatatableChecks", "mechanism": "JPA", "name": "EntityDatatableChecks", "description": "The class is a JPA Entity mapped to a relational database table using Jakarta Persistence annotations.", "databaseName": "m_entity_datatable_check", "tablesAccessed": [ "m_entity_datatable_check" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_entity_datatable_check\")\npublic class EntityDatatableChecks extends AbstractPersistableCustom {\n @Column(name = \"application_table_name\", nullable = false)\n private String entity;" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.RegisteredDatatable", "mechanism": "JPA", "name": "RegisteredDatatable", "description": "The class is a JPA Entity mapped to the 'x_registered_table' database table. It defines the schema for storing metadata about registered extension tables using Jakarta Persistence annotations.", "databaseName": "unknown", "tablesAccessed": [ "x_registered_table" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping for CRUD operations.", "transactionHandling": "Transactions are managed by the container or service layer interacting with this entity (likely Spring @Transactional).", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"x_registered_table\")\npublic class RegisteredDatatable extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.Report", "mechanism": "JPA", "name": "Report", "description": "The class is a JPA Entity mapped to the 'stretchy_report' table. It uses standard Jakarta Persistence annotations to define the schema mapping, including columns, unique constraints, and relationships.", "databaseName": "stretchy_report", "tablesAccessed": [ "stretchy_report" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"stretchy_report\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"report_name\" }, name = \"unq_report_name\") })\npublic final class Report extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportParameter", "mechanism": "JPA", "name": "ReportParameter", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the mapping strategy.", "databaseName": "unknown", "tablesAccessed": [ "stretchy_parameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping for CRUD operations", "transactionHandling": "Relies on the container or service layer transaction management (JPA)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"stretchy_parameter\")\npublic class ReportParameter extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportParameterUsage", "mechanism": "JPA", "name": "ReportParameterUsage", "description": "The class is a JPA Entity that maps to the 'stretchy_report_parameter' table. It manages the many-to-many relationship (with extra attributes) between Reports and ReportParameters.", "databaseName": "unknown", "tablesAccessed": [ "stretchy_report_parameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"stretchy_report_parameter\")\npublic final class ReportParameterUsage extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"report_id\", nullable = false)\n private Report report;" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.domain", "mechanism": "JPA", "name": "Image", "description": "The class is a JPA Entity that maps directly to the 'm_image' database table using Jakarta Persistence annotations.", "databaseName": "m_image", "tablesAccessed": [ "m_image" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_image\")\npublic final class Image extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.domain.Document", "mechanism": "JPA", "name": "Document", "description": "The class is a JPA entity mapped to the 'm_document' table using standard Jakarta Persistence annotations. It defines columns for document attributes and manages persistence through the JPA provider.", "databaseName": "m_document", "tablesAccessed": [ "m_document" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_document\")\npublic class Document extends AbstractPersistableCustom {\n @Column(name = \"name\", length = 250)\n private String name;\n}" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityAccess", "mechanism": "JPA", "name": "FineractEntityAccess", "description": "The class is a JPA Entity mapped to a relational database table. It uses annotations to define the table name and column mappings, including a Many-to-One relationship.", "databaseName": "m_entity_to_entity_access", "tablesAccessed": [ "m_entity_to_entity_access" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_entity_to_entity_access\")\npublic class FineractEntityAccess extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityRelation", "mechanism": "JPA", "name": "FineractEntityRelation", "description": "The class is a JPA entity that maps directly to the 'm_entity_relation' table in the database. It defines the schema for storing entity relationship definitions, including columns for 'from_entity_type', 'to_entity_type', and 'code_name'. It also manages a one-to-many relationship with the 'FineractEntityToEntityMapping' entity, configured with CascadeType.ALL and orphan removal.", "databaseName": "m_entity_relation", "tablesAccessed": [ "m_entity_relation", "m_entity_to_entity_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_entity_relation\")\npublic class FineractEntityRelation extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityToEntityMapping", "mechanism": "JPA", "name": "FineractEntityToEntityMapping", "description": "The class is a JPA entity mapped to the 'm_entity_to_entity_mapping' table. It uses Jakarta Persistence annotations to define the table structure, columns, and relationships (Many-to-One with FineractEntityRelation).", "databaseName": "m_entity_to_entity_mapping", "tablesAccessed": [ "m_entity_to_entity_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_entity_to_entity_mapping\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"rel_id\", \"from_id\", \"to_id\" }) })\npublic class FineractEntityToEntityMapping extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.event.external.repository", "mechanism": "JPA", "name": "CustomExternalEventConfigurationRepositoryImpl", "description": "The class uses the Jakarta Persistence API (JPA) EntityManager to perform direct entity lookups against the database.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEventConfiguration" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookup by primary key", "transactionHandling": "Implicitly managed by the container or Spring context (no explicit annotations on this class)", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "Managed by Spring/Container DataSource", "codeExample": "final ExternalEventConfiguration configuration = entityManager.find(ExternalEventConfiguration.class, externalEventType);" }, { "path": "org.apache.fineract.infrastructure.event.external.repository.domain.ExternalEvent", "mechanism": "JPA", "name": "ExternalEvent", "description": "The class is a JPA Entity that maps directly to the 'm_external_event' database table. It uses Jakarta Persistence annotations to define the schema mapping, including column names, nullability, and fetch types (e.g., Lazy fetching for the binary data blob).", "databaseName": "m_external_event", "tablesAccessed": [ "m_external_event" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_external_event\")\npublic class ExternalEvent extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.event.external.repository.domain.ExternalEventConfiguration", "mechanism": "JPA", "name": "ExternalEventConfiguration", "description": "The class is a JPA Entity that maps directly to a relational database table using Jakarta Persistence annotations.", "databaseName": "m_external_event_configuration", "tablesAccessed": [ "m_external_event_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_external_event_configuration\")\npublic class ExternalEventConfiguration {\n @Id\n @Column(name = \"type\", nullable = false)\n private String type;\n}" }, { "path": "org.apache.fineract.infrastructure.event.external.service.ExternalEventService", "mechanism": "JPA", "name": "ExternalEventRepository", "description": "The service interacts with the database primarily through the ExternalEventRepository (likely a Spring Data JPA repository) to save event entities. It also directly uses the JPA EntityManager to flush the persistence context to ensure data consistency before event serialization.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEvent" ], "operationType": [ "WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "repository.save(externalEvent);" }, { "path": "org.apache.fineract.infrastructure.gcm.domain.DeviceRegistration", "mechanism": "JPA", "name": "DeviceRegistration", "description": "This class is a JPA Entity that maps directly to the 'client_device_registration' database table. It defines the schema structure including a foreign key to the client table and a unique constraint on the registration ID.", "databaseName": "unknown", "tablesAccessed": [ "client_device_registration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping for CRUD operations.", "transactionHandling": "Managed by the JPA persistence context (likely Spring @Transactional in service layer).", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"client_device_registration\")\npublic class DeviceRegistration extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"client_id\", nullable = false, unique = true)\n private Client client;\n}" }, { "path": "org.apache.fineract.infrastructure.hooks.domain.Hook", "mechanism": "JPA", "name": "Hook", "description": "The class is a JPA Entity mapped to the 'm_hook' table. It defines columns for properties and manages relationships with other entities.", "databaseName": "m_hook", "tablesAccessed": [ "m_hook" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with OneToMany relationships.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_hook\")\npublic final class Hook extends AbstractAuditableCustom {\n @Column(name = \"name\", nullable = false, length = 100)\n private String name;\n}" }, { "path": "org.apache.fineract.infrastructure.hooks.domain.HookConfiguration", "mechanism": "JPA", "name": "HookConfiguration", "description": "The class is a JPA Entity mapped to the 'm_hook_configuration' table. It defines columns for configuration details and a foreign key relationship to the 'm_hook' table.", "databaseName": "m_hook_configuration", "tablesAccessed": [ "m_hook_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_hook_configuration\")\npublic class HookConfiguration extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.hooks.domain.HookResource", "mechanism": "JPA", "name": "HookResource", "description": "The class is a JPA entity that maps to the relational database table 'm_hook_registered_events'. It defines the schema for storing webhook event triggers, including a foreign key relationship to the main hook table.", "databaseName": "unknown", "tablesAccessed": [ "m_hook_registered_events" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_hook_registered_events\")\npublic class HookResource extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"hook_id\", referencedColumnName = \"id\", nullable = false)\n private Hook hook;\n}" }, { "path": "org.apache.fineract.infrastructure.hooks.domain.HookTemplate", "mechanism": "JPA", "name": "HookTemplate", "description": "The class is a JPA Entity mapped to the 'm_hook_templates' table using Jakarta Persistence annotations. It defines a one-to-many relationship with the 'Schema' entity.", "databaseName": "m_hook_templates", "tablesAccessed": [ "m_hook_templates" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_hook_templates\")\npublic final class HookTemplate extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.hooks.domain.Schema", "mechanism": "JPA", "name": "Schema", "description": "The class is a Java Persistence API (JPA) entity that maps directly to the relational database table 'm_hook_schema'. It defines the schema for storing hook configuration field definitions, including relationships to the hook template and column definitions for field metadata.", "databaseName": "m_hook_schema", "tablesAccessed": [ "m_hook_schema" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_hook_schema\")\npublic class Schema extends AbstractPersistableCustom {\n @Column(name = \"field_name\", nullable = false, length = 100)\n private String fieldName;\n}" }, { "path": "org.apache.fineract.infrastructure.jobs.domain", "mechanism": "JPA", "name": "CustomJobParameter", "description": "This class is a JPA Entity that maps to a relational database table using Jakarta Persistence annotations.", "databaseName": "batch_custom_job_parameters", "tablesAccessed": [ "batch_custom_job_parameters" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA Entity mapping for CRUD operations.", "transactionHandling": "Managed by JPA Context/Container", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"batch_custom_job_parameters\")\npublic class CustomJobParameter extends AbstractPersistableCustom {\n @Column(name = \"parameter_json\", nullable = false, columnDefinition = \"json\")\n private String parameterJson;\n}" }, { "path": "org.apache.fineract.infrastructure.jobs.domain", "mechanism": "JPA", "name": "SchedulerDetail", "description": "The class is a JPA Entity that maps the 'SchedulerDetail' object to the 'scheduler_detail' table in the database using Jakarta Persistence annotations.", "databaseName": "scheduler_detail", "tablesAccessed": [ "scheduler_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "Managed via JPA context/Spring Data (implicit in entity definition).", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"scheduler_detail\")\npublic class SchedulerDetail extends AbstractPersistableCustom {\n @Column(name = \"execute_misfired_jobs\")\n private boolean executeInstructionForMisfiredJobs;" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.JobParameter", "mechanism": "JPA", "name": "JobParameter", "description": "The class is a JPA Entity that maps directly to a relational database table to persist job parameter data.", "databaseName": "job_parameters", "tablesAccessed": [ "job_parameters" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Transactions are managed by the persistence context, typically via Spring's @Transactional in the service layer.", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"job_parameters\")\npublic class JobParameter extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.ScheduledJobDetail", "mechanism": "JPA", "name": "ScheduledJobDetail", "description": "The class is a JPA entity mapped to the 'job' database table using Jakarta Persistence annotations. It defines the schema mapping for job scheduling details, including columns for job name, cron expression, and execution timestamps.", "databaseName": "job", "tablesAccessed": [ "job" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"job\")\npublic class ScheduledJobDetail extends AbstractPersistableCustom {\n @Column(name = \"cron_expression\")\n private String cronExpression;\n}" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.ScheduledJobRunHistory", "mechanism": "JPA", "name": "ScheduledJobRunHistory", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships.", "databaseName": "job_run_history", "tablesAccessed": [ "job_run_history", "scheduled_job_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"job_run_history\")\npublic class ScheduledJobRunHistory extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain.ReportMailingJob", "mechanism": "JPA", "name": "ReportMailingJob", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'm_report_mailing_job' table. It uses Jakarta Persistence annotations to define column mappings, unique constraints, and relationships (ManyToOne) with other entities like 'Report' and 'AppUser'.", "databaseName": "m_report_mailing_job", "tablesAccessed": [ "m_report_mailing_job" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_report_mailing_job\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"unique_name\") })\npublic class ReportMailingJob extends AbstractAuditableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain.ReportMailingJobConfiguration", "mechanism": "JPA", "name": "ReportMailingJobConfiguration", "description": "The class is a JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the schema mapping, including table name, column definitions, and unique constraints.", "databaseName": "m_report_mailing_job_configuration", "tablesAccessed": [ "m_report_mailing_job_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_report_mailing_job_configuration\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"name\" }, name = \"unique_name\") })\npublic class ReportMailingJobConfiguration extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain.ReportMailingJobRunHistory", "mechanism": "JPA", "name": "ReportMailingJobRunHistory", "description": "The class is a JPA Entity that maps to a relational database table to store job execution history records.", "databaseName": "m_report_mailing_job_run_history", "tablesAccessed": [ "m_report_mailing_job_run_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Managed by the JPA provider and Spring transaction management context.", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_report_mailing_job_run_history\")\npublic class ReportMailingJobRunHistory extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.security.api", "mechanism": "JPA", "name": "AppUser Entity / ClientReadPlatformService", "description": "The code interacts with the database primarily through the `AppUser` JPA entity (retrieved via the Authentication principal) and the `ClientReadPlatformService`. It traverses entity relationships (Roles, Office) which may trigger lazy loading from the database.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser", "m_role", "m_office", "m_client" ], "operationType": [ "READ" ], "queryPatterns": "Entity traversal and service-based read operations", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final AppUser principal = (AppUser) authenticationCheck.getPrincipal();\nfinal Set userRoles = principal.getRoles();\nfor (final Role role : userRoles) {\n roles.add(role.toData());\n}" }, { "path": "org.apache.fineract.infrastructure.security.domain", "mechanism": "JPA", "name": "TFAccessToken", "description": "The class is a JPA Entity mapped to the 'twofactor_access_token' table. It defines columns for the token string, validity timestamps, enabled status, and a foreign key relationship to the AppUser entity.", "databaseName": "unknown", "tablesAccessed": [ "twofactor_access_token" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"twofactor_access_token\"...)\npublic class TFAccessToken extends AbstractPersistableCustom {\n @Column(name = \"token\", nullable = false, length = 32)\n private String token;\n ..." }, { "path": "org.apache.fineract.infrastructure.security.domain.TwoFactorConfiguration", "mechanism": "JPA", "name": "TwoFactorConfiguration", "description": "The class is a JPA Entity mapped to the 'twofactor_configuration' table. It defines columns for 'name' and 'value' and enforces a unique constraint on the 'name' column.", "databaseName": "twofactor_configuration", "tablesAccessed": [ "twofactor_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping for CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"twofactor_configuration\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"name_UNIQUE\") })\npublic class TwoFactorConfiguration extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.infrastructure.sms.domain.SmsMessage", "mechanism": "JPA", "name": "SmsMessage", "description": "The class is a JPA Entity mapped to the 'sms_messages_outbound' table. It defines columns for message details, status, and timestamps, and Many-to-One relationships with Group, Client, Staff, and SmsCampaign entities.", "databaseName": "sms_messages_outbound", "tablesAccessed": [ "sms_messages_outbound" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"sms_messages_outbound\")\npublic class SmsMessage extends AbstractPersistableCustom {\n @Column(name = \"mobile_no\", length = 50)\n private String mobileNo;\n}" }, { "path": "org.apache.fineract.infrastructure.survey.domain.Likelihood", "mechanism": "JPA", "name": "Likelihood", "description": "The class is a JPA entity mapped to a relational database table. It uses standard Jakarta Persistence annotations to define the table mapping and column constraints.", "databaseName": "unknown", "tablesAccessed": [ "ppi_likelihoods_ppi" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"ppi_likelihoods_ppi\")\npublic final class Likelihood extends AbstractPersistableCustom {\n @Column(name = \"ppi_name\", nullable = false)\n private String ppiName;\n ..." }, { "path": "org.apache.fineract.interoperation.domain.InteropIdentifier", "mechanism": "JPA", "name": "InteropIdentifier", "description": "The class is a JPA Entity mapped to the 'interop_identifier' table. It defines columns for account association, identifier type, value, and audit logs. It enforces unique constraints on (account_id, type) and (type, a_value, sub_value_or_type).", "databaseName": "interop_identifier", "tablesAccessed": [ "interop_identifier" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"interop_identifier\", uniqueConstraints = {\n @UniqueConstraint(name = \"uk_hathor_identifier_account\", columnNames = { \"account_id\", \"type\" }),...})\npublic class InteropIdentifier extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.investor.domain", "mechanism": "JPA", "name": "ExternalAssetOwnerTransferDetails", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships.", "databaseName": "m_external_asset_owner_transfer_details", "tablesAccessed": [ "m_external_asset_owner_transfer_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner_transfer_details\")\npublic class ExternalAssetOwnerTransferDetails extends AbstractAuditableWithUTCDateTimeCustom {\n @Column(name = \"total_outstanding_derived\", scale = 6, precision = 19, nullable = false)\n private BigDecimal totalOutstanding;\n}" }, { "path": "org.apache.fineract.investor.domain", "mechanism": "JPA", "name": "ExternalAssetOwnerJournalEntryMapping", "description": "The class is a JPA entity that maps directly to the 'm_external_asset_owner_journal_entry_mapping' table. It defines foreign key relationships to the 'journal_entry_id' and 'owner_id' columns.", "databaseName": "m_external_asset_owner_journal_entry_mapping", "tablesAccessed": [ "m_external_asset_owner_journal_entry_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping used for CRUD operations via a JPA repository.", "transactionHandling": "Transactions are managed by the container or Spring context wrapping the JPA operations.", "protocol": "JPA 3.0+ (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner_journal_entry_mapping\")\npublic class ExternalAssetOwnerJournalEntryMapping extends AbstractAuditableWithUTCDateTimeCustom {\n @OneToOne\n @JoinColumn(name = \"journal_entry_id\", nullable = false)\n private JournalEntry journalEntry;\n}" }, { "path": "org.apache.fineract.investor.domain.ExternalAssetOwner", "mechanism": "JPA", "name": "ExternalAssetOwner", "description": "The class is a JPA Entity that maps directly to a database table using Jakarta Persistence annotations. It defines column mappings and constraints (unique, nullable) for the external ID.", "databaseName": "m_external_asset_owner", "tablesAccessed": [ "m_external_asset_owner" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner\")\npublic class ExternalAssetOwner extends AbstractAuditableWithUTCDateTimeCustom {\n @Column(name = \"external_id\", nullable = false, length = 100, unique = true)\n private ExternalId externalId;\n}" }, { "path": "org.apache.fineract.investor.domain.ExternalAssetOwnerTransfer", "mechanism": "JPA", "name": "ExternalAssetOwnerTransfer", "description": "The class is a JPA Entity mapped to the `m_external_asset_owner_transfer` table. It defines the schema for storing asset owner transfer records, including foreign keys to the owner table and mapping of enum values to database columns.", "databaseName": "m_external_asset_owner_transfer", "tablesAccessed": [ "m_external_asset_owner_transfer" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping for CRUD operations.", "transactionHandling": "Transactions are typically managed by the container or Spring service layer interacting with this entity.", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner_transfer\")\npublic class ExternalAssetOwnerTransfer extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.investor.domain.ExternalAssetOwnerTransferJournalEntryMapping", "mechanism": "JPA", "name": "ExternalAssetOwnerTransferJournalEntryMapping", "description": "The class uses Jakarta Persistence (JPA) annotations to map the object directly to a relational database table. It defines foreign key relationships to the JournalEntry and ExternalAssetOwnerTransfer entities.", "databaseName": "unknown", "tablesAccessed": [ "m_external_asset_owner_transfer_journal_entry_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Implicitly handled by the JPA provider/container context.", "protocol": "JDBC/JPA", "connectionInfo": "configured in application properties", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner_transfer_journal_entry_mapping\")\npublic class ExternalAssetOwnerTransferJournalEntryMapping extends AbstractAuditableWithUTCDateTimeCustom {\n @OneToOne\n @JoinColumn(name = \"journal_entry_id\", nullable = false)\n private JournalEntry journalEntry;\n}" }, { "path": "org.apache.fineract.investor.domain.ExternalAssetOwnerTransferLoanMapping", "mechanism": "JPA", "name": "ExternalAssetOwnerTransferLoanMapping", "description": "The class is a JPA Entity mapped to the 'm_external_asset_owner_transfer_loan_mapping' table. It manages the persistence of loan transfer mappings using Jakarta Persistence annotations.", "databaseName": "m_external_asset_owner_transfer_loan_mapping", "tablesAccessed": [ "m_external_asset_owner_transfer_loan_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_external_asset_owner_transfer_loan_mapping\")\npublic class ExternalAssetOwnerTransferLoanMapping extends AbstractAuditableWithUTCDateTimeCustom {\n @Column(name = \"loan_id\", nullable = false)\n private Long loanId;\n}" }, { "path": "org.apache.fineract.investor.domain.ExternalIdConverter", "mechanism": "JPA", "name": "ExternalIdConverter", "description": "This class is a JPA AttributeConverter that handles the serialization and deserialization of the ExternalId custom type to a database column (String). It is marked with @Converter(autoApply = true), meaning it automatically intercepts database reads and writes for fields of type ExternalId across the persistence context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Converter(autoApply = true)\npublic class ExternalIdConverter implements AttributeConverter {\n @Override\n public String convertToDatabaseColumn(ExternalId externalId) {\n return externalId != null ? externalId.getValue() : null;\n }\n}" }, { "path": "org.apache.fineract.investor.domain.search", "mechanism": "JPA", "name": "SearchingExternalAssetOwnerRepositoryImpl", "description": "The class uses the JPA Criteria API via an injected EntityManager to perform dynamic, type-safe database queries. It constructs complex joins and predicates programmatically based on user input.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwnerTransferDetails", "ExternalAssetOwner" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic JPA Criteria queries with joins and filtering predicates.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "CriteriaBuilder cb = entityManager.getCriteriaBuilder();\nCriteriaQuery query = cb.createQuery(SearchedExternalAssetOwner.class);\nRoot root = query.from(ExternalAssetOwnerTransfer.class);" }, { "path": "org.apache.fineract.mix.domain.MixTaxonomyMapping", "mechanism": "JPA", "name": "MixTaxonomyMapping", "description": "The class is a JPA Entity mapped to a relational database table using Jakarta Persistence annotations. It defines columns for identifier, config, and currency.", "databaseName": "unknown", "tablesAccessed": [ "mix_taxonomy_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations managed via JPA/Hibernate.", "transactionHandling": "JPA EntityTransaction (implied by context)", "protocol": "JDBC/JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"mix_taxonomy_mapping\")\npublic final class MixTaxonomyMapping extends AbstractPersistableCustom {\n @Column(name = \"identifier\")\n private String identifier;" }, { "path": "org.apache.fineract.notification.domain.Notification", "mechanism": "JPA", "name": "Notification", "description": "The class is a JPA Entity that maps the Notification object to the relational database table 'notification_generator'. It uses Jakarta Persistence annotations to define the table mapping and column definitions for storing notification details.", "databaseName": "notification_generator", "tablesAccessed": [ "notification_generator" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"notification_generator\")\npublic class Notification extends AbstractPersistableCustom {\n @Column(name = \"object_type\")\n private String objectType;\n}" }, { "path": "org.apache.fineract.notification.domain.NotificationMapper", "mechanism": "JPA", "name": "NotificationMapper", "description": "The class is a JPA Entity that maps directly to a relational database table named 'notification_mapper'. It uses Jakarta Persistence annotations to define the table mapping, column definitions, and foreign key relationships to other entities.", "databaseName": "unknown", "tablesAccessed": [ "notification_mapper" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"notification_mapper\")\npublic class NotificationMapper extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"notification_id\")\n private Notification notification;\n}" }, { "path": "org.apache.fineract.organisation.holiday.domain.Holiday", "mechanism": "JPA", "name": "Holiday", "description": "The class is a JPA Entity mapped to the 'm_holiday' table. It uses standard Jakarta Persistence annotations to define the schema, including unique constraints and column definitions. It also manages a Many-to-Many relationship with the 'Office' entity via the 'm_holiday_office' join table.", "databaseName": "m_holiday", "tablesAccessed": [ "m_holiday", "m_holiday_office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_holiday\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"holiday_name\") })\npublic class Holiday extends AbstractPersistableCustom {\n @Column(name = \"name\", unique = true, nullable = false, length = 100)\n private String name;\n // ...\n @ManyToMany(fetch = FetchType.EAGER)\n @JoinTable(name = \"m_holiday_office\", joinColumns = @JoinColumn(name = \"holiday_id\"), inverseJoinColumns = @JoinColumn(name = \"office_id\"))\n private Set offices;\n}" }, { "path": "org.apache.fineract.organisation.holiday.handler", "mechanism": "JPA", "name": "HolidayWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation while delegating the actual data modification to the `HolidayWritePlatformService`. It ensures the delete operation is atomic.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.holidayWritePlatformService.deleteHoliday(command.entityId());\n}" }, { "path": "org.apache.fineract.organisation.monetary.domain.ApplicationCurrency", "mechanism": "JPA", "name": "ApplicationCurrency", "description": "The class is a JPA entity mapped to the 'm_currency' database table. It uses Jakarta Persistence annotations to define the table name and column mappings for currency attributes.", "databaseName": "m_currency", "tablesAccessed": [ "m_currency" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_currency\")\npublic class ApplicationCurrency extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.organisation.monetary.domain.MonetaryCurrency", "mechanism": "JPA", "name": "MonetaryCurrency Embeddable", "description": "The class is a JPA `@Embeddable` component. It does not have its own table but defines columns that are added to the tables of entities that embed it. It maps the currency code, decimal digits, and multiples-of values to specific database columns.", "databaseName": "unknown", "tablesAccessed": [ "unknown (dependent on embedding entity)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a (Embeddable definition only)", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Embeddable\npublic class MonetaryCurrency {\n @Column(name = \"currency_code\", length = 3, nullable = false)\n private String code;\n @Column(name = \"currency_digits\", nullable = false)\n private int digitsAfterDecimal;\n // ...\n}" }, { "path": "org.apache.fineract.organisation.monetary.domain.Money", "mechanism": "JPA", "name": "Money Embeddable", "description": "The Money class is annotated with @Embeddable, indicating that its instances are stored as an intrinsic part of an owning entity and share the same database table. It maps its fields (currencyCode, currencyDigitsAfterDecimal, inMultiplesOf, amount) to specific columns in the database.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Embeddable\npublic class Money implements Comparable {\n @Column(name = \"currency_code\", length = 3)\n private String currencyCode;\n @Column(name = \"amount\", scale = 6, precision = 19)\n private BigDecimal amount;\n}" }, { "path": "org.apache.fineract.organisation.office.domain.Office", "mechanism": "JPA", "name": "Office", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping to the 'm_office' table. It defines relationships using @ManyToOne and @OneToMany for the parent-child office structure.", "databaseName": "m_office", "tablesAccessed": [ "m_office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_office\"...)\npublic class Office extends AbstractPersistableCustom..." }, { "path": "org.apache.fineract.organisation.office.domain.OfficeTransaction", "mechanism": "JPA", "name": "OfficeTransaction", "description": "The class is a JPA entity that maps directly to a relational database table. It uses annotations to define the table name, column mappings, and relationships (Many-to-One) with other entities.", "databaseName": "m_office_transaction", "tablesAccessed": [ "m_office_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_office_transaction\")\npublic class OfficeTransaction extends AbstractPersistableCustom {\n @Column(name = \"transaction_amount\", scale = 6, precision = 19, nullable = false)\n private BigDecimal transactionAmount;" }, { "path": "org.apache.fineract.organisation.office.domain.OrganisationCurrency", "mechanism": "JPA", "name": "OrganisationCurrency", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to a relational database table. It uses @Column annotations to define column mappings for currency properties.", "databaseName": "m_organisation_currency", "tablesAccessed": [ "m_organisation_currency" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_organisation_currency\")\npublic class OrganisationCurrency extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.organisation.provisioning.domain.LoanProductProvisionCriteria", "mechanism": "JPA", "name": "LoanProductProvisionCriteria", "description": "The class is a JPA Entity that maps directly to a relational database table using Jakarta Persistence annotations. It defines foreign key relationships to other entities.", "databaseName": "m_loanproduct_provisioning_mapping", "tablesAccessed": [ "m_loanproduct_provisioning_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with ManyToOne relationships", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loanproduct_provisioning_mapping\"...)\npublic class LoanProductProvisionCriteria extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCategory", "mechanism": "JPA", "name": "ProvisioningCategory", "description": "The class is a JPA Entity mapped to the 'm_provision_category' database table. It uses Jakarta Persistence annotations to define the table name, unique constraints, and column mappings.", "databaseName": "m_provision_category", "tablesAccessed": [ "m_provision_category" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_provision_category\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"category_name\" }, name = \"category_name\") })\npublic class ProvisioningCategory extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCriteria", "mechanism": "JPA", "name": "ProvisioningCriteria", "description": "The class is a JPA Entity mapped to the 'm_provisioning_criteria' table. It manages relationships with other entities ('ProvisioningCriteriaDefinition' and 'LoanProductProvisionCriteria') using standard JPA annotations.", "databaseName": "m_provisioning_criteria", "tablesAccessed": [ "m_provisioning_criteria", "m_provisioning_criteria_definition", "m_loan_product_provisioning_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with OneToMany relationships and CascadeType.ALL", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_provisioning_criteria\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"criteria_name\" }, name = \"criteria_name\") })\npublic class ProvisioningCriteria extends AbstractAuditableCustom { ... }" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCriteriaDefinition", "mechanism": "JPA", "name": "ProvisioningCriteriaDefinition", "description": "The class is a JPA Entity mapped to a relational database table. It uses annotations to define the table name, column mappings, and foreign key relationships to other entities.", "databaseName": "m_provisioning_criteria_definition", "tablesAccessed": [ "m_provisioning_criteria_definition" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_provisioning_criteria_definition\")\npublic class ProvisioningCriteriaDefinition extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.organisation.staff.domain.Staff", "mechanism": "JPA", "name": "Staff", "description": "The class is a JPA Entity mapped to the 'm_staff' table. It uses standard Jakarta Persistence annotations to define the table structure, unique constraints, and relationships (Many-to-One with Office, One-to-One with Image).", "databaseName": "m_staff", "tablesAccessed": [ "m_staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_staff\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"display_name\" }, name = \"display_name\") })\npublic class Staff extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.organisation.teller.domain.Cashier", "mechanism": "JPA", "name": "Cashier Entity", "description": "The class is a standard JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, unique constraints, and relationships to other entities (Staff, Teller).", "databaseName": "unknown", "tablesAccessed": [ "m_cashiers" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with lazy loading for relationships.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_cashiers\", uniqueConstraints = {\n @UniqueConstraint(name = \"ux_cashiers_staff_teller\", columnNames = { \"staff_id\", \"teller_id\" }) })\npublic class Cashier extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.organisation.teller.domain.CashierTransaction", "mechanism": "JPA", "name": "CashierTransaction", "description": "The class is a JPA entity mapped to the 'm_cashier_transactions' table using Jakarta Persistence annotations. It defines columns for transaction details and a Many-to-One relationship with the Cashier entity.", "databaseName": "m_cashier_transactions", "tablesAccessed": [ "m_cashier_transactions" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_cashier_transactions\")\npublic class CashierTransaction extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.organisation.teller.domain.Teller", "mechanism": "JPA", "name": "Teller", "description": "The class is a JPA Entity mapped to the 'm_tellers' table. It uses standard Jakarta Persistence annotations to define the table structure, constraints, and relationships.", "databaseName": "m_tellers", "tablesAccessed": [ "m_tellers" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping with lazy loading for relationships.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA 3.0+ (Jakarta)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_tellers\", uniqueConstraints = { @UniqueConstraint(name = \"ux_tellers_name\", columnNames = { \"name\" }) })\npublic class Teller extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.organisation.teller.domain.TellerTransaction", "mechanism": "JPA", "name": "TellerTransaction", "description": "This class is a JPA Entity mapped to the 'm_teller_transactions' table. It uses Jakarta Persistence annotations to define the table mapping, column constraints, and foreign key relationships to other entities like Office, Teller, and Client.", "databaseName": "m_teller_transactions", "tablesAccessed": [ "m_teller_transactions" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping for CRUD operations.", "transactionHandling": "Managed by the JPA provider and persistence context.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_teller_transactions\")\npublic class TellerTransaction extends AbstractPersistableCustom {\n @Column(name = \"amount\", nullable = false)\n private Double amount;\n}" }, { "path": "org.apache.fineract.organisation.workingdays.domain", "mechanism": "JPA", "name": "m_working_days", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'm_working_days' database table. It inherits ID management from AbstractPersistableCustom.", "databaseName": "unknown", "tablesAccessed": [ "m_working_days" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_working_days\")\npublic class WorkingDays extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.account.domain", "mechanism": "JPA", "name": "AccountTransferDetails", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping Java objects to the 'm_account_transfer_details' database table. It defines relationships using @ManyToOne, @OneToMany, and @OneToOne annotations to link with other domain entities like Office, Client, Loan, and SavingsAccount.", "databaseName": "m_account_transfer_details", "tablesAccessed": [ "m_account_transfer_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_account_transfer_details\")\npublic class AccountTransferDetails extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.account.domain.AccountAssociations", "mechanism": "JPA", "name": "AccountAssociations Entity", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses annotations to define the table name, column mappings, and foreign key relationships to other entities (Loan and SavingsAccount).", "databaseName": "m_portfolio_account_associations", "tablesAccessed": [ "m_portfolio_account_associations" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_portfolio_account_associations\")\npublic class AccountAssociations extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.account.domain.AccountTransferStandingInstruction", "mechanism": "JPA", "name": "AccountTransferStandingInstruction", "description": "The class is a JPA entity mapped to the 'm_account_transfer_standing_instructions' table. It uses Jakarta Persistence annotations to define the table structure, unique constraints, and column mappings. It maintains a Many-to-One relationship with the 'AccountTransferDetails' entity.", "databaseName": "m_account_transfer_standing_instructions", "tablesAccessed": [ "m_account_transfer_standing_instructions", "m_account_transfer_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "Not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_account_transfer_standing_instructions\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"name\" }, name = \"name\") })\npublic class AccountTransferStandingInstruction extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.account.domain.AccountTransferTransaction", "mechanism": "JPA", "name": "AccountTransferTransaction", "description": "The class is a JPA Entity mapped to the 'm_account_transfer_transaction' table. It uses Jakarta Persistence annotations to define the table mapping, column definitions, and relationships with other entities.", "databaseName": "m_account_transfer_transaction", "tablesAccessed": [ "m_account_transfer_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_account_transfer_transaction\")\n@Getter\npublic class AccountTransferTransaction extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.account.handler", "mechanism": "JPA", "name": "AccountTransfersWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions for the refund operation. While the direct database access code is not in this file, it orchestrates a write operation via the injected `AccountTransfersWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.refundByTransfer(command);\n}" }, { "path": "org.apache.fineract.portfolio.address.domain", "mechanism": "JPA", "name": "FieldConfiguration", "description": "The class is a JPA Entity mapped to a relational database table using Jakarta Persistence annotations.", "databaseName": "unknown", "tablesAccessed": [ "m_field_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Managed by the JPA provider (likely via Spring @Transactional in the service layer).", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_field_configuration\")\npublic class FieldConfiguration extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.address.domain.Address", "mechanism": "JPA", "name": "Address Entity", "description": "The class is a JPA Entity mapped to the 'm_address' table. It uses Jakarta Persistence annotations to define the schema mapping, including columns, relationships (ManyToOne, OneToMany), and cascading rules.", "databaseName": "m_address", "tablesAccessed": [ "m_address" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_address\")\npublic class Address extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.calendar.domain.Calendar", "mechanism": "JPA", "name": "Calendar Entity", "description": "The class is a JPA Entity annotated with @Entity and @Table(name = 'm_calendar'). It maps class fields to database columns using @Column and manages a one-to-many relationship with CalendarHistory.", "databaseName": "m_calendar", "tablesAccessed": [ "m_calendar", "m_calendar_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with relationship management.", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_calendar\")\npublic class Calendar extends AbstractAuditableWithUTCDateTimeCustom {\n @Column(name = \"title\", length = 50, nullable = false)\n private String title;" }, { "path": "org.apache.fineract.portfolio.calendar.domain.CalendarHistory", "mechanism": "JPA", "name": "CalendarHistory", "description": "The class is a JPA Entity mapped to the 'm_calendar_history' table. It uses standard Jakarta Persistence annotations to define the schema mapping, relationships (ManyToOne with Calendar), and column definitions.", "databaseName": "m_calendar_history", "tablesAccessed": [ "m_calendar_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_calendar_history\")\npublic class CalendarHistory extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"calendar_id\", referencedColumnName = \"id\", nullable = false)\n private Calendar calendar;" }, { "path": "org.apache.fineract.portfolio.calendar.domain.CalendarInstance", "mechanism": "JPA", "name": "CalendarInstance", "description": "The class is a JPA Entity mapped to the 'm_calendar_instance' table. It manages persistence for calendar associations using Jakarta Persistence annotations.", "databaseName": "m_calendar_instance", "tablesAccessed": [ "m_calendar_instance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_calendar_instance\")\npublic class CalendarInstance extends AbstractPersistableCustom {\n @ManyToOne(cascade = CascadeType.PERSIST)\n @JoinColumn(name = \"calendar_id\", nullable = false)\n private Calendar calendar;" }, { "path": "org.apache.fineract.portfolio.calendar.handler", "mechanism": "JPA", "name": "CalendarWritePlatformService", "description": "The class manages a database transaction via the `@Transactional` annotation and delegates the actual persistence operation (deletion) to the `CalendarWritePlatformService`. While the SQL/ORM code isn't inline, this class defines the transaction boundary for the database write operation.", "databaseName": "unknown", "tablesAccessed": [ "CALENDAR" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for deletion logic", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteCalendar(command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.charge.domain.Charge", "mechanism": "JPA", "name": "Charge", "description": "The class is a JPA entity mapped to the 'm_charge' table. It uses standard Jakarta Persistence annotations to define the table mapping, columns, and relationships (ManyToOne) with other entities like PaymentType, GLAccount, and TaxGroup.", "databaseName": "m_charge", "tablesAccessed": [ "m_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_charge\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"name\") })\npublic class Charge extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.charge.handler", "mechanism": "JPA", "name": "ChargeWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions for the delete operation. While it does not execute SQL directly, it orchestrates the transaction for the underlying service layer which interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.clientWritePlatformService.deleteCharge(command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.charge.handler", "mechanism": "JPA", "name": "ChargeWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, implying that the underlying service method `updateCharge` performs database write operations, likely via JPA or a similar ORM used in the application.", "databaseName": "unknown", "tablesAccessed": [ "CHARGE" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.clientWritePlatformService.updateCharge(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "JPA", "name": "ClientIdentifier", "description": "The class is a JPA Entity mapped to the 'm_client_identifier' table. It defines relationships to other entities (Client, CodeValue) and specifies unique constraints on the database schema.", "databaseName": "m_client_identifier", "tablesAccessed": [ "m_client_identifier" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_identifier\", uniqueConstraints = { ... })\npublic class ClientIdentifier extends AbstractAuditableWithUTCDateTimeCustom { ... }" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "JPA", "name": "ClientAddress", "description": "The class is a JPA Entity that maps to the 'm_client_address' table in the database. It uses Jakarta Persistence annotations to define the table name, columns, and relationships (Many-to-One) with other entities.", "databaseName": "m_client_address", "tablesAccessed": [ "m_client_address" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for a join table with additional attributes.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_address\")\npublic class ClientAddress extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "JPA", "name": "ClientChargePaidBy", "description": "The class is a JPA Entity mapped to the 'm_client_charge_paid_by' table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships. It specifically maps foreign keys to 'm_client_transaction' and 'm_client_charge' tables via @ManyToOne and @JoinColumn annotations.", "databaseName": "m_client_charge_paid_by", "tablesAccessed": [ "m_client_charge_paid_by" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_client_charge_paid_by\")\npublic class ClientChargePaidBy extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"client_transaction_id\", nullable = false)\n private ClientTransaction clientTransaction;\n //..." }, { "path": "org.apache.fineract.portfolio.client.domain.Client", "mechanism": "JPA", "name": "Client Entity", "description": "The class is a JPA Entity mapped to the 'm_client' table. It uses standard Jakarta Persistence annotations to define columns, relationships, and constraints.", "databaseName": "m_client", "tablesAccessed": [ "m_client", "m_group_client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with lazy loading for relationships.", "transactionHandling": "JPA EntityTransaction (managed by container/service layer)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"account_no\" }, name = \"account_no_UNIQUE\") })\npublic class Client extends AbstractAuditableWithUTCDateTimeCustom { ... }" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientCharge", "mechanism": "JPA", "name": "ClientCharge Entity", "description": "The class is a standard JPA Entity annotated with @Entity and @Table. It maps to the 'm_client_charge' table and uses @ManyToOne relationships for linking to Client and Charge entities.", "databaseName": "m_client_charge", "tablesAccessed": [ "m_client_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA ORM mapping with derived fields and relationships.", "transactionHandling": "Implicitly handled by the persistence context/service layer (not visible in entity code).", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_charge\")\npublic class ClientCharge extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"client_id\", referencedColumnName = \"id\", nullable = false)\n private Client client;\n // ..." }, { "path": "org.apache.fineract.portfolio.client.domain.ClientFamilyMembers", "mechanism": "JPA", "name": "ClientFamilyMembers", "description": "The class is a JPA entity mapped to the 'm_family_members' table. It uses Jakarta Persistence annotations to define the table mapping, column definitions, and relationships with other entities like 'Client' and 'CodeValue'.", "databaseName": "m_family_members", "tablesAccessed": [ "m_family_members" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_family_members\")\npublic class ClientFamilyMembers extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"client_id\")\n private Client client;\n // ..." }, { "path": "org.apache.fineract.portfolio.client.domain.ClientNonPerson", "mechanism": "JPA", "name": "ClientNonPerson", "description": "The class is a JPA entity mapped to the 'm_client_non_person' table. It uses standard Jakarta Persistence annotations to define the table mapping, column constraints, and relationships (OneToOne with Client, ManyToOne with CodeValue).", "databaseName": "m_client_non_person", "tablesAccessed": [ "m_client_non_person" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_non_person\")\npublic class ClientNonPerson extends AbstractPersistableCustom {\n @OneToOne(optional = false)\n @JoinColumn(name = \"client_id\", referencedColumnName = \"id\", nullable = false, unique = true)\n private Client client;\n ..." }, { "path": "org.apache.fineract.portfolio.client.domain.ClientTransaction", "mechanism": "JPA", "name": "ClientTransaction", "description": "The class is a JPA Entity mapped to the 'm_client_transaction' table. It uses Jakarta Persistence annotations to define the schema mapping, including column definitions, unique constraints, and relationships with other entities (Client, Office, PaymentDetail).", "databaseName": "m_client_transaction", "tablesAccessed": [ "m_client_transaction", "m_client", "m_office", "m_payment_detail", "m_client_charge_paid_by" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with standard relationships (ManyToOne, OneToMany).", "transactionHandling": "JPA EntityTransaction (implicit in usage context)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_transaction\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"external_id\" }, name = \"external_id\") })\npublic class ClientTransaction extends AbstractAuditableWithUTCDateTimeCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"client_id\", nullable = false)\n private Client client;" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientTransferDetails", "mechanism": "JPA", "name": "ClientTransferDetails", "description": "The class is a JPA Entity mapped to the relational database table 'm_client_transfer_details'. It defines the schema mapping for client transfer records using annotations.", "databaseName": "m_client_transfer_details", "tablesAccessed": [ "m_client_transfer_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_client_transfer_details\")\npublic class ClientTransferDetails extends AbstractPersistableCustom {\n @Column(name = \"client_id\", length = 20, unique = true, nullable = false)\n private Long clientId;" }, { "path": "org.apache.fineract.portfolio.client.domain.search", "mechanism": "JPA", "name": "SearchingClientRepositoryImpl", "description": "The class interacts with the database using the Jakarta Persistence API (JPA) Criteria API via an injected EntityManager. It dynamically constructs SQL queries to retrieve client data based on search criteria.", "databaseName": "unknown", "tablesAccessed": [ "Client", "Office" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic criteria query with joins, filtering (LIKE, OR, AND), and DTO projection", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "CriteriaBuilder cb = entityManager.getCriteriaBuilder();\nCriteriaQuery query = cb.createQuery(SearchedClient.class);\nRoot root = query.from(Client.class);\n// ... predicates ...\nTypedQuery queryToExecute = entityManager.createQuery(query);" }, { "path": "org.apache.fineract.portfolio.client.handler.UndoClientTransactionCommandHandler", "mechanism": "JPA", "name": "ClientTransactionWritePlatformService", "description": "The class uses Spring's @Transactional annotation to manage database transactions. While it does not execute SQL or JPQL directly, it defines the transaction boundary for the 'undo' operation delegated to the service layer.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.undo(command.getClientId(), command.entityId());\n }" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "JPA", "name": "ClientTransactionReadPlatformService", "description": "The interface uses Spring's @Transactional annotation, indicating that its implementations interact with a database within a transaction context. While the implementation details (JDBC vs JPA) are not visible in the interface, the return of a domain entity (ClientTransaction) in one method and the transactional nature implies database interaction.", "databaseName": "unknown", "tablesAccessed": [ "ClientTransaction" ], "operationType": [ "READ" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional(readOnly = true)\nPage retrieveAllTransactions(Long clientId, SearchParameters parameters);" }, { "path": "org.apache.fineract.portfolio.client.service.ClientWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "ClientRepositoryWrapper", "description": "The class uses Spring Data JPA repositories wrapped in service wrappers (e.g., ClientRepositoryWrapper, ClientNonPersonRepositoryWrapper) to perform CRUD operations. It uses standard JPA entity management including saveAndFlush, delete, and findOne.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_client_non_person", "m_note", "m_group", "m_staff", "m_office", "m_savings_account", "m_loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, delete, findById) with some custom finders in the wrappers.", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.clientRepository.saveAndFlush(newClient);" }, { "path": "org.apache.fineract.portfolio.collateral.domain.LoanCollateral", "mechanism": "JPA", "name": "LoanCollateral", "description": "The class is a JPA Entity mapped to the 'm_loan_collateral' database table. It uses annotations to define column mappings, relationships (ManyToOne with Loan and CodeValue), and constraints.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_collateral" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_collateral\")\npublic class LoanCollateral extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;\n ..." }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain", "mechanism": "JPA", "name": "CollateralManagementDomain", "description": "The class is a standard JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships.", "databaseName": "m_collateral_management", "tablesAccessed": [ "m_collateral_management" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_collateral_management\")\npublic class CollateralManagementDomain extends AbstractPersistableCustom {\n @Column(name = \"base_price\", nullable = false, scale = 5, precision = 20)\n private BigDecimal basePrice;\n}" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain.ClientCollateralManagement", "mechanism": "JPA", "name": "ClientCollateralManagement", "description": "The class is a JPA entity mapped to the 'm_client_collateral_management' table. It uses standard Jakarta Persistence annotations to define the table mapping, column constraints, and relationships with other entities (Client, CollateralManagementDomain, LoanCollateralManagement).", "databaseName": "m_client_collateral_management", "tablesAccessed": [ "m_client_collateral_management" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM entity mapping with relationships", "transactionHandling": "JPA EntityTransaction (implicit via container)", "protocol": "JPA 3.0 / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_client_collateral_management\")\npublic class ClientCollateralManagement extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.handler", "mechanism": "JPA", "name": "CollateralManagementWritePlatformService", "description": "The class defines a transaction boundary using the @Transactional annotation, implying interaction with a transactional resource (likely a database) via the delegated service.", "databaseName": "unknown", "tablesAccessed": [ "COLLATERAL_PRODUCT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Jakarta @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand jsonCommand) {\n return this.collateralManagementWritePlatformService.createCollateral(jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.handler", "mechanism": "JPA", "name": "CollateralManagementWritePlatformService", "description": "The class defines transaction boundaries using the @Transactional annotation, ensuring that the database operations performed by the invoked service are atomic. While it does not execute SQL directly, it orchestrates the transaction for the persistence layer.", "databaseName": "unknown", "tablesAccessed": [ "COLLATERAL_PRODUCT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Jakarta @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.collateralManagementWritePlatformService.updateCollateral(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.handler", "mechanism": "JPA", "name": "CollateralManagementWritePlatformService", "description": "The class manages database transactions using the @Transactional annotation while delegating the actual persistence operations to the CollateralManagementWritePlatformService. It ensures that the delete operation performed by the service is committed or rolled back atomically.", "databaseName": "unknown", "tablesAccessed": [ "COLLATERAL_PRODUCT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for deletion logic", "transactionHandling": "Jakarta @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.collateralManagementWritePlatformService.deleteCollateral(command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.handler", "mechanism": "JPA", "name": "ClientCollateralManagementWritePlatformService", "description": "The class defines a transaction boundary using the `@Transactional` annotation, ensuring that the underlying service operation to add a collateral product is executed within a database transaction.", "databaseName": "unknown", "tablesAccessed": [ "CLIENT_COLLATERAL_PRODUCT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Jakarta @Transactional annotation managed by Spring", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand jsonCommand) {\n return this.clientCollateralManagementWritePlatformService.addClientCollateralProduct(jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.handler", "mechanism": "JPA", "name": "ClientCollateralManagementWritePlatformService", "description": "The class defines a transactional boundary using the @Transactional annotation, implying interaction with a database via the injected service. While the SQL or ORM logic is not present in this file, this handler manages the transaction lifecycle for the database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Jakarta @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand jsonCommand) {" }, { "path": "org.apache.fineract.portfolio.collectionsheet.service.CollectionSheetWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "CollectionSheetWritePlatformService", "description": "This class functions as a service layer implementation (suffixed JpaRepositoryImpl) that orchestrates database writes. While it does not contain direct EntityManager calls or SQL queries itself, it delegates to other services (LoanWritePlatformService, PaymentDetailWritePlatformService, etc.) that persist entities (PaymentDetail, SavingsAccountTransaction, Loan) using JPA/Spring Data.", "databaseName": "unknown", "tablesAccessed": [ "PaymentDetail", "SavingsAccountTransaction", "Loan", "Meeting" ], "operationType": [ "WRITE" ], "queryPatterns": "Orchestration of multiple entity updates (Loans, Savings, Payments) within a single logical transaction.", "transactionHandling": "Likely handled by Spring @Transactional at the interface level or within the delegated services (not explicitly visible in this file but implied by the 'Service' stereotype and 'JpaRepositoryImpl' naming convention).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService.createAndPersistPaymentDetail(command, changes);" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket", "mechanism": "JPA", "name": "DelinquencyBucket Entity", "description": "This class is a JPA Entity that maps directly to the relational database table 'm_delinquency_bucket'. It defines column mappings, unique constraints, and relationships to other entities.", "databaseName": "m_delinquency_bucket", "tablesAccessed": [ "m_delinquency_bucket", "m_delinquency_bucket_mappings", "DelinquencyRange" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_delinquency_bucket\", uniqueConstraints = {\n @UniqueConstraint(name = \"uq_delinquency_bucket_name\", columnNames = { \"name\" }) })\npublic class DelinquencyBucket extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketMappings", "mechanism": "JPA", "name": "DelinquencyBucketMappings", "description": "This class is a JPA Entity that maps to the relational database table 'm_delinquency_bucket_mappings'. It handles the persistence of the relationship between delinquency buckets and ranges.", "databaseName": "unknown", "tablesAccessed": [ "m_delinquency_bucket_mappings" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_delinquency_bucket_mappings\"...)\npublic class DelinquencyBucketMappings extends AbstractAuditableWithUTCDateTimeCustom { ... }" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange", "mechanism": "JPA", "name": "DelinquencyRange", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses standard Jakarta Persistence annotations to define the table name, column mappings, and constraints.", "databaseName": "m_delinquency_range", "tablesAccessed": [ "m_delinquency_range" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA 3.0+", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_delinquency_range\", uniqueConstraints = {\n @UniqueConstraint(name = \"uq_delinquency_range_classification\", columnNames = { \"classification\" }) })\npublic class DelinquencyRange extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistory", "mechanism": "JPA", "name": "LoanDelinquencyTagHistory", "description": "The class is a JPA Entity mapped to the 'm_loan_delinquency_tag_history' table. It uses Jakarta Persistence annotations to define the schema mapping and relationships.", "databaseName": "m_loan_delinquency_tag_history", "tablesAccessed": [ "m_loan_delinquency_tag_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_delinquency_tag_history\")\npublic class LoanDelinquencyTagHistory extends AbstractAuditableWithUTCDateTimeCustom {\n @ManyToOne\n @JoinColumn(name = \"delinquency_range_id\", nullable = false)\n private DelinquencyRange delinquencyRange;\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.handler", "mechanism": "JPA", "name": "DelinquencyWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates the transaction for the `DelinquencyWritePlatformService` which performs the actual database writes.", "databaseName": "unknown", "tablesAccessed": [ "DELINQUENCY_RANGE" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createDelinquencyRange(command);\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.handler", "mechanism": "JPA", "name": "DelinquencyWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions. While it does not execute SQL directly, it delegates to `DelinquencyWritePlatformService`, which performs the data persistence operations related to loan delinquency.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for updates", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.applyDelinquencyTagToLoan(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.service.LoanDelinquencyDomainServiceImpl", "mechanism": "JPA", "name": "LoanDelinquencyDomainService", "description": "The class uses Spring's @Transactional annotation to manage database transactions. While it does not contain direct SQL or Repository calls, it operates on JPA Entities (Loan, LoanRepaymentScheduleInstallment, LoanTransaction). Accessing collections on these entities (e.g., loan.getRepaymentScheduleInstallments()) triggers lazy loading of related database records within the transaction scope.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanRepaymentScheduleInstallment", "LoanTransaction" ], "operationType": [ "READ" ], "queryPatterns": "Traverses entity graph relationships (One-to-Many) which likely triggers Hibernate lazy-loading SQL selects.", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional(readOnly = true)\npublic CollectionData getOverdueCollectionData(final Loan loan) {\n // ...\n // Accessing lazy-loaded collection triggers DB read\n for (LoanRepaymentScheduleInstallment installment : loan.getRepaymentScheduleInstallments()) {\n // ...\n }\n}" }, { "path": "org.apache.fineract.portfolio.floatingrates.domain.FloatingRate", "mechanism": "JPA", "name": "FloatingRate", "description": "The class is a JPA Entity mapped to the 'm_floating_rates' table. It uses standard Jakarta Persistence annotations for ORM mapping.", "databaseName": "m_floating_rates", "tablesAccessed": [ "m_floating_rates" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with OneToMany relationship.", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_floating_rates\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"unq_name\") })\npublic class FloatingRate extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.floatingrates.domain.FloatingRatePeriod", "mechanism": "JPA", "name": "FloatingRatePeriod", "description": "The class is a JPA Entity mapped to the 'm_floating_rates_periods' table. It uses standard Jakarta Persistence annotations to define the table mapping, column constraints (precision, scale, nullability), and relationships (ManyToOne to FloatingRate).", "databaseName": "m_floating_rates_periods", "tablesAccessed": [ "m_floating_rates_periods" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_floating_rates_periods\")\npublic class FloatingRatePeriod extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.fund.domain.Fund", "mechanism": "JPA", "name": "Fund", "description": "The class is a JPA Entity mapped to the 'm_fund' table using Jakarta Persistence annotations. It defines columns and unique constraints for data persistence.", "databaseName": "m_fund", "tablesAccessed": [ "m_fund" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mapping for CRUD operations.", "transactionHandling": "Relies on the container or service layer to manage transactions via the EntityManager.", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_fund\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"fund_name_org\") })\npublic class Fund extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.group.domain.Group", "mechanism": "JPA", "name": "Group Entity", "description": "The class is a JPA entity mapped to the 'm_group' table. It uses standard Jakarta Persistence annotations to define columns, relationships (OneToMany, ManyToOne, ManyToMany), and join tables.", "databaseName": "m_group", "tablesAccessed": [ "m_group", "m_group_client", "m_staff_assignment_history", "m_group_roles" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM entity mapping with lazy and eager fetching strategies.", "transactionHandling": "JPA EntityTransaction (implicit via container or service layer)", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_group\")\npublic final class Group extends AbstractPersistableCustom {\n @Column(name = \"external_id\", length = 100, unique = true)\n private String externalId;\n @ManyToMany\n @JoinTable(name = \"m_group_client\", joinColumns = @JoinColumn(name = \"group_id\"), inverseJoinColumns = @JoinColumn(name = \"client_id\"))\n private Set clientMembers = new HashSet<>();\n}" }, { "path": "org.apache.fineract.portfolio.group.domain.GroupLevel", "mechanism": "JPA", "name": "GroupLevel", "description": "The class is a JPA Entity mapped to the 'm_group_level' table. It uses standard Jakarta Persistence annotations to define the table name and column mappings.", "databaseName": "m_group_level", "tablesAccessed": [ "m_group_level" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_group_level\")\npublic class GroupLevel extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.group.domain.GroupRole", "mechanism": "JPA", "name": "GroupRole", "description": "The class is a JPA Entity mapped to the 'm_group_roles' table. It uses annotations to define the table name and relationships (ManyToOne) with other entities (Group, Client, CodeValue).", "databaseName": "m_group_roles", "tablesAccessed": [ "m_group_roles" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_group_roles\")\npublic class GroupRole extends AbstractPersistableCustom {\n @ManyToOne(fetch = FetchType.LAZY)\n @JoinColumn(name = \"group_id\")\n private Group group;" }, { "path": "org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory", "mechanism": "JPA", "name": "StaffAssignmentHistory", "description": "The class is a JPA Entity that maps directly to the 'm_staff_assignment_history' table. It uses standard Jakarta Persistence annotations to define the table mapping, column definitions, and relationships (ManyToOne) with other entities.", "databaseName": "m_staff_assignment_history", "tablesAccessed": [ "m_staff_assignment_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_staff_assignment_history\")\npublic class StaffAssignmentHistory extends AbstractAuditableCustom {\n @ManyToOne\n @JoinColumn(name = \"centre_id\", nullable = true)\n private Group center;" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "JPA", "name": "GroupingTypesWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it manages the transaction for the underlying service (`GroupingTypesWritePlatformService`) which performs the actual database persistence (likely via JPA/Hibernate).", "databaseName": "unknown", "tablesAccessed": [ "m_group" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.groupWritePlatformService.updateCenter(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.group.handler.UnassignRoleCommandHandler", "mechanism": "JPA", "name": "GroupRolesWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it orchestrates a write operation (delete) delegated to the `GroupRolesWritePlatformService`, which interacts with the persistence layer (likely JPA/Hibernate repositories).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for deletion", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.groupRolesWritePlatformService.deleteRole(command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain", "mechanism": "JPA", "name": "InterestRateChartFields", "description": "The class is a JPA Embeddable component. It defines the schema for columns that will be embedded in the table of the parent entity using @Column annotations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings via annotations", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class InterestRateChartFields {\n @Column(name = \"name\", length = 100, unique = false, nullable = false)\n private String name;\n // ..." }, { "path": "org.apache.fineract.portfolio.interestratechart.domain", "mechanism": "JPA", "name": "InterestRateChartSlabFields", "description": "This class is an Embeddable JPA component. It does not correspond to a standalone table but defines a set of columns that are embedded into the table of the parent entity (likely InterestRateChartSlab). It uses standard Jakarta Persistence annotations to define column properties such as name, precision, scale, and nullability.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Embeddable\npublic class InterestRateChartSlabFields {\n @Column(name = \"description\", nullable = true)\n private String description;\n\n @Column(name = \"annual_interest_rate\", scale = 6, precision = 19, nullable = false)\n private BigDecimal annualInterestRate;\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestIncentives", "mechanism": "JPA", "name": "InterestIncentives", "description": "The class is a JPA entity mapped to the 'm_interest_incentives' table. It uses annotations to define the table mapping, relationships (ManyToOne), and embedded fields.", "databaseName": "unknown", "tablesAccessed": [ "m_interest_incentives" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_interest_incentives\")\npublic class InterestIncentives extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"interest_rate_slab_id\", nullable = false)\n private InterestRateChartSlab interestRateChartSlab;\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestIncentivesFields", "mechanism": "JPA", "name": "InterestIncentivesFields", "description": "The class is an `@Embeddable` component used to map a set of related fields to database columns within a parent entity. It defines column mappings for incentive details.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class InterestIncentivesFields {\n @Column(name = \"entiry_type\", nullable = false)\n private Integer entityType;\n @Column(name = \"attribute_name\", nullable = false)\n private Integer attributeName;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestRateChart", "mechanism": "JPA", "name": "InterestRateChart Entity", "description": "The class is a standard JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the mapping, including embedded fields and one-to-many relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_interest_rate_chart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with One-To-Many relationship fetching", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC/JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_interest_rate_chart\")\npublic class InterestRateChart extends AbstractPersistableCustom {\n @Embedded\n private InterestRateChartFields chartFields;\n @OneToMany(mappedBy = \"interestRateChart\", cascade = CascadeType.ALL...)\n private Set chartSlabs..." }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartSlab", "mechanism": "JPA", "name": "InterestRateChartSlab Entity", "description": "The class is a JPA entity mapped to the 'm_interest_rate_slab' table. It uses standard Jakarta Persistence annotations to define the table mapping, embedded fields, and relationships with other entities.", "databaseName": "m_interest_rate_slab", "tablesAccessed": [ "m_interest_rate_slab" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with One-to-Many and Many-to-One relationships.", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_interest_rate_slab\")\npublic class InterestRateChartSlab extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanOfficerAssignmentHistory", "description": "The class is a JPA Entity mapped to the 'm_loan_officer_assignment_history' table. It uses standard Jakarta Persistence annotations to define the table mapping and relationships (ManyToOne) with Loan and Staff entities.", "databaseName": "m_loan_officer_assignment_history", "tablesAccessed": [ "m_loan_officer_assignment_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_officer_assignment_history\")\npublic class LoanOfficerAssignmentHistory extends AbstractAuditableCustom {\n @ManyToOne\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanRescheduleRequestToTermVariationMapping", "description": "The class is a JPA entity that maps directly to a database table used for linking two other entities. It defines foreign key relationships via annotations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_reschedule_request_term_variations_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for a join table.", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_reschedule_request_term_variations_mapping\")\npublic class LoanRescheduleRequestToTermVariationMapping..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanPaymentAllocationRule", "description": "The class is a JPA entity mapped to the 'm_loan_payment_allocation_rule' table. It defines a unique constraint on the combination of 'loan_id' and 'transaction_type'. It uses a custom converter (AllocationTypeListConverter) to handle the persistence of the 'allocationTypes' list and standard enumerations for transaction and rule types.", "databaseName": "m_loan_payment_allocation_rule", "tablesAccessed": [ "m_loan_payment_allocation_rule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_payment_allocation_rule\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"loan_id\", \"transaction_type\" }, name = \"uq_m_loan_payment_allocation_rule\") })\npublic class LoanPaymentAllocationRule extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "Loan Persistence", "description": "The interface defines methods that explicitly handle the persistence of Loan and LoanTransaction entities. Methods like 'saveAndFlushLoanWithDataIntegrityViolationChecks' and 'saveLoanWithDataIntegrityViolationChecks' indicate that the implementation of this service is responsible for interacting with the database to save state changes, likely wrapping JPA repository calls with additional validation logic.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM entity persistence and flushing", "transactionHandling": "Likely Spring @Transactional in implementation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Loan saveAndFlushLoanWithDataIntegrityViolationChecks(Loan loan);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanTransactionToRepaymentScheduleMapping", "description": "The class is a JPA Entity that maps to the 'm_loan_transaction_repayment_schedule_mapping' database table. It uses standard Jakarta Persistence annotations to define the table name, column mappings, and relationships (ManyToOne) to other entities.", "databaseName": "m_loan_transaction_repayment_schedule_mapping", "tablesAccessed": [ "m_loan_transaction_repayment_schedule_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_transaction_repayment_schedule_mapping\")\npublic class LoanTransactionToRepaymentScheduleMapping extends AbstractPersistableCustom {\n @ManyToOne(optional = false, cascade = CascadeType.PERSIST)\n @JoinColumn(name = \"loan_transaction_id\", nullable = false)\n private LoanTransaction loanTransaction;\n // ..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanTransactionRelation", "description": "The class is a JPA Entity mapped to the 'm_loan_transaction_relation' table. It manages foreign key relationships to the 'm_loan_transaction' table (via 'from_loan_transaction_id' and 'to_loan_transaction_id') and the 'm_loan_charge' table (via 'to_loan_charge_id').", "databaseName": "m_loan_transaction_relation", "tablesAccessed": [ "m_loan_transaction_relation", "m_loan_transaction", "m_loan_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_transaction_relation\")\npublic class LoanTransactionRelation extends AbstractAuditableWithUTCDateTimeCustom {\n @ManyToOne\n @JoinColumn(name = \"from_loan_transaction_id\", nullable = false)\n private LoanTransaction fromTransaction;" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanCollateralManagement", "description": "The class is a JPA Entity mapped to the 'm_loan_collateral_management' table. It uses Jakarta Persistence annotations to define the table mapping, column constraints (precision, scale, nullability), and relationships (ManyToOne) with other entities.", "databaseName": "m_loan_collateral_management", "tablesAccessed": [ "m_loan_collateral_management" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_collateral_management\")\npublic class LoanCollateralManagement extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "GroupLoanIndividualMonitoringAccount", "description": "The class is a JPA Entity that maps to the 'glim_accounts' table. It defines the schema structure including columns for account details and relationships to Group and Loan entities.", "databaseName": "glim_accounts", "tablesAccessed": [ "glim_accounts" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"glim_accounts\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"account_number\" }, name = \"FK_glim_id\") })\npublic class GroupLoanIndividualMonitoringAccount extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanTransaction", "description": "The class is a JPA Entity mapped to the 'm_loan_transaction' table. It uses standard Jakarta Persistence annotations to define the mapping, including relationships to other entities like 'Loan' and 'Office'.", "databaseName": "m_loan_transaction", "tablesAccessed": [ "m_loan_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_transaction\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"external_id\" }, name = \"external_id_UNIQUE\") })\npublic class LoanTransaction extends AbstractAuditableWithUTCDateTimeCustom {\n\n @ManyToOne(optional = false)\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "JPA", "name": "LoanInterestRecalcualtionAdditionalDetails", "description": "The class is a JPA entity mapped to the database table 'm_loan_interest_recalculation_additional_details'. It uses Jakarta Persistence annotations to define the table name, column mappings (including precision and scale for the amount), and a Many-to-One relationship with the LoanRepaymentScheduleInstallment entity via a foreign key column.", "databaseName": "m_loan_interest_recalculation_additional_details", "tablesAccessed": [ "m_loan_interest_recalculation_additional_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_interest_recalculation_additional_details\")\npublic class LoanInterestRecalcualtionAdditionalDetails extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"loan_repayment_schedule_id\", nullable = false)\n private LoanRepaymentScheduleInstallment loanRepaymentScheduleInstallment;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.Loan", "mechanism": "JPA", "name": "Loan Entity", "description": "The class is a JPA Entity mapped to the 'm_loan' table. It uses standard Jakarta Persistence annotations to define the mapping of fields to database columns and relationships to other entities (Client, Group, LoanProduct, etc.).", "databaseName": "m_loan", "tablesAccessed": [ "m_loan", "m_loan_rate", "m_loan_charge", "m_loan_collateral", "m_loan_collateral_management", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_loan_disbursement_detail", "m_loan_term_variations", "m_loan_interest_recalculation_details", "m_loan_topup_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM-based CRUD operations managed by the persistence context.", "transactionHandling": "JPA EntityTransaction (managed by the container/service layer)", "protocol": "JDBC (via Hibernate/JPA)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"account_no\" }, name = \"loan_account_no_UNIQUE\"),\n @UniqueConstraint(columnNames = { \"external_id\" }, name = \"loan_externalid_UNIQUE\") })\npublic class Loan extends AbstractAuditableWithUTCDateTimeCustom {\n @Column(name = \"account_no\", length = 20, unique = true, nullable = false)\n private String accountNumber;\n ..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanAccountDomainServiceJpa", "mechanism": "JPA", "name": "LoanRepositoryWrapper, LoanTransactionRepository", "description": "The class uses Spring Data JPA repositories (and wrapper services around them) to persist `Loan`, `LoanTransaction`, `Note`, and other related entities. It relies on `@Transactional` annotations to manage database transactions.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_transaction", "m_note", "m_holiday", "m_working_days", "m_account_transfer_transaction", "m_standing_instruction", "m_post_dated_checks", "m_loan_collateral_management" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations via repositories, with some complex object graph traversals handled by Hibernate.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.loanTransactionRepository.saveAndFlush(newRepaymentTransaction);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanCharge", "mechanism": "JPA", "name": "LoanCharge Entity", "description": "The class is a JPA Entity mapped to the 'm_loan_charge' table. It uses standard Jakarta Persistence annotations to define the table structure, columns, and relationships (ManyToOne with Loan and Charge, OneToMany with LoanInstallmentCharge).", "databaseName": "m_loan_charge", "tablesAccessed": [ "m_loan_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_charge\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"external_id\" }, name = \"external_id\") })\npublic class LoanCharge extends AbstractAuditableWithUTCDateTimeCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"loan_id\", referencedColumnName = \"id\", nullable = false)\n private Loan loan;\n ..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanChargePaidBy", "mechanism": "JPA", "name": "LoanChargePaidBy", "description": "The class is a JPA entity mapped to the 'm_loan_charge_paid_by' table. It uses Jakarta Persistence annotations to define the table mapping, column constraints (precision, scale, nullability), and foreign key relationships to the 'm_loan_transaction' and 'm_loan_charge' tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_charge_paid_by" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_charge_paid_by\")\npublic class LoanChargePaidBy extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanDisbursementDetails", "mechanism": "JPA", "name": "LoanDisbursementDetails", "description": "The class is a JPA Entity mapped to the 'm_loan_disbursement_detail' table. It uses standard Jakarta Persistence annotations to define the table mapping, column definitions (precision, scale), and relationships (ManyToOne to Loan).", "databaseName": "m_loan_disbursement_detail", "tablesAccessed": [ "m_loan_disbursement_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_loan_disbursement_detail\")\npublic class LoanDisbursementDetails extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanInstallmentCharge", "mechanism": "JPA", "name": "LoanInstallmentCharge Entity", "description": "The class is a JPA Entity mapped to the 'm_loan_installment_charge' table. It defines the schema for storing loan installment charges, including columns for amounts (amount, paid, waived, written off, outstanding) and relationships to the 'm_loan_charge' and 'm_loan_repayment_schedule' tables via ManyToOne associations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_installment_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_installment_charge\")\npublic class LoanInstallmentCharge extends AbstractPersistableCustom implements Comparable {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"loan_charge_id\", referencedColumnName = \"id\", nullable = false)\n private LoanCharge loancharge;" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanInterestRecalculationDetails", "mechanism": "JPA", "name": "LoanInterestRecalculationDetails", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'm_loan_recalculation_details' table. It uses standard JPA annotations for column mapping and relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_recalculation_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping without explicit queries in this file.", "transactionHandling": "Implicitly handled by the JPA provider/container (likely Spring @Transactional in service layer).", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_recalculation_details\")\npublic class LoanInterestRecalculationDetails extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;\n ..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanOverdueInstallmentCharge", "mechanism": "JPA", "name": "LoanOverdueInstallmentCharge", "description": "The class is a JPA entity mapped to the 'm_loan_overdue_installment_charge' table using Jakarta Persistence annotations.", "databaseName": "m_loan_overdue_installment_charge", "tablesAccessed": [ "m_loan_overdue_installment_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping for CRUD operations.", "transactionHandling": "Implicitly handled by the JPA provider and container transaction management.", "protocol": "JDBC (via JPA)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_overdue_installment_charge\")\npublic class LoanOverdueInstallmentCharge extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment", "mechanism": "JPA", "name": "LoanRepaymentScheduleInstallment Entity", "description": "The class is a standard JPA Entity annotated with @Entity and @Table(name = 'm_loan_repayment_schedule'). It maps class fields to database columns using @Column. It uses @ManyToOne for the relationship to the Loan table and @OneToMany for child collections like installment charges.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_repayment_schedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with standard CRUD operations managed by the persistence context.", "transactionHandling": "JPA EntityTransaction (implicit via framework usage)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_repayment_schedule\")\npublic class LoanRepaymentScheduleInstallment ... {\n @Column(name = \"principal_amount\", scale = 6, precision = 19, nullable = true)\n private BigDecimal principal;\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanSummary", "mechanism": "JPA", "name": "LoanSummary", "description": "The class is an @Embeddable JPA component. Its fields are mapped to database columns in the table of the owning entity (likely the Loan table) using @Column annotations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping of embedded fields", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Column(name = \"principal_disbursed_derived\", scale = 6, precision = 19)\nprivate BigDecimal totalPrincipalDisbursed;" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTermVariations", "mechanism": "JPA", "name": "LoanTermVariations", "description": "The class is a JPA entity mapped to the 'm_loan_term_variations' table using Jakarta Persistence annotations. It defines columns for term details and relationships to the Loan entity.", "databaseName": "m_loan_term_variations", "tablesAccessed": [ "m_loan_term_variations" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_term_variations\")\npublic class LoanTermVariations extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTopupDetails", "mechanism": "JPA", "name": "LoanTopupDetails", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the schema mapping, including table name, column definitions, and foreign key relationships.", "databaseName": "m_loan_topup", "tablesAccessed": [ "m_loan_topup" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_loan_topup\")\npublic class LoanTopupDetails extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTrancheCharge", "mechanism": "JPA", "name": "LoanTrancheCharge", "description": "The class is a JPA entity mapped to the 'm_loan_tranche_charges' table. It uses Jakarta Persistence annotations to define the schema mapping and relationships.", "databaseName": "m_loan_tranche_charges", "tablesAccessed": [ "m_loan_tranche_charges" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM mappings for CRUD operations managed by the persistence provider.", "transactionHandling": "Transactions are managed implicitly by the JPA EntityTransaction or Spring container context.", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_tranche_charges\")\npublic class LoanTrancheCharge extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTrancheDisbursementCharge", "mechanism": "JPA", "name": "LoanTrancheDisbursementCharge", "description": "The class is a JPA Entity mapped to the 'm_loan_tranche_disbursement_charge' table. It uses Jakarta Persistence annotations to define the table name and column mappings. It establishes foreign key relationships to the 'm_loan_charge' table (via 'loan_charge_id') and the 'm_loan_disbursement_detail' table (via 'disbursement_detail_id').", "databaseName": "m_loan_tranche_disbursement_charge", "tablesAccessed": [ "m_loan_tranche_disbursement_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_tranche_disbursement_charge\")\npublic class LoanTrancheDisbursementCharge extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"loan_charge_id\", referencedColumnName = \"id\", nullable = false)\n private LoanCharge loancharge;\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain.Guarantor", "mechanism": "JPA", "name": "Guarantor Entity", "description": "The class is a JPA entity mapped to the 'm_guarantor' table. It uses standard Jakarta Persistence annotations to define the schema mapping, relationships (ManyToOne with Loan, OneToMany with GuarantorFundingDetails), and column definitions.", "databaseName": "m_guarantor", "tablesAccessed": [ "m_guarantor" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with relationships.", "transactionHandling": "JPA EntityTransaction", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_guarantor\")\npublic class Guarantor extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"loan_id\", nullable = false)\n private Loan loan;" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain.GuarantorFundingDetails", "mechanism": "JPA", "name": "GuarantorFundingDetails", "description": "The class is a JPA Entity mapped to the 'm_guarantor_funding_details' table. It uses standard Jakarta Persistence annotations to define the table mapping, columns, and relationships (ManyToOne, OneToMany).", "databaseName": "m_guarantor_funding_details", "tablesAccessed": [ "m_guarantor_funding_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_guarantor_funding_details\")\npublic class GuarantorFundingDetails extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain.GuarantorFundingTransaction", "mechanism": "JPA", "name": "GuarantorFundingTransaction", "description": "The class is a JPA Entity that maps to the 'm_guarantor_transaction' table. It uses Jakarta Persistence annotations to define the table mapping, column constraints, and relationships with other entities (Many-to-One and One-to-One).", "databaseName": "m_guarantor_transaction", "tablesAccessed": [ "m_guarantor_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with relationship navigation.", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_guarantor_transaction\")\npublic class GuarantorFundingTransaction extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.service.GuarantorWritePlatformServiceJpaRepositoryIImpl", "mechanism": "JPA", "name": "GuarantorRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on Guarantor, Loan, and AccountAssociations entities. It uses @Transactional to manage transaction boundaries.", "databaseName": "unknown", "tablesAccessed": [ "m_guarantor", "m_loan", "m_portfolio_account_associations", "m_code_value", "m_client", "m_staff", "m_savings_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findOne, findByLoan) and some domain service calls.", "transactionHandling": "Spring @Transactional annotations on public methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.guarantorRepository.saveAndFlush(guarantor);" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation and handles JPA-specific exceptions (`JpaSystemException`), indicating interaction with a JPA persistence layer via the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Transactional service method invocation", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.makeLoanRepayment(...);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) {\n // handle error\n }\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation and handles JPA-specific exceptions (`JpaSystemException`). While it does not execute SQL directly, it orchestrates a write operation (`makeLoanRepayment`) on the Loan entity through the injected service.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_transaction" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for transactional writes", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.makeLoanRepayment(LoanTransactionType.MERCHANT_ISSUED_REFUND, ...);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class manages the transaction boundary for database operations using Spring's `@Transactional` annotation. While it delegates the actual persistence calls to `LoanWritePlatformService`, it explicitly handles JPA-specific exceptions (`JpaSystemException`) and database constraint violations (`DataIntegrityViolationException`), indicating it is tightly coupled to the database interaction layer.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Transactional write operation delegated to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n // ...\n return this.writePlatformService.makeLoanRepayment(LoanTransactionType.REPAYMENT, ...);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) {\n // ...\n }\n }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation and handles JPA-specific exceptions (JpaSystemException, DataIntegrityViolationException), although the direct database writes are delegated to the injected service.", "databaseName": "unknown", "tablesAccessed": [ "LOAN" ], "operationType": [ "WRITE" ], "queryPatterns": "Transactional write operation delegated to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.disburseLoan(command.entityId(), command, false);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanChargeWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation and handles JPA-specific exceptions (`JpaSystemException`, `DataIntegrityViolationException`). While it does not execute SQL directly, it orchestrates the transaction for the `LoanChargeWritePlatformService` which performs the persistence operations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Transactional service delegation", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.loanChargeRefund(command.getLoanId(), command);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class manages a database transaction using Spring's @Transactional annotation and handles JPA-specific exceptions (JpaSystemException). While it does not execute SQL directly, it orchestrates a write operation (refund) via the LoanWritePlatformService which interacts with the persistence layer.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "WRITE" ], "queryPatterns": "Transactional write operation delegated to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.creditBalanceRefund(command.getLoanId(), command);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.AddLoanChargeCommandHandler", "mechanism": "JPA", "name": "LoanChargeWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation and handles JPA-specific exceptions (JpaSystemException, DataIntegrityViolationException). While it delegates the actual persistence logic to the LoanChargeWritePlatformService, it acts as the transaction boundary and error handling layer for database interactions related to creating loan charges.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n return this.writePlatformService.addLoanCharge(command.getLoanId(), command);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.LoanPayoutRefundCommandHandler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The class interacts with the database indirectly through the `LoanWritePlatformService`. It manages the transaction boundary using Spring's `@Transactional` annotation. The explicit handling of `JpaSystemException` and `DataIntegrityViolationException` confirms that the underlying service interacts with a JPA-based persistence layer.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "The code delegates to a service layer, but the context implies a write/update operation (Repayment) on Loan entities.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n try {\n // ...\n return this.writePlatformService.makeLoanRepayment(LoanTransactionType.PAYOUT_REFUND, ...);\n } catch (final JpaSystemException | DataIntegrityViolationException dve) {\n // ...\n }\n }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.UpdateLoanOfficerCommandHandler", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "This class initiates a database write operation by delegating to the `LoanWritePlatformService`. The `processCommand` method is annotated with `@Transactional`, indicating that the call to `writePlatformService.loanReassignment` is executed within a database transaction managed by the Spring framework. The actual database interaction logic (e.g., finding the loan entity, updating its officer field, and saving the changes) resides within the `LoanWritePlatformService`, which uses JPA for persistence.", "databaseName": "not identifiable from code", "tablesAccessed": [ "m_loan" ], "operationType": [ "WRITE" ], "queryPatterns": "ORM-based entity update", "transactionHandling": "Spring @Transactional", "protocol": "not identifiable from code", "connectionInfo": "not identifiable from code", "codeExample": "return this.writePlatformService.loanReassignment(command.getLoanId(), command);" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.domain", "mechanism": "JPA", "name": "LoanRepaymentScheduleHistory", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, precision for decimal values, and foreign key relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_repayment_schedule_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_repayment_schedule_history\")\npublic class LoanRepaymentScheduleHistory extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.service", "mechanism": "JPA", "name": "LoanAccountDomainService", "description": "The class interacts with the database primarily through the `LoanAccountDomainService` to persist changes to the `Loan` entity and its related `LoanTermVariations`. It also uses `LoanAssembler` to fetch entities. The operations are wrapped in a Spring `@Transactional` annotation to ensure atomicity.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_term_variations" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM entity retrieval and save operations", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "loanAccountDomainService.saveLoanWithDataIntegrityViolationChecks(loan);" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.domain.LoanRescheduleRequest", "mechanism": "JPA", "name": "LoanRescheduleRequest", "description": "The class is a JPA Entity mapped to the 'm_loan_reschedule_request' table. It uses Jakarta Persistence annotations to define the schema mapping and relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_reschedule_request" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_loan_reschedule_request\")\npublic class LoanRescheduleRequest extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.handler", "mechanism": "JPA", "name": "LoanRescheduleRequestWritePlatformService", "description": "The class participates in database transactions via the Spring `@Transactional` annotation. While it does not execute SQL directly, it defines the transaction boundary for the `approve` operation performed by the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.loanRescheduleRequestWritePlatformService.approve(jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "JPA", "name": "LoanArrearsAgingService", "description": "The interface interacts with the database primarily through the 'Loan' domain entity (likely JPA) and explicitly through the generation of SQL statements in 'createInsertStatements'. This suggests a hybrid approach using both ORM for entity management and raw SQL generation for bulk operations.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanSchedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Hybrid approach: ORM-based entity updates and manual SQL string generation for batch inserts.", "transactionHandling": "Likely managed by Spring @Transactional in the implementation classes.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "void createInsertStatements(List insertStatement, ...)" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanApplicationWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "LoanRepositoryWrapper, ClientRepositoryWrapper, etc.", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrapper classes) to interact with the database. It performs CRUD operations on entities like Loan, Client, Group, LoanProduct, CalendarInstance, and Note. It uses `@Transactional` to ensure atomicity of complex operations involving multiple tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_client", "m_group", "m_product_loan", "m_calendar", "m_calendar_instance", "m_note", "m_portfolio_account_associations", "glim_account_info_table", "m_loan_collateral_management", "m_client_collateral_management" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code primarily uses `findById`, `save`, `saveAndFlush`, and `delete` methods provided by the repositories. There are also custom finder methods like `findActiveLoansLoanProductIdsByGroup` and `findNonClosedLoanThatBelongsToClient` which likely execute JPQL queries.", "transactionHandling": "Spring @Transactional annotations are used on public methods to manage transaction boundaries.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.loanRepositoryWrapper.saveAndFlush(newLoanApplication);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanWritePlatformService", "mechanism": "JPA", "name": "LoanWritePlatformService", "description": "The service manages write operations for loans, which involves persisting changes to Loan and LoanTransaction entities within transactions. It uses Spring's @Transactional annotation to manage transaction boundaries.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanTransaction", "Office", "Staff", "Calendar", "CalendarInstance" ], "operationType": [ "WRITE", "READ_WRITE" ], "queryPatterns": "Transactional updates to domain entities.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\nCommandProcessingResult makeLoanRepaymentWithChargeRefundChargeType(LoanTransactionType repaymentTransactionType, Long loanId, JsonCommand command, boolean isRecoveryRepayment, String chargeRefundChargeType);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "LoanRepositoryWrapper", "description": "The service uses Spring Data JPA repositories (wrapped in wrapper classes like `LoanRepositoryWrapper`) to interact with the database. It performs CRUD operations on `Loan`, `LoanTransaction`, and related entities. It uses `@Transactional` to ensure atomicity of complex business operations involving multiple tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_transaction", "m_note", "m_loan_charge", "m_loan_collateral_management", "m_loan_disbursement_detail", "m_loan_repayment_schedule", "glim_accounts", "m_calendar_instance", "m_holiday", "m_working_days" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM-based CRUD operations, finding entities by ID, saving entities with cascade updates.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "loanRepaymentScheduleInstallmentRepository.saveAll(loan.getRepaymentScheduleInstallments());\nreturn this.loanRepositoryWrapper.saveAndFlush(loan);" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "LoanProductBorrowerCycleVariations", "description": "The class is a JPA Entity mapped to the `m_product_loan_variations_borrower_cycle` table. It uses standard Jakarta Persistence annotations to define the table name, column mappings (including precision/scale for BigDecimals), and a Many-to-One relationship with the `LoanProduct` entity.", "databaseName": "m_product_loan_variations_borrower_cycle", "tablesAccessed": [ "m_product_loan_variations_borrower_cycle" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_product_loan_variations_borrower_cycle\")\npublic class LoanProductBorrowerCycleVariations extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "LoanProductConfigurableAttributes", "description": "The class is a JPA Entity mapped to the 'm_product_loan_configurable_attributes' table using Jakarta Persistence annotations. It uses a One-to-One relationship with the LoanProduct entity.", "databaseName": "m_product_loan_configurable_attributes", "tablesAccessed": [ "m_product_loan_configurable_attributes" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_product_loan_configurable_attributes\")\npublic class LoanProductConfigurableAttributes extends AbstractPersistableCustom implements Serializable {\n @OneToOne\n @JoinColumn(name = \"loan_product_id\", nullable = false)\n private LoanProduct loanProduct;" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "LoanProductRelatedDetail", "description": "This class is a JPA Embeddable component. It does not represent a standalone table but defines a set of columns that are embedded into the tables of entities that use it (likely Loan or LoanProduct tables). It uses standard Jakarta Persistence annotations to map fields to database columns.", "databaseName": "unknown", "tablesAccessed": [ "Embeddable (tables depend on embedding entity)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings via @Embeddable and @Column", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class LoanProductRelatedDetail implements LoanProductMinimumRepaymentScheduleRelatedDetail {\n @Column(name = \"principal_amount\", scale = 6, precision = 19)\n private BigDecimal principal;\n @Enumerated(EnumType.ORDINAL)\n @Column(name = \"interest_period_frequency_enum\")\n private PeriodFrequencyType interestPeriodFrequencyType;\n}" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "LoanProductPaymentAllocationRule", "description": "The class uses Jakarta Persistence (JPA) annotations to map the object model to the relational database table 'm_loan_product_payment_allocation_rule'. It defines column mappings, constraints, and relationships.", "databaseName": "m_loan_product_payment_allocation_rule", "tablesAccessed": [ "m_loan_product_payment_allocation_rule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JPA / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_loan_product_payment_allocation_rule\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"loan_product_id\", \"transaction_type\" }, name = \"uq_m_loan_product_payment_allocation_rule\") })\npublic class LoanProductPaymentAllocationRule extends AbstractAuditableWithUTCDateTimeCustom {" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "LoanProductMinMaxConstraints", "description": "The class is a JPA Embeddable component. It defines the schema for min/max constraints columns (e.g., 'min_principal_amount', 'max_principal_amount') which are embedded into the table of the parent entity (likely LoanProduct).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class LoanProductMinMaxConstraints {\n @Column(name = \"min_principal_amount\", scale = 6, precision = 19)\n private BigDecimal minPrincipal;\n // ..." }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "JPA", "name": "AllocationTypeListConverter", "description": "This class is a JPA AttributeConverter. It intercepts database read and write operations for attributes of type List, converting them to a String format (likely CSV) for the database and back to a List for the Java entity.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM conversion logic", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Converter(autoApply = true)\npublic class AllocationTypeListConverter extends GenericEnumListConverter\n implements AttributeConverter, String>" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProduct", "mechanism": "JPA", "name": "LoanProduct Entity", "description": "The class is a standard JPA Entity annotated with @Entity and @Table. It maps to the 'm_product_loan' table. It uses @OneToMany, @ManyToOne, @ManyToMany, and @OneToOne annotations to define relationships with other entities like Fund, Charge, Rate, and various configuration details. It uses @Embedded to flatten complex value objects into the main table.", "databaseName": "m_product_loan", "tablesAccessed": [ "m_product_loan", "m_product_loan_charge", "m_product_loan_rate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_product_loan\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"unq_name\"), ... })\npublic class LoanProduct extends AbstractPersistableCustom {\n @Column(name = \"name\", nullable = false, unique = true)\n private String name;\n ..." }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProductFloatingRates", "mechanism": "JPA", "name": "LoanProductFloatingRates", "description": "The class is a JPA Entity mapped to the 'm_product_loan_floating_rates' table. It uses Jakarta Persistence annotations to define the table mapping, column constraints, and relationships (OneToOne, ManyToOne).", "databaseName": "m_product_loan_floating_rates", "tablesAccessed": [ "m_product_loan_floating_rates" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with relationship handling", "transactionHandling": "JPA EntityTransaction (implicit via container)", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_product_loan_floating_rates\")\npublic class LoanProductFloatingRates extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"loan_product_id\", nullable = false)\n private LoanProduct loanProduct;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProductGuaranteeDetails", "mechanism": "JPA", "name": "LoanProductGuaranteeDetails", "description": "The class is a JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships.", "databaseName": "m_product_loan_guarantee_details", "tablesAccessed": [ "m_product_loan_guarantee_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_product_loan_guarantee_details\")\npublic class LoanProductGuaranteeDetails extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProductInterestRecalculationDetails", "mechanism": "JPA", "name": "LoanProductInterestRecalculationDetails", "description": "The class is a JPA Entity that maps to the 'm_product_loan_recalculation_details' table. It uses Jakarta Persistence annotations (@Entity, @Table, @Column, @OneToOne) to define the schema mapping. It maintains a one-to-one relationship with the 'LoanProduct' entity via the 'product_id' join column.", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan_recalculation_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_product_loan_recalculation_details\")\npublic class LoanProductInterestRecalculationDetails extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"product_id\", nullable = false)\n private LoanProduct loanProduct;\n // ..." }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProductTrancheDetails", "mechanism": "JPA", "name": "LoanProductTrancheDetails", "description": "The class is a JPA Embeddable component. It defines database column mappings for tranche-related fields which will be part of the table of the entity that embeds this class (likely the Loan Product table).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Column(name = \"max_outstanding_loan_balance\", scale = 6, precision = 19)\nprivate BigDecimal outstandingLoanBalance;" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain.LoanProductVariableInstallmentConfig", "mechanism": "JPA", "name": "LoanProductVariableInstallmentConfig", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and relationships (OneToOne).", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan_variable_installment_config" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_product_loan_variable_installment_config\")\npublic class LoanProductVariableInstallmentConfig extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.loanproduct.productmix.domain.ProductMix", "mechanism": "JPA", "name": "ProductMix Entity", "description": "This class is a JPA Entity that maps directly to the relational database table 'm_product_mix'. It uses annotations to define foreign key relationships to the LoanProduct table.", "databaseName": "m_product_mix", "tablesAccessed": [ "m_product_mix" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_product_mix\")\npublic class ProductMix extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"product_id\", nullable = false)\n private LoanProduct product;\n}" }, { "path": "org.apache.fineract.portfolio.meeting.attendance.domain.ClientAttendance", "mechanism": "JPA", "name": "ClientAttendance", "description": "The class is a JPA Entity mapped to the 'm_client_attendance' table. It defines the schema structure including foreign keys to Client and Meeting tables and a unique constraint.", "databaseName": "m_client_attendance", "tablesAccessed": [ "m_client_attendance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_client_attendance\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"client_id\", \"meeting_id\" }, name = \"unique_client_meeting_attendance\") })\npublic class ClientAttendance extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.meeting.domain.Meeting", "mechanism": "JPA", "name": "Meeting", "description": "The class is a JPA Entity mapped to the 'm_meeting' table. It uses standard Jakarta Persistence annotations to define the table structure, unique constraints, and relationships (ManyToOne, OneToMany).", "databaseName": "m_meeting", "tablesAccessed": [ "m_meeting", "m_client_attendance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_meeting\", uniqueConstraints = {\n @UniqueConstraint(columnNames = { \"calendar_instance_id\", \"meeting_date\" }, name = \"unique_calendar_instance_id_meeting_date\") })\npublic class Meeting extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.note.domain.Note", "mechanism": "JPA", "name": "Note", "description": "The class is a standard JPA Entity mapped to the 'm_note' table. It defines relationships to other tables (m_client, m_group, m_loan, etc.) using @ManyToOne annotations.", "databaseName": "m_note", "tablesAccessed": [ "m_note" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_note\")\npublic class Note extends AbstractAuditableWithUTCDateTimeCustom {\n @ManyToOne\n @JoinColumn(name = \"client_id\", nullable = true)\n private Client client;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.paymentdetail.domain", "mechanism": "JPA", "name": "PaymentDetail", "description": "The class is a JPA entity mapped to the 'm_payment_detail' database table. It uses annotations to define column mappings and relationships.", "databaseName": "m_payment_detail", "tablesAccessed": [ "m_payment_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_payment_detail\")\npublic final class PaymentDetail extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.paymenttype.domain.PaymentType", "mechanism": "JPA", "name": "PaymentType Entity", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name and column mappings.", "databaseName": "m_payment_type", "tablesAccessed": [ "m_payment_type" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_payment_type\")\npublic class PaymentType extends AbstractPersistableCustom {\n @Column(name = \"value\")\n private String name;\n}" }, { "path": "org.apache.fineract.portfolio.rate.domain.Rate", "mechanism": "JPA", "name": "Rate", "description": "The class is a JPA entity mapped to the 'm_rate' database table. It uses Jakarta Persistence annotations to define the table structure, columns, and relationships.", "databaseName": "m_rate", "tablesAccessed": [ "m_rate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_rate\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"name\") })\npublic class Rate extends AbstractAuditableCustom {\n @Column(name = \"name\", length = 250, unique = true)\n private String name;\n // ..." }, { "path": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.domain.PostDatedChecks", "mechanism": "JPA", "name": "PostDatedChecks", "description": "The class is a JPA entity that maps to the 'm_repayment_with_post_dated_checks' table. It uses Jakarta Persistence annotations to define the table structure, column constraints, and foreign key relationships to the Loan and LoanRepaymentScheduleInstallment tables.", "databaseName": "m_repayment_with_post_dated_checks", "tablesAccessed": [ "m_repayment_with_post_dated_checks" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations.", "transactionHandling": "Implicitly handled by the JPA provider/container.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_repayment_with_post_dated_checks\")\npublic class PostDatedChecks extends AbstractPersistableCustom {\n @Column(name = \"account_no\", nullable = false, length = 10)\n private Long accountNo;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "n/a", "description": "The class is a JPA Embeddable component. It does not interact with the database directly but defines columns that will be part of the table of the entity embedding it.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings via annotations", "transactionHandling": "JPA EntityTransaction (managed by context)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Column(name = \"is_mandatory\", nullable = true)\nprivate boolean isMandatoryDeposit;" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "SavingsAccountChargePaidBy", "description": "The class is a JPA entity mapped to the 'm_savings_account_charge_paid_by' table. It uses Jakarta Persistence annotations to define the table mapping and relationships (ManyToOne) with other entities.", "databaseName": "m_savings_account_charge_paid_by", "tablesAccessed": [ "m_savings_account_charge_paid_by" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account_charge_paid_by\")\npublic class SavingsAccountChargePaidBy extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "SavingsOfficerAssignmentHistory", "description": "The class is a JPA entity that maps directly to the 'm_savings_officer_assignment_history' table. It uses annotations to define the table name, column mappings, and relationships (ManyToOne) to other entities (SavingsAccount, Staff).", "databaseName": "m_savings_officer_assignment_history", "tablesAccessed": [ "m_savings_officer_assignment_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA 3.1 / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_officer_assignment_history\")\npublic class SavingsOfficerAssignmentHistory extends AbstractAuditableCustom {\n @ManyToOne\n @JoinColumn(name = \"account_id\", nullable = false)\n private SavingsAccount savingsAccount;" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "SavingsAccountTransaction", "description": "The class is a JPA entity mapped to the 'm_savings_account_transaction' table. It uses standard JPA annotations for ORM mapping.", "databaseName": "m_savings_account_transaction", "tablesAccessed": [ "m_savings_account_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity operations (persist, merge, find).", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account_transaction\")\npublic final class SavingsAccountTransaction extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "SavingsAccountSummary", "description": "This class is a JPA Embeddable component. It does not represent a standalone table but defines columns that are embedded into the table of the owning entity (likely SavingsAccount). It uses standard Jakarta Persistence annotations to map fields to database columns with specific precision and scale.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic final class SavingsAccountSummary {\n @Column(name = \"total_deposits_derived\", scale = 6, precision = 19)\n private BigDecimal totalDeposits;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in wrapper classes) to interact with the database. It loads, updates, and saves `SavingsAccount`, `FixedDepositAccount`, `RecurringDepositAccount`, and `CalendarInstance` entities. It also uses `JournalEntryWritePlatformService` to write accounting entries.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_calendar_instance", "m_account_number_format", "acc_gl_journal_entry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations on account entities, fetching calendar instances, and persisting journal entries.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.savingsAccountRepository.save(account);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositProductTermAndPreClosure", "description": "The class is a JPA Entity that maps to the 'm_deposit_product_term_and_preclosure' table. It uses Jakarta Persistence annotations to define the mapping. It utilizes @Embedded to flatten the structure of related value objects (DepositPreClosureDetail, DepositTermDetail, DepositProductAmountDetails) into columns within the same table, and @OneToOne to link to the 'm_savings_product' table (via FixedDepositProduct).", "databaseName": "unknown", "tablesAccessed": [ "m_deposit_product_term_and_preclosure" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA ORM mapping with embedded objects.", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_deposit_product_term_and_preclosure\")\npublic class DepositProductTermAndPreClosure extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositProductRecurringDetail", "description": "The class is a JPA Entity that maps to a relational database table. It uses Jakarta Persistence annotations to define the table name, relationships, and embedded fields.", "databaseName": "m_deposit_product_recurring_detail", "tablesAccessed": [ "m_deposit_product_recurring_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_deposit_product_recurring_detail\")\npublic class DepositProductRecurringDetail extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "RecurringDepositAccount Entity", "description": "The class is a JPA entity that maps to the database table for savings accounts (likely 'm_savings_account' via inheritance). It uses a discriminator value '300' to distinguish itself from other savings account types. It manages relationships with other entities like DepositAccountTermAndPreClosure, DepositAccountRecurringDetail, and RecurringDepositScheduleInstallment using @OneToOne and @OneToMany annotations with CascadeType.ALL.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_deposit_account_term_and_pre_closure", "m_deposit_account_recurring_detail", "m_deposit_account_interest_rate_chart", "m_recurring_deposit_schedule_installment" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@DiscriminatorValue(\"300\")\npublic class RecurringDepositAccount extends SavingsAccount {\n @OneToOne(mappedBy = \"account\", cascade = CascadeType.ALL)\n private DepositAccountTermAndPreClosure accountTermAndPreClosure;\n ..." }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositAccountDomainService", "description": "This interface defines a domain service that orchestrates changes to JPA entities (SavingsAccount, FixedDepositAccount, RecurringDepositAccount). The @Transactional annotation on 'handleFDAccountMaturityClosure' indicates that the implementation manages database transactions to ensure data consistency during complex operations like account maturity.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The implementation likely uses JPA entity state transitions (modifying fields on the account objects) which are then flushed to the database.", "transactionHandling": "Spring @Transactional annotation is explicitly used on the maturity closure method, implying declarative transaction management.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\nLong handleFDAccountMaturityClosure(FixedDepositAccount account, ...)" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositAccountInterestRateChart", "description": "The class is a JPA Entity mapped to the 'm_savings_account_interest_rate_chart' table. It uses standard Jakarta Persistence annotations to define the table mapping, embedded fields, and relationships (OneToOne with SavingsAccount, OneToMany with DepositAccountInterestRateChartSlabs).", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account_interest_rate_chart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_savings_account_interest_rate_chart\")\npublic class DepositAccountInterestRateChart extends AbstractPersistableCustom {\n @OneToOne\n @JoinColumn(name = \"savings_account_id\", nullable = false)\n private SavingsAccount account;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositAccountOnHoldTransaction", "description": "The class is a JPA Entity mapped to the 'm_deposit_account_on_hold_transaction' table. It uses standard Jakarta Persistence annotations to define columns and relationships.", "databaseName": "m_deposit_account_on_hold_transaction", "tablesAccessed": [ "m_deposit_account_on_hold_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_deposit_account_on_hold_transaction\")\npublic class DepositAccountOnHoldTransaction extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "DepositAccountRecurringDetail", "description": "The class is a JPA Entity mapped to the 'm_deposit_account_recurring_detail' table. It uses standard Jakarta Persistence annotations to define the table mapping, columns, and relationships (OneToOne with SavingsAccount).", "databaseName": "m_deposit_account_recurring_detail", "tablesAccessed": [ "m_deposit_account_recurring_detail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "Unknown (JPA abstraction)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_deposit_account_recurring_detail\")\npublic class DepositAccountRecurringDetail extends AbstractPersistableCustom {\n @Column(name = \"mandatory_recommended_deposit_amount\"...)\n private BigDecimal mandatoryRecommendedDepositAmount;\n @OneToOne\n @JoinColumn(name = \"savings_account_id\", nullable = false)\n private SavingsAccount account;" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "JPA", "name": "RecurringDepositProduct", "description": "The class is a JPA Entity annotated with `@Entity` and `@DiscriminatorValue(\"300\")`. It extends `FixedDepositProduct`, implying a Single Table inheritance strategy where all products are stored in one table (likely `m_savings_product` or similar) distinguished by the discriminator column. It also manages a child entity `DepositProductRecurringDetail` via a `@OneToOne` relationship with `CascadeType.ALL`.", "databaseName": "unknown", "tablesAccessed": [ "RecurringDepositProduct", "DepositProductRecurringDetail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@DiscriminatorValue(\"300\")\npublic class RecurringDepositProduct extends FixedDepositProduct {\n @OneToOne(mappedBy = \"product\", cascade = CascadeType.ALL)\n private DepositProductRecurringDetail recurringDetail;" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositAccountInterestIncentive", "mechanism": "JPA", "name": "DepositAccountInterestIncentive", "description": "The class uses Jakarta Persistence API (JPA) annotations to map the Java object to a relational database table. It defines relationships and embedded fields that correspond to columns in the 'm_deposit_account_interest_incentives' table.", "databaseName": "m_deposit_account_interest_incentives", "tablesAccessed": [ "m_deposit_account_interest_incentives" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_deposit_account_interest_incentives\")\npublic class DepositAccountInterestIncentive extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositAccountInterestIncentives", "mechanism": "JPA", "name": "m_savings_interest_incentives", "description": "The class is a JPA entity that maps directly to the 'm_savings_interest_incentives' table in the database. It uses annotations to define the table name, column mappings, and relationships (Many-to-One) with other entities.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_interest_incentives" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_savings_interest_incentives\")\npublic class DepositAccountInterestIncentives extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositAccountInterestRateChartSlabs", "mechanism": "JPA", "name": "DepositAccountInterestRateChartSlabs", "description": "The class is a JPA Entity mapped to the 'm_savings_account_interest_rate_slab' table. It uses Jakarta Persistence annotations to define the table mapping, embedded fields, and relationships with other entities.", "databaseName": "m_savings_account_interest_rate_slab", "tablesAccessed": [ "m_savings_account_interest_rate_slab" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with OneToMany and ManyToOne relationships.", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account_interest_rate_slab\")\npublic class DepositAccountInterestRateChartSlabs extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositAccountTermAndPreClosure", "mechanism": "JPA", "name": "DepositAccountTermAndPreClosure", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'm_deposit_account_term_and_preclosure' table. It uses standard JPA annotations (@Column, @OneToOne, @Embedded) to map class fields to database columns and relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_deposit_account_term_and_preclosure" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction (managed by container/framework)", "protocol": "JDBC/JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_deposit_account_term_and_preclosure\")\npublic class DepositAccountTermAndPreClosure extends AbstractPersistableCustom {\n @Column(name = \"deposit_amount\", scale = 6, precision = 19, nullable = true)\n private BigDecimal depositAmount;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositPreClosureDetail", "mechanism": "JPA", "name": "DepositPreClosureDetail", "description": "This class is a JPA Embeddable component. It does not represent a standalone table but defines columns that are embedded into the tables of the entities that use it (e.g., FixedDepositProduct or FixedDepositAccount). It uses Jakarta Persistence annotations to map fields to database columns.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class DepositPreClosureDetail {\n @Column(name = \"pre_closure_penal_applicable\")\n private boolean preClosurePenalApplicable;\n @Column(name = \"pre_closure_penal_interest\", scale = 6, precision = 19, nullable = true)\n private BigDecimal preClosurePenalInterest;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositProductAmountDetails", "mechanism": "JPA", "name": "DepositProductAmountDetails", "description": "The class uses Jakarta Persistence (JPA) annotations to map its fields to database columns. It is marked as @Embeddable, meaning it does not have its own table but its columns are embedded in the table of the entity that contains it.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mapping via annotations", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class DepositProductAmountDetails {\n @Column(name = \"min_deposit_amount\", scale = 6, precision = 19, nullable = true)\n private BigDecimal minDepositAmount;" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositTermDetail", "mechanism": "JPA", "name": "DepositTermDetail", "description": "This class is a JPA Embeddable component. It does not have its own table but defines columns that are embedded into the tables of entities that use it (e.g., FixedDepositProduct).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Embeddable\npublic class DepositTermDetail {\n @Column(name = \"min_deposit_term\", nullable = true)\n private Integer minDepositTerm;" }, { "path": "org.apache.fineract.portfolio.savings.domain.FixedDepositAccount", "mechanism": "JPA", "name": "FixedDepositAccount Entity", "description": "The class is a JPA Entity mapped to the database. It inherits from `SavingsAccount` and uses a discriminator value to distinguish it in the persistence layer. It uses One-to-One relationships for managing term details and interest charts.", "databaseName": "unknown", "tablesAccessed": [ "FixedDepositAccount (mapped via SavingsAccount table)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM-based CRUD operations, likely using Joined or Single Table inheritance strategy.", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@DiscriminatorValue(\"200\")\npublic class FixedDepositAccount extends SavingsAccount {\n @OneToOne(mappedBy = \"account\", cascade = CascadeType.ALL)\n private DepositAccountTermAndPreClosure accountTermAndPreClosure;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.FixedDepositProduct", "mechanism": "JPA", "name": "FixedDepositProduct Entity", "description": "The class is a JPA Entity annotated with @Entity and @DiscriminatorValue('200'). It maps to a database table (likely 'm_savings_product' via inheritance) and uses a join table 'm_deposit_product_interest_rate_chart' for its relationship with InterestRateChart.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_product", "m_deposit_product_interest_rate_chart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with OneToOne and OneToMany relationships.", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@DiscriminatorValue(\"200\")\npublic class FixedDepositProduct extends SavingsProduct {\n @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)\n @JoinTable(name = \"m_deposit_product_interest_rate_chart\", ...)\n protected Set charts;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.GroupSavingsIndividualMonitoring", "mechanism": "JPA", "name": "GroupSavingsIndividualMonitoring", "description": "The class is a JPA Entity mapped to the 'gsim_accounts' table. It uses Jakarta Persistence annotations to define the schema, including columns, unique constraints, and relationships (ManyToOne with Group, OneToMany with SavingsAccount).", "databaseName": "gsim_accounts", "tablesAccessed": [ "gsim_accounts" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"gsim_accounts\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"account_number\" }, name = \"gsim_id\") })\npublic final class GroupSavingsIndividualMonitoring extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.savings.domain.RecurringDepositScheduleInstallment", "mechanism": "JPA", "name": "RecurringDepositScheduleInstallment", "description": "The class is a JPA Entity that maps directly to the 'm_mandatory_savings_schedule' table. It uses standard Jakarta Persistence annotations to define the table name, column mappings, and relationships (ManyToOne with RecurringDepositAccount).", "databaseName": "unknown", "tablesAccessed": [ "m_mandatory_savings_schedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_mandatory_savings_schedule\")\npublic class RecurringDepositScheduleInstallment extends AbstractAuditableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"savings_account_id\")\n private RecurringDepositAccount account;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsAccount", "mechanism": "JPA", "name": "SavingsAccount", "description": "The class is a JPA Entity mapped to the 'm_savings_account' table. It uses Single Table Inheritance with a discriminator column. It defines relationships with other entities like Client, Group, SavingsProduct, and manages collections of transactions and charges.", "databaseName": "m_savings_account", "tablesAccessed": [ "m_savings_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity mapping with OneToMany and ManyToOne relationships.", "transactionHandling": "JPA EntityTransaction (implicitly managed by container/service layer)", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"account_no\" }, name = \"sa_account_no_UNIQUE\"),\n @UniqueConstraint(columnNames = { \"external_id\" }, name = \"sa_external_id_UNIQUE\") })\n@Inheritance(strategy = InheritanceType.SINGLE_TABLE)\n@DiscriminatorColumn(name = \"deposit_type_enum\", discriminatorType = DiscriminatorType.INTEGER)\n@DiscriminatorValue(\"100\")\npublic class SavingsAccount extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsAccountCharge", "mechanism": "JPA", "name": "SavingsAccountCharge", "description": "The class is a JPA Entity mapped to the 'm_savings_account_charge' table. It uses standard Jakarta Persistence annotations to define the table mapping, column definitions, and relationships (ManyToOne) with SavingsAccount and Charge entities.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM entity mapping", "transactionHandling": "JPA EntityTransaction (implicit via container)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account_charge\")\npublic class SavingsAccountCharge extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"savings_account_id\", referencedColumnName = \"id\", nullable = false)\n private SavingsAccount savingsAccount;\n // ..." }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsAccountTransactionTaxDetails", "mechanism": "JPA", "name": "SavingsAccountTransactionTaxDetails", "description": "The class is a JPA entity mapped to the 'm_savings_account_transaction_tax_details' table. It uses standard JPA annotations to define the table mapping, column constraints, and foreign key relationships to other entities.", "databaseName": "m_savings_account_transaction_tax_details", "tablesAccessed": [ "m_savings_account_transaction_tax_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping with Many-to-One relationships.", "transactionHandling": "Implicitly handled via JPA EntityTransaction or Spring @Transactional in the service layer.", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_account_transaction_tax_details\")\npublic class SavingsAccountTransactionTaxDetails extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"savings_transaction_id\", nullable = false)\n private SavingsAccountTransaction savingsAccountTransaction;\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsProduct", "mechanism": "JPA", "name": "SavingsProduct", "description": "The class is a JPA Entity mapped to the 'm_savings_product' table. It uses Single Table Inheritance with a discriminator column 'deposit_type_enum'. It defines mappings for various columns including unique constraints on name and short_name, and relationships like Many-to-Many with Charges and Many-to-One with TaxGroup.", "databaseName": "m_savings_product", "tablesAccessed": [ "m_savings_product", "m_savings_product_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_savings_product\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"sp_unq_name\") })\n@Inheritance\n@DiscriminatorColumn(name = \"deposit_type_enum\", discriminatorType = DiscriminatorType.INTEGER)\npublic class SavingsProduct extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "DepositAccountWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions. While it does not execute SQL directly, it delegates to `DepositAccountWritePlatformService` which performs write operations on the database.", "databaseName": "unknown", "tablesAccessed": [ "FIXEDDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.prematureCloseFDAccount(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "DepositAccountWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation. While it does not execute SQL directly, it defines the transaction boundary for the `depositToRDAccount` operation performed by the injected service, which likely interacts with the database using JPA.", "databaseName": "unknown", "tablesAccessed": [ "RECURRINGDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.depositToRDAccount(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "DepositApplicationProcessWritePlatformService", "description": "The class defines a transactional boundary using Spring's @Transactional annotation. While it does not execute SQL or call a repository directly, it orchestrates a write operation via the DepositApplicationProcessWritePlatformService which interacts with the database to update the state of the recurring deposit account application.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_application" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.undoApplicationApproval(...);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "DepositAccountWritePlatformService", "description": "The class defines a transaction boundary using the Spring `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates a transactional unit of work that delegates to the `DepositAccountWritePlatformService`, which performs the actual database persistence operations.", "databaseName": "unknown", "tablesAccessed": [ "RECURRINGDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.postInterest(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "SavingsAccountWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation. While it does not execute SQL directly, it orchestrates a write operation ('UNBLOCKCREDIT') on the 'SAVINGSACCOUNT' entity through the injected service, ensuring atomicity of the database changes.", "databaseName": "unknown", "tablesAccessed": [ "SAVINGSACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations.", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.unblockCredits(command.getSavingsId());\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "SavingsAccountWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions for the operation. It delegates the actual data modification to `SavingsAccountWritePlatformService`, which likely interacts with the `SAVINGSACCOUNT` table.", "databaseName": "unknown", "tablesAccessed": [ "SAVINGSACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.blockCredits(command.getSavingsId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "JPA", "name": "SavingsAccountWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation for a database write operation. While it does not contain direct SQL or Repository calls, it orchestrates a persistence operation by delegating to the SavingsAccountWritePlatformService which interacts with the database.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.waiveCharge(command.getSavingsId(), command.entityId());\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler.GSIMDepositCommandHandler", "mechanism": "JPA", "name": "SavingsAccountWritePlatformService", "description": "The class defines a transactional boundary using Spring's `@Transactional` annotation, implying interaction with a transactional resource (database). It delegates the actual persistence logic to `SavingsAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.gsimDeposit(command.getSavingsId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JPA", "name": "DepositAccountAssembler", "description": "The service uses `DepositAccountAssembler` to retrieve domain entities (`SavingsAccount`, `FixedDepositAccount`, `RecurringDepositAccount`) from the database. It is also annotated with `@Transactional`, indicating it participates in a database transaction managed by Spring.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_payment_type" ], "operationType": [ "READ" ], "queryPatterns": "Entity retrieval via assembler and reference data lookup via read platform services.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic DepositAccountData calculatePreMatureAmount(final Long accountId, final JsonQuery query, final DepositAccountType depositAccountType) {\n // ...\n final SavingsAccount account = this.depositAccountAssembler.assembleFrom(accountId, depositAccountType);\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "JPA", "name": "Savings/Deposit Repositories", "description": "The service uses Spring Data JPA repositories to interact with the database. It injects repositories for FixedDepositAccount, RecurringDepositAccount, SavingsAccount, and related entities (Client, Group, Staff, Note). It uses the @Transactional annotation to ensure data consistency across multiple repository calls.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_deposit_account_term_and_preclosure", "m_deposit_account_recurring_detail", "m_calendar_instance", "m_note", "m_portfolio_account_associations", "m_client", "m_group", "m_staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA repositories, with some complex object graph traversal and updates.", "transactionHandling": "Spring @Transactional annotations on the service class and methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.fixedDepositAccountRepository.saveAndFlush(account);" }, { "path": "org.apache.fineract.portfolio.savings.service.DepositAccountWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in wrapper classes) to interact with the database. It performs CRUD operations on savings accounts, transactions, charges, and related entities. Transaction management is handled via Spring's @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction", "m_note", "m_charge", "m_savings_account_charge", "m_calendar_instance", "m_holiday", "m_working_days", "m_deposit_account_on_hold_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findOne, saveAndFlush) with some custom finders.", "transactionHandling": "Spring @Transactional annotations on class and methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.savingAccountRepositoryWrapper.saveAndFlush(account);" }, { "path": "org.apache.fineract.portfolio.self.account.domain.SelfBeneficiariesTPT", "mechanism": "JPA", "name": "SelfBeneficiariesTPT", "description": "The class is a JPA Entity mapped to a relational database table. It uses Jakarta Persistence annotations to define the table name, column mappings, and unique constraints.", "databaseName": "m_selfservice_beneficiaries_tpt", "tablesAccessed": [ "m_selfservice_beneficiaries_tpt" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_selfservice_beneficiaries_tpt\"...)\npublic class SelfBeneficiariesTPT extends AbstractPersistableCustom {\n @Column(name = \"app_user_id\", nullable = false)\n private Long appUserId;\n..." }, { "path": "org.apache.fineract.portfolio.self.pockets.domain", "mechanism": "JPA", "name": "PocketAccountMapping", "description": "The class is a JPA Entity mapped to the 'm_pocket_accounts_mapping' table. It uses Jakarta Persistence annotations to define the table structure and column mappings for pocket IDs and account details.", "databaseName": "unknown", "tablesAccessed": [ "m_pocket_accounts_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_pocket_accounts_mapping\")\npublic class PocketAccountMapping extends AbstractPersistableCustom {\n @Column(name = \"pocket_id\", length = 20, nullable = false)\n private Long pocketId;\n // ..." }, { "path": "org.apache.fineract.portfolio.self.pockets.domain.Pocket", "mechanism": "JPA", "name": "Pocket Entity", "description": "The class is a JPA Entity that maps directly to a relational database table using Jakarta Persistence annotations. It defines the table structure, column mappings, and unique constraints for the 'Pocket' domain object.", "databaseName": "m_pocket", "tablesAccessed": [ "m_pocket" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_pocket\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"app_user_id\" }, name = \"unique_app_user\") })\npublic class Pocket extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.portfolio.self.registration.domain.SelfServiceRegistration", "mechanism": "JPA", "name": "SelfServiceRegistration", "description": "The class is a JPA Entity mapped to the 'request_audit_table' database table. It uses Jakarta Persistence annotations to define the schema mapping, including column names, lengths, and nullability constraints. It establishes a Many-to-One relationship with the Client entity.", "databaseName": "unknown", "tablesAccessed": [ "request_audit_table" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"request_audit_table\")\npublic class SelfServiceRegistration extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"client_id\", nullable = false)\n private Client client;" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain", "mechanism": "JPA", "name": "ShareAccountChargePaidBy", "description": "The class is a JPA entity mapped to the 'm_share_account_charge_paid_by' table. It uses foreign keys to link to 'm_share_account_transaction' and 'm_share_account_charge'.", "databaseName": "m_share_account_charge_paid_by", "tablesAccessed": [ "m_share_account_charge_paid_by" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_share_account_charge_paid_by\")\npublic class ShareAccountChargePaidBy extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"share_transaction_id\", referencedColumnName = \"id\", nullable = false)\n private ShareAccountTransaction shareAccountTransaction;\n //..." }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccount", "mechanism": "JPA", "name": "ShareAccount", "description": "The class is a JPA Entity mapped to the 'm_share_account' table. It uses standard Jakarta Persistence annotations (@Entity, @Table, @Column, @ManyToOne, @OneToMany) to define the mapping to the relational database schema, including relationships with Client, ShareProduct, and child entities like ShareAccountTransaction.", "databaseName": "m_share_account", "tablesAccessed": [ "m_share_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "codeExample": "@Entity\n@Table(name = \"m_share_account\")\npublic class ShareAccount extends AbstractPersistableCustom {\n @ManyToOne\n @JoinColumn(name = \"client_id\")\n private Client client;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountCharge", "mechanism": "JPA", "name": "ShareAccountCharge Entity", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping directly to the 'm_share_account_charge' table. It uses @ManyToOne relationships for linking to ShareAccount and Charge entities.", "databaseName": "unknown", "tablesAccessed": [ "m_share_account_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with standard CRUD operations implied by the entity structure.", "transactionHandling": "JPA EntityTransaction (implicit in persistence context usage)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_share_account_charge\")\npublic class ShareAccountCharge extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountDividendDetails", "mechanism": "JPA", "name": "ShareAccountDividendDetails", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses annotations to define column mappings, constraints, and relationships.", "databaseName": "m_share_account_dividend_details", "tablesAccessed": [ "m_share_account_dividend_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_share_account_dividend_details\")\npublic class ShareAccountDividendDetails extends AbstractPersistableCustom {\n @Column(name = \"account_id\", nullable = false)\n private Long shareAccountId;" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountTransaction", "mechanism": "JPA", "name": "ShareAccountTransaction Entity", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping to the 'm_share_account_transactions' table. It uses standard JPA annotations for column mapping (@Column), relationships (@ManyToOne, @OneToMany), and cascading operations.", "databaseName": "m_share_account_transactions", "tablesAccessed": [ "m_share_account_transactions" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with relationship management", "transactionHandling": "JPA EntityTransaction (implicit via framework)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_share_account_transactions\")\npublic class ShareAccountTransaction extends AbstractPersistableCustom {\n @ManyToOne(optional = false)\n @JoinColumn(name = \"account_id\", referencedColumnName = \"id\", nullable = false)\n private ShareAccount shareAccount;" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler", "mechanism": "JPA", "name": "ShareAccountWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation. While it does not execute SQL directly, it orchestrates a write operation (redeem shares) via the ShareAccountWritePlatformService, which implies underlying database interaction managed by JPA or a similar persistence framework.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.redeemShares(jsonCommand.entityId(), jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service.ShareAccountWritePlatformServiceJpaRepositoryImpl", "mechanism": "JPA", "name": "ShareAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrappers) to perform CRUD operations on share accounts, share products, and notes. It relies on the persistence context to manage entity states and flush changes to the database.", "databaseName": "unknown", "tablesAccessed": [ "ShareAccount", "ShareProduct", "Note", "AccountNumberFormat" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, saveAndFlush, findOne) without explicit complex queries in this file.", "transactionHandling": "Implicitly handled by the service layer or repository wrappers, likely using Spring's @Transactional (though not explicitly annotated on this class, it is standard practice in this framework).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "ShareAccount account = this.accountDataSerializer.validateAndCreate(jsonCommand);\nthis.shareAccountRepository.saveAndFlush(account);" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain", "mechanism": "JPA", "name": "ShareProductDividendPayOutDetails", "description": "The class is a standard JPA Entity mapped to a specific database table. It uses Jakarta Persistence annotations to define the schema mapping, including column definitions and relationships.", "databaseName": "unknown", "tablesAccessed": [ "m_share_product_dividend_pay_out" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_share_product_dividend_pay_out\")\npublic class ShareProductDividendPayOutDetails extends AbstractAuditableCustom {" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain", "mechanism": "JPA", "name": "ShareProductMarketPrice", "description": "The class is a JPA Entity mapped to a relational database table. It uses annotations to define the table name, column mappings, and relationships (ManyToOne) to other entities.", "databaseName": "m_share_product_market_price", "tablesAccessed": [ "m_share_product_market_price" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "JDBC (via JPA provider)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_share_product_market_price\")\npublic class ShareProductMarketPrice extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain.ShareProduct", "mechanism": "JPA", "name": "m_share_product", "description": "The class is a JPA Entity mapped to the 'm_share_product' table. It uses standard Jakarta Persistence annotations to define column mappings, relationships (OneToMany for market prices, ManyToMany for charges), and constraints.", "databaseName": "unknown", "tablesAccessed": [ "m_share_product", "m_share_product_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings", "transactionHandling": "JPA EntityTransaction", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_share_product\")\npublic class ShareProduct extends AbstractAuditableCustom {\n @Column(name = \"name\", nullable = false, unique = true)\n private String name;\n // ...\n}" }, { "path": "org.apache.fineract.portfolio.shareproducts.handler", "mechanism": "JPA", "name": "ShareProductWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, implying that the underlying service method `deleteShareProductDividend` performs database write operations (likely via JPA or JDBC) that need to be atomic.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareProductWritePlatformService.deleteShareProductDividend(jsonCommand.entityId());\n }" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxComponent", "mechanism": "JPA", "name": "TaxComponent Entity", "description": "The class is a JPA Entity mapped to the 'm_tax_component' table. It uses Jakarta Persistence annotations to define the schema mapping, including columns for name, percentage, and account IDs. It manages relationships with 'TaxComponentHistory' (One-to-Many) and 'GLAccount' (Many-to-One).", "databaseName": "m_tax_component", "tablesAccessed": [ "m_tax_component", "m_tax_component_history", "acc_gl_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings with relationship traversal", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_tax_component\")\npublic class TaxComponent extends AbstractAuditableCustom {\n @Column(name = \"percentage\", scale = 6, precision = 19, nullable = false)\n private BigDecimal percentage;\n @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)\n @JoinColumn(name = \"tax_component_id\", referencedColumnName = \"id\", nullable = false)\n private Set taxComponentHistories = new HashSet<>();\n}" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxComponentHistory", "mechanism": "JPA", "name": "TaxComponentHistory", "description": "This class is a JPA entity mapped to the 'm_tax_component_history' table. It defines columns for percentage, start_date, and end_date.", "databaseName": "unknown", "tablesAccessed": [ "m_tax_component_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_tax_component_history\")\npublic class TaxComponentHistory extends AbstractAuditableCustom {" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxGroup", "mechanism": "JPA", "name": "TaxGroup", "description": "The class is a JPA Entity annotated with @Entity and @Table, mapping it to the 'm_tax_group' table. It manages a relationship with the 'm_tax_group_mappings' table (implied by the OneToMany relationship) via the TaxGroupMappings entity.", "databaseName": "m_tax_group", "tablesAccessed": [ "m_tax_group", "m_tax_group_mappings" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA entity traversal and state management.", "transactionHandling": "JPA EntityTransaction (likely managed by Spring container in service layer)", "protocol": "JPA / JDBC", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_tax_group\")\npublic class TaxGroup extends AbstractAuditableCustom {\n @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = \"taxGroup\")\n private Set taxGroupMappings = new HashSet<>();" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxGroupMappings", "mechanism": "JPA", "name": "TaxGroupMappings", "description": "The class is a JPA entity mapped to the 'm_tax_group_mappings' table. It uses Jakarta Persistence annotations to define the table mapping and relationships.", "databaseName": "m_tax_group_mappings", "tablesAccessed": [ "m_tax_group_mappings" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_tax_group_mappings\")\npublic class TaxGroupMappings extends AbstractAuditableCustom {" }, { "path": "org.apache.fineract.spm.domain", "mechanism": "JPA", "name": "Component", "description": "The class is a JPA Entity mapped to the 'm_survey_components' table. It uses annotations to define column mappings and relationships.", "databaseName": "m_survey_components", "tablesAccessed": [ "m_survey_components" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for standard CRUD operations.", "transactionHandling": "JPA EntityTransaction (managed by container)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_survey_components\")\npublic class Component extends AbstractPersistableCustom {\n @ManyToOne(fetch = FetchType.LAZY)\n @JoinColumn(name = \"survey_id\")\n private Survey survey;" }, { "path": "org.apache.fineract.spm.domain.LookupTable", "mechanism": "JPA", "name": "LookupTable", "description": "The class is a JPA Entity mapped to the 'm_survey_lookup_tables' table. It uses standard Jakarta Persistence annotations to define the table mapping, column constraints (length, precision, scale), and relationships (ManyToOne with Survey).", "databaseName": "unknown", "tablesAccessed": [ "m_survey_lookup_tables" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Entity\n@Table(name = \"m_survey_lookup_tables\")\npublic class LookupTable extends AbstractPersistableCustom {\n @Column(name = \"score\", precision = 5, scale = 2)\n private Double score;\n}" }, { "path": "org.apache.fineract.spm.domain.Question", "mechanism": "JPA", "name": "Question", "description": "The class is a JPA entity mapped to the 'm_survey_questions' table. It defines columns for component key, key, text, description, and sequence number. It also manages foreign key relationships to the Survey entity and a collection of Response entities.", "databaseName": "m_survey_questions", "tablesAccessed": [ "m_survey_questions" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA (Jakarta Persistence)", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_survey_questions\")\npublic class Question extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.spm.domain.Response", "mechanism": "JPA", "name": "Response", "description": "The class is a JPA entity mapped to the 'm_survey_responses' table. It uses Jakarta Persistence annotations to define the table mapping, column definitions (including length and precision), and the Many-to-One relationship with the Question entity.", "databaseName": "m_survey_responses", "tablesAccessed": [ "m_survey_responses" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_survey_responses\")\npublic class Response extends AbstractPersistableCustom {\n @ManyToOne(fetch = FetchType.LAZY)\n @JoinColumn(name = \"question_id\")\n private Question question;" }, { "path": "org.apache.fineract.spm.domain.Scorecard", "mechanism": "JPA", "name": "Scorecard", "description": "The class is a JPA Entity mapped to the 'm_survey_scorecards' table. It defines the schema for storing survey scores, including foreign keys to Survey, Question, Response, AppUser, and Client tables.", "databaseName": "m_survey_scorecards", "tablesAccessed": [ "m_survey_scorecards" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA/Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_survey_scorecards\")\npublic class Scorecard extends AbstractPersistableCustom {\n @ManyToOne(fetch = FetchType.LAZY)\n @JoinColumn(name = \"survey_id\")\n private Survey survey;\n // ..." }, { "path": "org.apache.fineract.spm.domain.Survey", "mechanism": "JPA", "name": "Survey", "description": "The class is a JPA entity mapped to the 'm_surveys' table. It defines the schema for storing survey data and manages relationships with 'Component' and 'Question' entities via OneToMany mappings.", "databaseName": "m_surveys", "tablesAccessed": [ "m_surveys" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_surveys\")\npublic class Survey extends AbstractPersistableCustom { ... }" }, { "path": "org.apache.fineract.template.domain", "mechanism": "JPA", "name": "TemplateMapper", "description": "The class is a JPA Entity mapped to the 'm_templatemappers' database table using Jakarta Persistence annotations. It maps class fields to specific database columns.", "databaseName": "unknown", "tablesAccessed": [ "m_templatemappers" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard ORM entity mapping without explicit queries in this file.", "transactionHandling": "Implicitly handled by the JPA provider/container context.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_templatemappers\")\npublic class TemplateMapper extends AbstractPersistableCustom {\n @Column(name = \"mapperorder\")\n private int mapperorder;" }, { "path": "org.apache.fineract.template.domain.Template", "mechanism": "JPA", "name": "Template", "description": "The class is a JPA entity mapped to the 'm_template' table. It uses standard JPA annotations to define column mappings, unique constraints, and relationships. Specifically, it defines a One-to-Many relationship with 'TemplateMapper' using a join table 'm_template_m_templatemappers'.", "databaseName": "m_template", "tablesAccessed": [ "m_template", "m_template_m_templatemappers" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM mappings for CRUD operations", "transactionHandling": "JPA EntityTransaction (managed by container/context)", "protocol": "JPA 2.x / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_template\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"unq_name\") })\npublic class Template extends AbstractPersistableCustom {\n @Column(name = \"name\", nullable = false, unique = true)\n private String name;\n @OneToMany(targetEntity = TemplateMapper.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)\n @JoinTable(name = \"m_template_m_templatemappers\"...)\n private List mappers;\n}" }, { "path": "org.apache.fineract.template.service", "mechanism": "JPA", "name": "TemplateRepository", "description": "This interface defines service-level operations that delegate to a persistence layer (likely JPA/Hibernate based on the domain entities) to perform CRUD operations on Template data.", "databaseName": "unknown", "tablesAccessed": [ "Template" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and filtering by entity/type.", "transactionHandling": "Likely handled by Spring @Transactional in the implementation class.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "n/a" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "JPA", "name": "PasswordValidationPolicy", "description": "The class is a JPA Entity mapped to the 'm_password_validation_policy' table. It uses annotations to define the table name and column constraints (nullability).", "databaseName": "m_password_validation_policy", "tablesAccessed": [ "m_password_validation_policy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_password_validation_policy\")\npublic class PasswordValidationPolicy extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.useradministration.domain.AppUser", "mechanism": "JPA", "name": "AppUser Entity", "description": "The class is a JPA Entity mapped to the 'm_appuser' table. It uses standard Jakarta Persistence annotations to define columns, constraints, and relationships (ManyToOne with Office/Staff, ManyToMany with Role, OneToMany with AppUserClientMapping).", "databaseName": "m_appuser", "tablesAccessed": [ "m_appuser", "m_appuser_role", "m_office", "m_staff", "m_appuser_client_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM-based CRUD operations managed by the persistence context.", "transactionHandling": "Implicitly handled by the service layer invoking this entity (likely Spring @Transactional).", "protocol": "JPA 3.0 / Hibernate", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_appuser\", uniqueConstraints = @UniqueConstraint(columnNames = { \"username\" }, name = \"username_org\"))\npublic class AppUser extends AbstractPersistableCustom implements PlatformUser { ... }" }, { "path": "org.apache.fineract.useradministration.domain.AppUserClientMapping", "mechanism": "JPA", "name": "AppUserClientMapping", "description": "The class is a JPA Entity that maps directly to a relational database table. It uses annotations to define the table name and column relationships (foreign keys) to other entities.", "databaseName": "m_selfservice_user_client_mapping", "tablesAccessed": [ "m_selfservice_user_client_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Entity\n@Table(name = \"m_selfservice_user_client_mapping\")\npublic class AppUserClientMapping extends AbstractPersistableCustom {\n @ManyToOne(optional = false, cascade = CascadeType.ALL)\n @JoinColumn(name = \"appuser_id\", nullable = false)\n private AppUser appUser;" }, { "path": "org.apache.fineract.useradministration.domain.AppUserPreviousPassword", "mechanism": "JPA", "name": "AppUserPreviousPassword", "description": "This class is a JPA Entity that maps directly to a relational database table. It uses Jakarta Persistence annotations to define the table name and column mappings.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser_previous_password" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_appuser_previous_password\")\npublic class AppUserPreviousPassword extends AbstractPersistableCustom {" }, { "path": "org.apache.fineract.useradministration.domain.Permission", "mechanism": "JPA", "name": "Permission", "description": "The class is a JPA Entity mapped to the 'm_permission' table. It uses Jakarta Persistence annotations to define the table mapping and column constraints.", "databaseName": "m_permission", "tablesAccessed": [ "m_permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "JPA ENTITYTRANSACTION", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_permission\")\npublic class Permission extends AbstractPersistableCustom implements Serializable {" }, { "path": "org.apache.fineract.useradministration.domain.Role", "mechanism": "JPA", "name": "Role Entity", "description": "The class is a JPA entity annotated with @Entity and @Table. It maps to the 'm_role' table in the database. It uses a Many-To-Many relationship with the Permission entity, managed via a join table named 'm_role_permission'.", "databaseName": "m_role", "tablesAccessed": [ "m_role", "m_role_permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA ORM mapping with Eager fetching for permissions.", "transactionHandling": "Implicitly handled by the persistence context/container (likely Spring @Transactional in service layer).", "protocol": "JDBC/JPA", "connectionInfo": "n/a", "codeExample": "@Entity\n@Table(name = \"m_role\", uniqueConstraints = { @UniqueConstraint(columnNames = { \"name\" }, name = \"unq_name\") })\npublic class Role extends AbstractPersistableCustom implements Serializable {\n @ManyToMany(fetch = FetchType.EAGER)\n @JoinTable(name = \"m_role_permission\", joinColumns = @JoinColumn(name = \"role_id\"), inverseJoinColumns = @JoinColumn(name = \"permission_id\"))\n private Set permissions = new HashSet<>();\n}" }, { "path": "fineract-db/server_collation.cnf", "mechanism": "OTHER", "name": "MySQL Server Configuration", "description": "This file is a direct configuration for the MySQL database server itself, rather than application code that integrates with a database. It establishes the character set and collation rules for the server instance and client connections.", "databaseName": "Global Server Instance", "tablesAccessed": [], "operationType": [ "ADMIN" ], "queryPatterns": "Configuration directives", "transactionHandling": "n/a", "protocol": "MySQL", "connectionInfo": "n/a", "codeExample": "[mysqld]\ncollation-server=utf8mb4_unicode_ci\ninit-connect='SET NAMES utf8mb4'" }, { "path": "kubernetes/fineractmysql-deployment.yml", "mechanism": "OTHER", "name": "fineractmysql", "description": "This file does not connect to a database via an application layer but rather deploys the MariaDB database server itself within a Kubernetes cluster. It configures the container image, ports, storage volumes, and initialization scripts required to run the database service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "ADMIN", "OTHER" ], "queryPatterns": "Infrastructure deployment, no application queries performed directly in this file.", "transactionHandling": "n/a", "protocol": "MariaDB 10.9", "connectionInfo": "Service: fineractmysql, Port: 3306", "codeExample": "containers:\n - image: mariadb:10.9\n name: mysql\n ports:\n - containerPort: 3306\n name: fineractmysql" }, { "path": "org.apache.fineract.accounting.accrual.handler.ExecutePeriodicAccrualCommandHandler", "mechanism": "OTHER", "name": "AccrualAccountingWritePlatformService", "description": "The class defines a transactional boundary using Spring's @Transactional annotation, implying interaction with a database via the injected service, although no direct SQL or repository calls are made in this file.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.executeLoansPeriodicAccrual(command);\n}" }, { "path": "org.apache.fineract.accounting.closure.handler.CreateGLClosureCommandHandler", "mechanism": "OTHER", "name": "GLClosureWritePlatformService", "description": "This class defines the transaction boundary for database operations using Spring's `@Transactional` annotation, although the direct data access logic is delegated to the injected `GLClosureWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createGLClosure(command);\n}" }, { "path": "org.apache.fineract.accounting.closure.handler.UpdateGLClosureCommandHandler", "mechanism": "OTHER", "name": "Transaction Management", "description": "The class defines a transactional boundary using Spring's @Transactional annotation, ensuring that the GL closure update operation performed by the injected service is atomic. While it does not execute SQL directly, it manages the database transaction context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateGLClosure(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.handler.DeleteFinancialActivityAccountCommandHandler", "mechanism": "OTHER", "name": "FinancialActivityAccountWritePlatformService", "description": "This class orchestrates a database write operation (deletion) by defining a transaction boundary using Spring's `@Transactional` annotation and delegating the persistence logic to a service component.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteGLAccountActivityMapping(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.accounting.glaccount.handler", "mechanism": "OTHER", "name": "GLAccountWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation, although the direct database interaction (SQL/ORM) is delegated to the `GLAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createGLAccount(command);\n}" }, { "path": "org.apache.fineract.accounting.glaccount.handler", "mechanism": "OTHER", "name": "GLAccountWritePlatformService", "description": "The class manages the transaction boundary for a database write operation using Spring's `@Transactional` annotation, delegating the actual persistence logic to the `GLAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "GLACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteGLAccount(command.entityId());\n}" }, { "path": "org.apache.fineract.accounting.provisioning.handler", "mechanism": "OTHER", "name": "ProvisioningEntriesWritePlatformService", "description": "The class uses Spring's @Transactional annotation to manage database transactions for the command processing, delegating the actual persistence logic to the ProvisioningEntriesWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {" }, { "path": "org.apache.fineract.accounting.rule.handler", "mechanism": "OTHER", "name": "Transaction Management", "description": "The class uses Spring's `@Transactional` annotation to define transaction boundaries for the command processing, ensuring that the underlying service operations are executed within a database transaction.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {" }, { "path": "org.apache.fineract.accounting.rule.handler.UpdateAccountingRuleCommandHandler", "mechanism": "OTHER", "name": "AccountingRuleWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation, ensuring that the database operations performed by the delegated service (AccountingRuleWritePlatformService) are executed within a transaction context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateAccountingRule(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.adhocquery.handler.DeleteAdHocCommandHandler", "mechanism": "OTHER", "name": "AdHocWritePlatformService", "description": "The class manages the transaction boundary for a database write operation via Spring's @Transactional annotation, delegating the actual persistence logic to the AdHocWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.deleteAdHocQuery(command.entityId());\n }" }, { "path": "org.apache.fineract.cob.service", "mechanism": "OTHER", "name": "ConfigJobParameterService", "description": "The class uses Spring's `@Transactional` annotation to define a transaction boundary for the database update operation. While the direct SQL/ORM calls are likely inside the injected `ConfigJobParameterService`, this handler explicitly manages the transaction lifecycle for the 'UPDATE' action.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_BUSINESS_STEP" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(JsonCommand command) ..." }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.handler", "mechanism": "OTHER", "name": "AccountNumberFormatWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation, although the direct database manipulation (SQL/ORM) is delegated to the injected service layer.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.accountNumberFormatWritePlatformService.deleteAccountNumberFormat(command.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler", "mechanism": "OTHER", "name": "EmailCampaignWritePlatformService", "description": "The class manages the transaction boundary for database operations using Spring's @Transactional annotation, while delegating the actual data access logic to the EmailCampaignWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "EMAIL_CAMPAIGN" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.emailCampaignWritePlatformService.update(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler", "mechanism": "OTHER", "name": "EmailConfigurationWritePlatformService", "description": "The class manages database transactions using Spring's @Transactional annotation while delegating the actual persistence logic to a service layer. The @CommandType annotation indicates interaction with the 'EMAIL_CONFIGURATION' entity.", "databaseName": "unknown", "tablesAccessed": [ "EMAIL_CONFIGURATION" ], "operationType": [ "WRITE" ], "queryPatterns": "Service delegation within transaction", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.update(command);\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler", "mechanism": "OTHER", "name": "EmailWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions, although the direct database access logic (SQL/JPA) is delegated to the `EmailWritePlatformService`. It ensures that the operation performed by the service is atomic.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.create(command);\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.handler.CreateEmailCampaignCommandHandler", "mechanism": "OTHER", "name": "EmailCampaignWritePlatformService", "description": "The class integrates with the database indirectly by managing the transaction boundary for the write operation. It uses Spring's `@Transactional` annotation to ensure that the changes made by the `EmailCampaignWritePlatformService` are committed or rolled back atomically.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.emailCampaignWritePlatformService.create(command);\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.handler", "mechanism": "OTHER", "name": "SmsCampaignWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation. While it does not contain direct SQL or JPA calls, it defines the transactional boundary for the `delete` operation which is delegated to the `SmsCampaignWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "SMSCAMPAIGN" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.smsCampaignWritePlatformService.delete(command.entityId());\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.handler", "mechanism": "OTHER", "name": "SmsCampaignWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's `@Transactional` annotation, although the direct data access logic is delegated to the `SmsCampaignWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "SMSCAMPAIGN" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.smsCampaignWritePlatformService.reactivateSmsCampaign(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.handler", "mechanism": "OTHER", "name": "SmsCampaignWritePlatformService", "description": "The class orchestrates database updates by delegating to a service layer within a Spring `@Transactional` boundary. While it does not contain direct SQL or repository calls, it defines the transaction scope for the database write operation performed by the injected service.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.smsCampaignWritePlatformService.update(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.handler.ActivateSmsCampaignCommandHandler", "mechanism": "OTHER", "name": "SmsCampaignWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions, ensuring that the activation operation performed by the `SmsCampaignWritePlatformService` is atomic. While it does not contain direct SQL or ORM calls, it defines the transaction boundary for database writes.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.smsCampaignWritePlatformService.activateSmsCampaign(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.codes.handler.CreateCodeCommandHandler", "mechanism": "OTHER", "name": "CodeWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation. While it does not contain direct SQL or Repository calls, it defines the transaction boundary for the database write operation performed by the delegated `CodeWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.createCode(command);\n }" }, { "path": "org.apache.fineract.infrastructure.codes.handler.CreateCodeValueCommandHandler", "mechanism": "OTHER", "name": "CodeValueWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation, delegating the actual database write operation to the CodeValueWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "CODEVALUE" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.createCodeValue(command);\n }" }, { "path": "org.apache.fineract.infrastructure.codes.handler.DeleteCodeValueCommandHandler", "mechanism": "OTHER", "name": "CodeValueWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, although the specific database operations (SQL/JPA) are delegated to the injected `CodeValueWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.deleteCodeValue(command.entityId(), command.subentityId());\n }" }, { "path": "org.apache.fineract.infrastructure.core.service.migration", "mechanism": "OTHER", "name": "Liquibase Migration Filter", "description": "This class is a utility for the Liquibase database migration framework. While it does not execute SQL or connect to a database directly, it controls which migration files (changelogs) are applied to the database schema.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "Liquibase", "connectionInfo": "n/a", "codeExample": "public boolean include(String changeLogPath) {\n return changeLogPath.endsWith(\"module-changelog-master.xml\");\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.handler", "mechanism": "OTHER", "name": "OrganisationCreditBureauWritePlatflormService", "description": "The class manages the transaction boundary for database operations using Spring's @Transactional annotation, although the direct data access logic is delegated to the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.updateCreditBureau(command);\n }" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class manages database transactions via the Spring `@Transactional` annotation. While it does not contain direct SQL or ORM calls, it defines the transaction boundary for the `updateDatatableEntryOneToMany` operation performed by the injected `ReadWriteNonCoreDataService`.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateDatatableEntryOneToMany(...);\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation, but delegates the actual data access logic to the `ReadWriteNonCoreDataService`. It does not contain direct SQL or ORM calls itself.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteDatatableEntry(command.entityName(), command.entityId(), command.subentityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class defines a database transaction boundary using Spring's @Transactional annotation, although the direct database manipulation is delegated to the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return writePlatformService.createDatatable(command);\n }" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class manages a database transaction using Spring's `@Transactional` annotation while delegating the actual data persistence logic to the `ReadWriteNonCoreDataService`. It does not contain direct SQL or ORM calls but defines the transaction boundary for database operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n // ...\n this.writePlatformService.updateDatatable(datatableName, command);\n // ...\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class orchestrates database operations by delegating to the ReadWriteNonCoreDataService within a Spring-managed transaction. While the specific persistence mechanism (likely JDBC or DDL execution given the context of 'Datatables') is hidden in the service, this handler explicitly manages the transaction boundary for the write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n this.writePlatformService.registerDatatable(command);\n return new CommandProcessingResultBuilder()...\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class manages database transactions via Spring's `@Transactional` annotation while delegating the actual data modification to the `ReadWriteNonCoreDataService`. While it does not contain direct SQL or ORM calls, it defines the transaction boundary for database write operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteDatatableEntries(command.entityName(), command.entityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler.CreateDatatableEntryCommandHandler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class manages database transactions via Spring's `@Transactional` annotation and delegates the actual data persistence logic to the `ReadWriteNonCoreDataService`. While it does not contain direct SQL or ORM calls, it defines the transaction boundary for a database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return writePlatformService.createNewDatatableEntry(command.entityName(), command.entityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.handler.UpdateOneToOneDatatableEntryCommandHandler", "mechanism": "OTHER", "name": "ReadWriteNonCoreDataService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation and delegates the actual database write operation to the `ReadWriteNonCoreDataService`. While it does not contain direct SQL or repository calls, it controls the transaction for the data modification.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n final CommandProcessingResult commandProcessingResult = this.writePlatformService.updateDatatableEntryOneToOne(command.entityName(),\n command.entityId(), command);\n // ...\n}" }, { "path": "org.apache.fineract.infrastructure.entityaccess.handler.UpdateEntityToEntityMappingCommandHandler", "mechanism": "OTHER", "name": "FineractEntityAccessWriteService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. It delegates the actual database write operation to the `FineractEntityAccessWriteService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.fineractEntityAccessWriteService.updateEntityToEntityMapping(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.event.external.handler.ExternalEventConfigurationUpdateHandler", "mechanism": "OTHER", "name": "ExternalEventConfigurationWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's `@Transactional` annotation, delegating the actual persistence logic to the `ExternalEventConfigurationWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(@NotNull final JsonCommand command) {\n return writePlatformService.updateConfigurations(command);\n}" }, { "path": "org.apache.fineract.infrastructure.event.external.jobs.PurgeExternalEventsConfig", "mechanism": "OTHER", "name": "JobRepository", "description": "The class configures a Spring Batch Job which interacts with the database via the Spring Batch `JobRepository`. This repository is responsible for persisting job execution metadata, such as job instances, execution contexts, and step execution statuses. While this class does not contain direct SQL, it wires up the infrastructure that performs database operations for batch management.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal repository operations (CRUD on batch metadata tables)", "transactionHandling": "Spring PlatformTransactionManager used in Step configuration", "protocol": "unknown", "connectionInfo": "configured via JobRepository and TransactionManager beans", "codeExample": "new JobBuilder(JobName.PURGE_EXTERNAL_EVENTS.name(), jobRepository)" }, { "path": "org.apache.fineract.infrastructure.hooks.handler", "mechanism": "OTHER", "name": "HookWritePlatformService", "description": "The class manages a database transaction via the Spring @Transactional annotation, wrapping a delete operation performed by the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteHook(command.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.hooks.handler.CreateHookCommandHandler", "mechanism": "OTHER", "name": "HookWritePlatformService", "description": "The class defines the transaction boundary for database write operations using Spring's transaction management, although the direct database access logic resides in the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createHook(command);\n }" }, { "path": "org.apache.fineract.infrastructure.hooks.handler.UpdateHookCommandHandler", "mechanism": "OTHER", "name": "HookWritePlatformService", "description": "This class defines the transaction boundary for database operations using Spring's @Transactional annotation, although the direct database access is delegated to the injected HookWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateHook(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.jobs.filter", "mechanism": "OTHER", "name": "LoanCOBFilterHelper / PlatformTransactionManager", "description": "The class manages transaction boundaries using Spring's PlatformTransactionManager to suspend the current transaction. It delegates actual database read (calculating loan IDs) and write (executing inline COB) operations to the injected LoanCOBFilterHelper.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates complex logic to helper; likely involves selecting loan status and updating loan records.", "transactionHandling": "Spring TransactionTemplate with PROPAGATION_NOT_SUPPORTED to suspend existing transactions during the check.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "TransactionTemplate tr = new TransactionTemplate(transactionManager);\ntr.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);\nreturn tr.execute(status -> {\n // ...\n List result = helper.calculateRelevantLoanIds(relativeUrl);\n if (!result.isEmpty() && helper.isLoanBehind(result)) {\n helper.executeInlineCob(result);\n }\n // ...\n});" }, { "path": "org.apache.fineract.infrastructure.jobs.service", "mechanism": "OTHER", "name": "SchedularWritePlatformService", "description": "This class manages a database transaction boundary using Spring's `@Transactional` annotation with `READ_COMMITTED` isolation. While it does not execute SQL directly, it delegates to `schedularService` which likely performs database writes or checks to manage job state.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional(isolation = Isolation.READ_COMMITTED)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional(isolation = Isolation.READ_COMMITTED)\npublic boolean veto(Trigger trigger, JobExecutionContext context) { ... }" }, { "path": "org.apache.fineract.infrastructure.jobs.service.increasedateby1day.increasebusinessdateby1day", "mechanism": "OTHER", "name": "JobRepository", "description": "The class configures a Spring Batch Job which relies on the injected JobRepository. The JobRepository is responsible for persisting job execution metadata (job instances, executions, steps, and contexts) to the underlying database.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal repository operations", "transactionHandling": "Spring PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "new StepBuilder(JobName.INCREASE_BUSINESS_DATE_BY_1_DAY.name(), jobRepository)" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.handler", "mechanism": "OTHER", "name": "ReportMailingJobWritePlatformService", "description": "The class defines the transaction boundary for a database update operation using Spring's @Transactional annotation. While it does not execute SQL or JPA queries directly, it orchestrates the transaction for the underlying service which interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.reportMailingJobWritePlatformService.updateReportMailingJob(jsonCommand.entityId(), jsonCommand);\n}" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.handler", "mechanism": "OTHER", "name": "ReportMailingJobWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation, although the direct database manipulation is delegated to the injected `ReportMailingJobWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.reportMailingJobWritePlatformService.deleteReportMailingJob(jsonCommand.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.sms.handler", "mechanism": "OTHER", "name": "SmsWritePlatformService", "description": "The class manages the transaction boundary for database operations using Spring's @Transactional annotation, delegating the actual persistence logic to the SmsWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "SMS" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates update logic to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.update(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.infrastructure.survey.handler.UpdateLikelihoodCommandHandler", "mechanism": "OTHER", "name": "WriteLikelihoodService", "description": "The class manages database transactions using Spring's @Transactional annotation, defining a transaction boundary for the update operation. The actual database interaction logic is delegated to the injected WriteLikelihoodService.", "databaseName": "unknown", "tablesAccessed": [ "LIKELIHOOD" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.update(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.interoperation.handler", "mechanism": "OTHER", "name": "InteropService", "description": "The class manages database transactions via the Spring @Transactional annotation, ensuring that the operations performed by the delegated InteropService are atomic. While it does not contain direct SQL or Repository calls, it defines the transaction boundary for the database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n // ... parsing logic ...\n return this.interopService.registerAccountIdentifier(idType, idValue, subIdOrType, command);\n}" }, { "path": "org.apache.fineract.interoperation.handler", "mechanism": "OTHER", "name": "InteropService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates a database write operation ('CREATE') by delegating to the `InteropService` within a transaction.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.interopService.createQuote(command);\n }" }, { "path": "org.apache.fineract.interoperation.handler.CreateInteropRequestHandler", "mechanism": "OTHER", "name": "InteropService", "description": "This class defines a transactional boundary using Spring's @Transactional annotation. While it does not execute SQL or JPA queries directly, it orchestrates database operations performed by the injected InteropService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.interopService.createTransactionRequest(command);\n}" }, { "path": "org.apache.fineract.mix.handler", "mechanism": "OTHER", "name": "MixTaxonomyMappingWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation, although the direct database manipulation is delegated to the injected service. It acts as a transactional boundary for the 'XBRLMAPPING' update operation.", "databaseName": "unknown", "tablesAccessed": [ "XBRLMAPPING" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writeTaxonomyService.updateMapping(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.organisation.holiday.handler", "mechanism": "OTHER", "name": "HolidayWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's @Transactional annotation, but delegates the actual data access and modification logic to the HolidayWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.holidayWritePlatformService.updateHoliday(command);\n}" }, { "path": "org.apache.fineract.organisation.monetary.handler.UpdateCurrencyCommandHandler", "mechanism": "OTHER", "name": "CurrencyWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to define a transaction boundary. While it does not execute SQL or call a repository directly, it delegates to `CurrencyWritePlatformService` which performs the actual database persistence operations for currency updates.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateAllowedCurrencies(command);\n}" }, { "path": "org.apache.fineract.organisation.office.handler.CreateOfficeCommandHandler", "mechanism": "OTHER", "name": "OfficeWritePlatformService", "description": "The class manages database transaction boundaries using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it wraps the execution of the `OfficeWritePlatformService` in a transaction, implying that the service performs database write operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.createOffice(command);\n }" }, { "path": "org.apache.fineract.organisation.provisioning.handler", "mechanism": "OTHER", "name": "ProvisioningCriteriaWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates the write operation which is performed by the injected `ProvisioningCriteriaWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.provisioningCriteriaWritePlatformService.createProvisioningCriteria(jsonCommand);\n}" }, { "path": "org.apache.fineract.organisation.provisioning.handler", "mechanism": "OTHER", "name": "ProvisioningCriteriaWritePlatformService", "description": "The class manages database transaction boundaries using Spring's @Transactional annotation, ensuring that the delegated service operations are executed within a transaction context, although it does not perform direct SQL or repository calls itself.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {" }, { "path": "org.apache.fineract.organisation.provisioning.handler", "mechanism": "OTHER", "name": "ProvisioningCriteriaWritePlatformService", "description": "The class manages database transactions using Spring's @Transactional annotation, ensuring the delete operation performed by the delegate service is atomic. While it does not contain direct SQL or Repository calls, it defines the transaction boundary for database writes.", "databaseName": "unknown", "tablesAccessed": [ "PROVISIONCRITERIA" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.provisioningCriteriaWritePlatformService.deleteProvisioningCriteria(jsonCommand.entityId());\n }" }, { "path": "org.apache.fineract.organisation.provisioning.handler", "mechanism": "OTHER", "name": "ProvisioningCategoryWritePlatformService", "description": "The class manages database transactions using Spring's @Transactional annotation, delegating the actual data persistence logic to the ProvisioningCategoryWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.provisioningCategoryWritePlatformService.createProvisioningCateogry(jsonCommand);\n }" }, { "path": "org.apache.fineract.organisation.staff.handler.CreateStaffCommandHandler", "mechanism": "OTHER", "name": "StaffWritePlatformService", "description": "The class orchestrates database interactions by defining a transaction boundary using Spring's `@Transactional` annotation, but delegates the specific data access logic to the `StaffWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createStaff(command);\n}" }, { "path": "org.apache.fineract.portfolio.account.handler.CreateAccountTransferCommandHandler", "mechanism": "OTHER", "name": "AccountTransfersWritePlatformService", "description": "This class defines a transaction boundary using Spring's `@Transactional` annotation, but delegates the actual database interaction to the `AccountTransfersWritePlatformService`. While it does not contain direct SQL or ORM calls, it controls the transaction context for the database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.create(command);\n}" }, { "path": "org.apache.fineract.portfolio.calendar.handler.CreateCalendarCommandHandler", "mechanism": "OTHER", "name": "CalendarWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation but delegates the actual data access and persistence logic to the `CalendarWritePlatformService`. It does not contain direct SQL or ORM calls itself.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createCalendar(command);\n }" }, { "path": "org.apache.fineract.portfolio.client.handler", "mechanism": "OTHER", "name": "ClientWritePlatformService", "description": "This class defines the transaction boundary using Spring's @Transactional annotation, but delegates the actual database operations to the ClientWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.clientWritePlatformService.undoRejection(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.client.handler", "mechanism": "OTHER", "name": "ClientChargeWritePlatformService", "description": "This class defines a transactional boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it orchestrates the write operation by delegating to `ClientChargeWritePlatformService`, which performs the actual database persistence.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.addCharge(command.getClientId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.client.handler", "mechanism": "OTHER", "name": "ClientChargeWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it delegates to `ClientChargeWritePlatformService` which performs the database write operation to waive the charge.", "databaseName": "unknown", "tablesAccessed": [ "m_client_charge" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.waiveCharge(command.getClientId(), command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.client.handler.DeleteClientChargeCommandHandler", "mechanism": "OTHER", "name": "ClientChargeWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation, delegating the actual persistence logic to the injected `ClientChargeWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteCharge(command.getClientId(), command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.client.handler.UpdateClientCommandHandler", "mechanism": "OTHER", "name": "ClientWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation, although the direct database access logic is delegated to the `ClientWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "CLIENT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.clientWritePlatformService.updateClient(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.collateral.handler", "mechanism": "OTHER", "name": "CollateralWritePlatformService", "description": "The class manages database transactions via Spring's `@Transactional` annotation but delegates the actual database modification logic to the `CollateralWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "COLLATERAL" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.collateralWritePlatformService.deleteCollateral(...);\n}" }, { "path": "org.apache.fineract.portfolio.collectionsheet.handler.UpdateCollectionSheetCommandHandler", "mechanism": "OTHER", "name": "CollectionSheetWritePlatformService", "description": "The class orchestrates database interactions by defining a transaction boundary using Spring's `@Transactional` annotation. While it does not contain direct SQL or JPA calls, it delegates to `CollectionSheetWritePlatformService` which performs the actual data persistence operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.collectionSheetWritePlatformService.updateCollectionSheet(command);\n }" }, { "path": "org.apache.fineract.portfolio.delinquency.handler", "mechanism": "OTHER", "name": "DelinquencyWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation, although the direct database manipulation is delegated to the `DelinquencyWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateDelinquencyRange(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.handler.CreateDelinquencyBucketCommandHandler", "mechanism": "OTHER", "name": "DelinquencyWritePlatformService", "description": "This class orchestrates database interactions by defining a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or call a repository directly, it delegates to `DelinquencyWritePlatformService` which performs the persistence operations.", "databaseName": "unknown", "tablesAccessed": [ "DELINQUENCY_BUCKET" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createDelinquencyBucket(command);\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.handler.DeleteDelinquencyRangeCommandHandler", "mechanism": "OTHER", "name": "DelinquencyWritePlatformService", "description": "The class manages the transaction boundary for a database write operation using Spring's `@Transactional` annotation, although the actual data access logic resides in the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteDelinquencyRange(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.floatingrates.handler.UpdateFloatingRateCommandHandler", "mechanism": "OTHER", "name": "FloatingRateWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation, delegating the actual data persistence to the FloatingRateWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "FLOATINGRATE (inferred from entity name)" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateFloatingRate(command);\n }" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "OTHER", "name": "GroupingTypesWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation, although the direct database operations are delegated to the GroupingTypesWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n final Long centerId = command.longValueOfParameterNamed(\"centerId\");\n return this.groupWritePlatformService.createGroup(centerId, command);\n}" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "OTHER", "name": "GroupRolesWritePlatformService", "description": "This class defines a transactional boundary using Spring's @Transactional annotation. While it does not execute SQL directly, it orchestrates a database write operation by delegating to the GroupRolesWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.groupRolesWritePlatformService.updateRole(command);\n}" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "OTHER", "name": "GroupingTypesWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation and delegates data modification logic to the `GroupingTypesWritePlatformService`. While it does not contain direct SQL or ORM calls, it orchestrates a database write operation via the service layer.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.disassociateGroupsToCenter(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "OTHER", "name": "GroupingTypesWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, delegating the actual database write operation (delete) to the injected `GroupingTypesWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.groupWritePlatformService.deleteGroup(command.entityId());\n }" }, { "path": "org.apache.fineract.portfolio.group.handler.UpdateGroupCommandHandler", "mechanism": "OTHER", "name": "GroupingTypesWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation, orchestrating database writes via the injected service.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.groupWritePlatformService.updateGroup(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "The class defines a database transaction boundary using Spring's @Transactional annotation. While it does not execute SQL directly, it manages the transaction for the underlying service layer which interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.undoApplicationApproval(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it orchestrates a write operation (loan approval) via the injected service layer within a transaction context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.approveApplication(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, but delegates the actual database interaction to the injected `LoanApplicationWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.submitApplication(command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "The class orchestrates a database transaction using Spring's `@Transactional` annotation, although the direct data access logic is delegated to the `LoanApplicationWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.applicantWithdrawsFromApplication(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "This class defines a transaction boundary using Spring's `@Transactional` annotation, but delegates the actual data access and persistence logic to the `LoanWritePlatformService`. While it does not contain direct SQL or Repository calls, it controls the transaction for a database write operation.", "databaseName": "unknown", "tablesAccessed": [ "m_loan" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.waiveInterestOnLoan(command.getLoanId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "This class manages database transactions using Spring's `@Transactional` annotation, although the direct database access logic (SQL/JPA) is delegated to the injected `LoanApplicationWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.approveGLIMLoanAppication(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanChargeWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation and delegates the actual database write operation (deletion) to the `LoanChargeWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_charge" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for deletion logic", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteLoanCharge(command.getLoanId(), command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanChargeWritePlatformService", "description": "The class defines a transactional boundary using Spring's @Transactional annotation and delegates the actual database write operation to the LoanChargeWritePlatformService. While it does not contain direct SQL or JPA calls, it orchestrates the persistence flow for the Loan Charge entity.", "databaseName": "unknown", "tablesAccessed": [ "LOANCHARGE" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateLoanCharge(command.getLoanId(), command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanChargeWritePlatformService", "description": "This class does not perform direct database operations (SQL/JPA) itself but defines a transaction boundary using Spring's `@Transactional` annotation. It delegates the actual data persistence logic to the `LoanChargeWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return writePlatformService.adjustmentForLoanCharge(...);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanChargeWritePlatformService", "description": "This class participates in database integration by defining the transaction boundary using Spring's `@Transactional` annotation, although the direct database operations are delegated to the `LoanChargeWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.payLoanCharge(command.getLoanId(), ...);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "This class defines a transaction boundary using Spring's `@Transactional` annotation, implying interaction with the database occurs within the called service method. While it does not contain direct SQL or Repository calls, it orchestrates a write operation (Disbursement) that persists state changes to the database via the injected `LoanWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.disburseGLIMLoan(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.AddAndDeleteLoanDisburseDetailsCommandHandler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "This class defines a transactional boundary using Spring's @Transactional annotation. It delegates the actual database operations to the LoanWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.addAndDeleteLoanDisburseDetails(command.getLoanId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.GLIMApplicationRejectionCommandHandler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's `@Transactional` annotation. While it does not execute SQL or access repositories directly, it orchestrates the transaction for the `LoanApplicationWritePlatformService` which performs the actual database writes.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.rejectGLIMApplicationApproval(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.LoanApplicationModificationCommandHandler", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "This class defines a transactional boundary using Spring's `@Transactional` annotation, orchestrating database writes by delegating to the `LoanApplicationWritePlatformService`. While it does not execute SQL directly, it controls the transaction for the database update operation.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.modifyApplication(command.getLoanId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.RemoveLoanOfficerCommandHandler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, implying database interactions occur within the called service method. It delegates the actual data persistence logic to `LoanWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.removeLoanOfficer(command.getLoanId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.UndoChargeOffLoanCommandHandler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "This class defines a database transaction boundary using Spring's @Transactional annotation, ensuring that the delegated service operation is executed within a transaction context, although it does not perform direct SQL or ORM operations itself.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return writePlatformService.undoChargeOff(command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.UndoGLIMLoanApplicationApproval", "mechanism": "OTHER", "name": "LoanApplicationWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to define a transaction boundary for the operation. While it does not execute SQL or JPA calls directly, it delegates to `LoanApplicationWritePlatformService` which performs the actual database writes.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.undoGLIMLoanApplicationApproval(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.UndoGLIMLoanDisbursalCommandHandler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions, although the direct data access logic is delegated to the `LoanWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.undoGLIMLoanDisbursal(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.handler.UpdateLoanDisburseDateCommandHandler", "mechanism": "OTHER", "name": "LoanWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it delegates to `LoanWritePlatformService` which performs the actual database write operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateDisbursementDateAndAmountForTranche(command.getLoanId(), command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.updateloanarrearsageing", "mechanism": "OTHER", "name": "Spring Batch Repository", "description": "The class configures Spring Batch components which implicitly interact with the database to persist job execution metadata (JobInstance, JobExecution, StepExecution) via the injected JobRepository. It also configures a PlatformTransactionManager to handle transactions during the batch step execution.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_INSTANCE", "BATCH_JOB_EXECUTION", "BATCH_STEP_EXECUTION" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Batch internal metadata management (CRUD on batch tables)", "transactionHandling": "Spring @Transactional via PlatformTransactionManager", "protocol": "JDBC (implied by Spring Batch)", "connectionInfo": "unknown", "codeExample": "new StepBuilder(JobName.UPDATE_LOAN_ARREARS_AGEING.name(), jobRepository)\n .tasklet(updateLoanArrearsAgeingTasklet(), transactionManager)" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.handler", "mechanism": "OTHER", "name": "LoanRescheduleRequestWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, wrapping the operations performed by the `LoanRescheduleRequestWritePlatformService`. While it does not execute SQL directly, it defines the transaction boundary for the database interactions.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.loanRescheduleRequestWritePlatformService.create(jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.loanproduct.productmix.handler", "mechanism": "OTHER", "name": "ProductMixWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's @Transactional annotation, while the actual data access and modification are delegated to the ProductMixWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "PRODUCTMIX" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.productMixWritePlatformService.updateProductMix(command.getProductId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.meeting.handler", "mechanism": "OTHER", "name": "MeetingWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, ensuring that the delegated service operation runs within a transaction context. The actual data access logic is performed by the injected `MeetingWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteMeeting(command.entityId());\n }" }, { "path": "org.apache.fineract.portfolio.meeting.handler.UpdateMeetingAttendanceCommandHandler", "mechanism": "OTHER", "name": "MeetingWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not contain direct SQL or ORM calls, it orchestrates database write operations by delegating to `MeetingWritePlatformService` within a transactional context.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.saveOrUpdateAttendance(command);\n}" }, { "path": "org.apache.fineract.portfolio.note.handler", "mechanism": "OTHER", "name": "NoteWritePlatformService", "description": "This class defines the transaction boundary for database write operations but delegates the actual data access to the NoteWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.createNote(command);\n}" }, { "path": "org.apache.fineract.portfolio.note.handler.UpdateNoteCommandHandler", "mechanism": "OTHER", "name": "NoteWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's `@Transactional` annotation, though the direct database access logic is delegated to the injected `NoteWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.updateNote(command);\n }" }, { "path": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.handler", "mechanism": "OTHER", "name": "RepaymentWithPostDatedChecksWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, ensuring that the update operation performed by the underlying service is atomic. While it does not execute SQL directly, it controls the transaction boundary for the database interaction.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.repaymentWithPostDatedChecksWritePlatformService.updatePostDatedChecks(command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation, delegating the actual data persistence and modification logic to the injected `DepositAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "FIXEDDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.activateFDAccount(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "This class manages the transaction boundary for database writes using Spring's @Transactional annotation, but delegates the actual data access and persistence logic to the SavingsApplicationProcessWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.savingAccountWritePlatformService.rejectGSIMApplication(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositApplicationProcessWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions, delegating the actual persistence operations to the `DepositApplicationProcessWritePlatformService`. While it does not contain direct SQL or ORM calls, it defines the transactional boundary for the database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.rejectApplication(command.entityId(), command, DepositAccountType.FIXED_DEPOSIT);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "TransactionManagement", "description": "This class does not execute SQL directly but defines a transaction boundary using Spring's `@Transactional` annotation. This ensures that the database operations performed by the injected `SavingsAccountWritePlatformService` are committed or rolled back atomically.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.withdrawal(command.getSavingsId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "This class defines a transaction boundary using Spring's @Transactional annotation, but delegates the actual database interaction to the injected SavingsApplicationProcessWritePlatformService. While it does not contain direct SQL or Repository calls, it controls the transaction context for the database write operation (deletion).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.savingAccountWritePlatformService.deleteApplication(command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class defines a transactional boundary using Spring's \"@Transactional\" annotation, ensuring that the withdrawal operation performed by the delegated service is atomic. While it does not execute SQL directly, it controls the transaction context for the database operations executed by the \"DepositAccountWritePlatformService\".", "databaseName": "unknown", "tablesAccessed": [ "RECURRINGDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotation on the processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.withdrawal(command.entityId(), command, DepositAccountType.RECURRING_DEPOSIT);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "Transaction Management", "description": "The class does not perform direct database queries but manages database transaction boundaries using Spring's `@Transactional` annotation before delegating to the service layer.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation while delegating the actual data persistence logic to the `DepositAccountWritePlatformService`. It does not execute SQL directly but controls the transaction boundary for the operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n final Long transactionId = Long.valueOf(command.getTransactionId());\n return this.depositAccountWritePlatformService.undoFDTransaction(command.entityId(), transactionId, false);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, ensuring that the delegated service operation runs within a transaction context. While it does not execute SQL directly, it orchestrates the transactional boundary for the database write operation performed by the service.", "databaseName": "unknown", "tablesAccessed": [ "RECURRINGDEPOSITACCOUNT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n final Long transactionId = Long.valueOf(command.getTransactionId());\n return this.depositAccountWritePlatformService.adjustRDTransaction(command.entityId(), transactionId, command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "Spring Transaction Management", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not contain direct SQL or ORM calls itself, it orchestrates a service method (`depositAccountWritePlatformService.calculateInterest`) that performs database write operations (calculating and persisting interest data).", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer for business logic and persistence", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.calculateInterest(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositApplicationProcessWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation while delegating the actual data modification to the `DepositApplicationProcessWritePlatformService`. While it does not contain direct SQL or Repository calls, it defines the transactional boundary for a database write operation.", "databaseName": "unknown", "tablesAccessed": [ "RECURRING_DEPOSIT_ACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.deleteApplication(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions, although the actual data access logic is delegated to the `DepositAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.closeRDAccount(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class orchestrates database writes by defining a transaction boundary using Spring's @Transactional annotation and delegating to a service layer component that performs the actual persistence operations.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.updateDepositAmountForRDAccount(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation, ensuring that the downstream database operations performed by the `DepositAccountWritePlatformService` are atomic. While it does not contain direct SQL or ORM calls, it defines the transaction boundary for database writes.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.closeFDAccount(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation, although the direct database operations are delegated to the injected service.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n\n return this.writePlatformService.undoApplicationApproval(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "The class defines a transactional boundary using Spring's `@Transactional` annotation. It delegates the actual database persistence and business logic to the `SavingsApplicationProcessWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.applicantWithdrawsFromApplication(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates a unit of work that modifies database state via the injected `SavingsApplicationProcessWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [ "GSIMACCOUNT (implied by CommandType)" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.savingAccountWritePlatformService.modifyGSIMApplication(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it orchestrates a write operation by delegating to a service layer that interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.savingAccountWritePlatformService.modifyApplication(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsApplicationProcessWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it orchestrates a write operation (creation of a savings account) by delegating to a service layer that interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.savingAccountWritePlatformService.submitApplication(command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsAccountWritePlatformService", "description": "The class orchestrates database interactions by defining a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL directly, it delegates to the `SavingsAccountWritePlatformService` which performs the actual database write operations to block the account.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.blockAccount(command.getSavingsId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsAccountWritePlatformService", "description": "The class does not execute SQL or access repositories directly, but it manages database transactions via the Spring `@Transactional` annotation. It delegates the actual persistence operations to the `SavingsAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.inactivateCharge(command.getSavingsId(), command.entityId());\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "SavingsAccountWritePlatformService", "description": "The class defines a database transaction boundary using Spring's `@Transactional` annotation, ensuring the savings account closure operation is atomic. While it does not execute SQL directly, it orchestrates the write operation via the injected service.", "databaseName": "unknown", "tablesAccessed": [ "SAVINGSACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.close(command.getSavingsId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositAccountWritePlatformService", "description": "The class defines a database transaction boundary using the Spring @Transactional annotation. While it does not execute SQL directly, it orchestrates the transaction for the underlying service layer which interacts with the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.depositToFDAccount(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositApplicationProcessWritePlatformService", "description": "This class defines a transaction boundary using Spring's @Transactional annotation but delegates the actual database persistence operations to the injected DepositApplicationProcessWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.approveApplication(...);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "OTHER", "name": "DepositApplicationProcessWritePlatformService", "description": "This class participates in database integration by defining a transaction boundary using Spring's `@Transactional` annotation. While it does not execute SQL or call repositories directly, it delegates to a service that performs write operations on the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.rejectApplication(command.entityId(), command, DepositAccountType.RECURRING_DEPOSIT);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler.CloseGSIMCommandHandler", "mechanism": "OTHER", "name": "SavingsAccountWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation. While it does not contain direct SQL or Repository calls, it defines the transaction boundary for the `bulkGSIMClose` operation performed by the injected service.", "databaseName": "unknown", "tablesAccessed": [ "GSIMACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update operations", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.bulkGSIMClose(command.getSavingsId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler.RecurringDepositAccountApplicationSubmittalCommandHandler", "mechanism": "OTHER", "name": "TransactionManagement", "description": "The class uses Spring's declarative transaction management to define transaction boundaries for the command processing, although it does not execute direct SQL queries itself.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {" }, { "path": "org.apache.fineract.portfolio.savings.handler.UnblockSavingsAccountCommandHandler", "mechanism": "OTHER", "name": "SavingsAccountWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to define a transaction boundary for the operation. While it does not contain direct JDBC or JPA calls itself, it orchestrates the transaction for the underlying `SavingsAccountWritePlatformService` which performs the actual database writes.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.unblockAccount(command.getSavingsId());\n }" }, { "path": "org.apache.fineract.portfolio.self.pockets.handler", "mechanism": "OTHER", "name": "PocketWritePlatformService", "description": "The class orchestrates a database transaction using Spring's `@Transactional` annotation, although the direct database manipulation logic is delegated to the `PocketWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.pocketWritePlatformService.delinkAccounts(command);\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "The class defines a transactional boundary using Spring's `@Transactional` annotation, implying interaction with the database through the delegated service. While this specific file does not contain SQL or Repository calls, it manages the transaction context for the database operations performed by the `ShareAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.rejectAdditionalShares(jsonCommand.entityId(), jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "This class manages the transaction boundary for database operations using Spring's `@Transactional` annotation. While it does not execute SQL or JPA queries directly, it delegates to `ShareAccountWritePlatformService` which performs the actual database write operations for the 'SHAREACCOUNT' entity.", "databaseName": "unknown", "tablesAccessed": [ "SHAREACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.updateShareAccount(jsonCommand.entityId(), jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "This class does not perform direct database operations (SQL/JPA) itself but manages the transaction boundary for database interactions. It uses Spring's `@Transactional` annotation to ensure that the operations performed by the called service (`ShareAccountWritePlatformService`) occur within a transaction context.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.approveShareAccount(jsonCommand.entityId(), jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "This class acts as a transactional wrapper around the business service. While it does not execute SQL directly, it defines the transaction boundary using Spring's `@Transactional` annotation, delegating the actual database persistence operations to the `ShareAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.undoApproveShareAccount(jsonCommand.entityId(), jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler.ApproveAddtionalSharesCommandHandler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "This class defines the transaction boundary for database operations using Spring's @Transactional annotation, although the direct database access logic resides in the injected ShareAccountWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.approveAdditionalShares(jsonCommand.entityId(), jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler.CreateShareAccountCommandHandler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "The class defines a transaction boundary using Spring's @Transactional annotation, ensuring that the database operations performed by the called service are atomic. While it does not execute SQL directly, it controls the transaction context for the database write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.createShareAccount(jsonCommand);\n }" }, { "path": "org.apache.fineract.portfolio.shareaccounts.handler.RejectShareAccountCommandHandler", "mechanism": "OTHER", "name": "ShareAccountWritePlatformService", "description": "The class manages database transactions using Spring's `@Transactional` annotation. It does not perform direct database queries itself but delegates the persistence operations to the `ShareAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareAccountWritePlatformService.rejectShareAccount(jsonCommand.entityId(), jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.shareproducts.handler.CreateShareProductCommandHandler", "mechanism": "OTHER", "name": "ShareProductWritePlatformService", "description": "The class manages database transactions using Spring's @Transactional annotation, wrapping the database operations performed by the injected ShareProductWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "SHAREPRODUCT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.shareProductWritePlatformService.createShareProduct(jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.transfer.handler", "mechanism": "OTHER", "name": "TransferWritePlatformService", "description": "The class manages database transactions via Spring's @Transactional annotation, although the direct database operations are delegated to the injected TransferWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.proposeAndAcceptClientTransfer(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.transfer.handler", "mechanism": "OTHER", "name": "TransferWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation but delegates the actual data access and modification to the `TransferWritePlatformService`. It does not contain direct SQL or Repository calls itself, but acts as the transactional boundary for the write operation.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.rejectClientTransfer(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.useradministration.handler", "mechanism": "OTHER", "name": "PasswordPreferencesWritePlatformService", "description": "The class defines a transaction boundary using Spring's `@Transactional` annotation, implying interaction with a transactional resource (database) via the delegated service.", "databaseName": "unknown", "tablesAccessed": [ "PASSWORD_PREFERENCES" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updatePreferences(command);\n}" }, { "path": "org.apache.fineract.useradministration.handler", "mechanism": "OTHER", "name": "AppUserWritePlatformService", "description": "The class defines a transactional boundary for the user creation operation using Spring's @Transactional annotation, ensuring that the database operations performed by the delegated service are atomic.", "databaseName": "unknown", "tablesAccessed": [ "USER" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates creation logic to service layer", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {" }, { "path": "org.apache.fineract.useradministration.handler", "mechanism": "OTHER", "name": "RoleWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to manage database transactions. It delegates the actual database write operation to the `RoleWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.updateRolePermissions(command.entityId(), command);\n}" }, { "path": "fineract-loan/dependencies.gradle", "mechanism": "SPRING-DATA", "name": "Spring Data JPA / EclipseLink", "description": "The build script configures the application to use Spring Data JPA for database access. It specifically overrides the default Hibernate provider to use EclipseLink by excluding the Hibernate group from the starter dependency and explicitly adding the EclipseLink library.", "databaseName": "not identifiable from code", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "n/a (Dependency configuration only)", "transactionHandling": "n/a (Dependency configuration only)", "protocol": "JPA (EclipseLink)", "connectionInfo": "n/a", "codeExample": "implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {\n exclude group: 'org.hibernate'\n}\nimplementation('org.eclipse.persistence:org.eclipse.persistence.jpa') {\n exclude group: 'org.eclipse.persistence', module: 'jakarta.persistence'\n}" }, { "path": "org.apache.fineract.accounting.closure.domain.GLClosureRepository", "mechanism": "SPRING-DATA", "name": "GLClosureRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends `JpaRepository` to provide standard data access methods and defines a custom JPQL query for specific business logic.", "databaseName": "unknown", "tablesAccessed": [ "GLClosure" ], "operationType": [ "READ_WRITE", "READ" ], "queryPatterns": "JPQL query containing a subquery and aggregation (MAX) to filter by date and foreign key.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select closure from GLClosure closure where closure.closingDate = (select max(closure1.closingDate) from GLClosure closure1 where closure1.office.id=:officeId) and closure.office.id= :officeId\")\nGLClosure getLatestGLClosureByBranch(@Param(\"officeId\") Long officeId);" }, { "path": "org.apache.fineract.accounting.closure.service", "mechanism": "SPRING-DATA", "name": "GLClosureRepository", "description": "The class uses Spring Data JPA repositories (GLClosureRepository and OfficeRepositoryWrapper) to interact with the database. It performs CRUD operations on GLClosure entities and read operations on Office entities.", "databaseName": "unknown", "tablesAccessed": [ "GLClosure", "Office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, delete) and a custom query method (getLatestGLClosureByBranch).", "transactionHandling": "Spring @Transactional annotations are used on all public service methods to manage transaction boundaries.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.glClosureRepository.saveAndFlush(glClosure);" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.domain", "mechanism": "SPRING-DATA", "name": "FinancialActivityAccountRepository", "description": "The class wraps a Spring Data repository interface to perform database operations on FinancialActivityAccount entities.", "databaseName": "unknown", "tablesAccessed": [ "FinancialActivityAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to Spring Data JPA repository.", "transactionHandling": "Implicitly handled by the underlying Spring Data repository implementation.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new FinancialActivityAccountNotFoundException(id));" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.domain", "mechanism": "SPRING-DATA", "name": "FinancialActivityAccountRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "FinancialActivityAccount" ], "operationType": [ "READ_WRITE", "READ" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select faa from FinancialActivityAccount faa where faa.financialActivityType = :financialActivityType\")" }, { "path": "org.apache.fineract.accounting.financialactivityaccount.service", "mechanism": "SPRING-DATA", "name": "FinancialActivityAccountRepositoryWrapper", "description": "The class uses repository wrappers (likely wrapping Spring Data JPA repositories) to perform CRUD operations on `FinancialActivityAccount` and `GLAccount` entities. It handles persistence exceptions and performs explicit `saveAndFlush` operations.", "databaseName": "unknown", "tablesAccessed": [ "FinancialActivityAccount", "GLAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via repository methods (findOne, save, delete).", "transactionHandling": "Likely handled by Spring's @Transactional at the interface level or default repository behavior, though not explicitly annotated in this class file.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.financialActivityAccountRepository.saveAndFlush(financialActivityAccount);" }, { "path": "org.apache.fineract.accounting.glaccount.domain", "mechanism": "SPRING-DATA", "name": "TrialBalanceRepository", "description": "The class interacts with the database through the injected `TrialBalanceRepository`, which is likely a Spring Data interface. It performs read operations filtered by office and account, and batch write operations.", "databaseName": "unknown", "tablesAccessed": [ "TrialBalance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (find by criteria and save all)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findNewByOfficeAndAccount(officeId, accountId);" }, { "path": "org.apache.fineract.accounting.glaccount.domain", "mechanism": "SPRING-DATA", "name": "GLAccountRepository", "description": "The class interacts with the database through the injected `GLAccountRepository`, which is a Spring Data repository interface. It performs read operations to fetch GLAccount entities.", "databaseName": "unknown", "tablesAccessed": [ "GLAccount" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookups by Primary Key and Unique Key (GL Code)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.findById(id).orElseThrow(() -> new GLAccountNotFoundException(id))" }, { "path": "org.apache.fineract.accounting.glaccount.domain.GLAccountRepository", "mechanism": "SPRING-DATA", "name": "GLAccountRepository", "description": "The file uses Spring Data JPA to abstract database interactions. It extends JpaRepository to provide standard CRUD operations and JpaSpecificationExecutor for complex criteria queries without writing explicit SQL.", "databaseName": "unknown", "tablesAccessed": [ "GLAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived query methods and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Optional findOneByGlCode(String glCode);" }, { "path": "org.apache.fineract.accounting.glaccount.domain.TrialBalanceRepository", "mechanism": "SPRING-DATA", "name": "TrialBalanceRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends JpaRepository for standard CRUD operations and defines a custom native SQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "m_trial_balance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Uses standard Spring Data abstractions for most operations, but includes one explicit native SQL query for filtering null closing balances.", "transactionHandling": "Spring @Transactional", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(value = \"select * from m_trial_balance where office_id=:officeId ...\", nativeQuery = true)" }, { "path": "org.apache.fineract.accounting.glaccount.jobs.updatetrialbalancedetails.UpdateTrialBalanceDetailsConfig", "mechanism": "SPRING-DATA", "name": "TrialBalanceRepositoryWrapper", "description": "The configuration class injects a repository wrapper (TrialBalanceRepositoryWrapper) and a data source factory (RoutingDataSourceServiceFactory) and passes them to the Tasklet. This indicates that the job's execution involves reading from and writing to the database using these components, likely via JPA/Spring Data and potentially direct JDBC via the data source factory.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch processing logic likely involving bulk updates or calculations based on trial balance data.", "transactionHandling": "Spring Batch Step configuration uses the PlatformTransactionManager.", "protocol": "unknown", "connectionInfo": "Managed by RoutingDataSourceServiceFactory", "codeExample": "return new UpdateTrialBalanceDetailsTasklet(dataSourceServiceFactory, trialBalanceRepositoryWrapper);" }, { "path": "org.apache.fineract.accounting.glaccount.service", "mechanism": "SPRING-DATA", "name": "GLAccountRepository, JournalEntryRepository, JdbcTemplate", "description": "The class primarily uses Spring Data JPA repositories (GLAccountRepository, JournalEntryRepository) for CRUD operations and existence checks on entities. It also utilizes Spring's JdbcTemplate to execute a raw SQL query for checking product mappings in the 'acc_product_mapping' table.", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_account", "acc_gl_journal_entry", "acc_product_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, delete, exists) and one inline SQL count query.", "transactionHandling": "Spring @Transactional annotations on public methods.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "String sql = \"select count(*) from acc_product_mapping acc where acc.gl_account_id = ?\";\nint count = this.jdbcTemplate.queryForObject(sql, Integer.class, glAccountId);" }, { "path": "org.apache.fineract.accounting.journalentry.domain", "mechanism": "SPRING-DATA", "name": "JournalEntryRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD methods, and by defining custom JPQL queries via the @Query annotation to perform specific filtering on the JournalEntry table.", "databaseName": "unknown", "tablesAccessed": [ "JournalEntry" ], "operationType": [ "READ" ], "queryPatterns": "JPQL queries with subqueries (NOT IN), DISTINCT clauses, and multiple filtering criteria (transactionId, reversed status, entityType).", "transactionHandling": "Spring Data repositories typically participate in the caller's transaction context (Spring @Transactional).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select journalEntry from JournalEntry journalEntry where journalEntry.transactionId= :transactionId and journalEntry.reversed=false and journalEntry.manualEntry=true\")" }, { "path": "org.apache.fineract.accounting.journalentry.service.AccountingProcessorHelper", "mechanism": "SPRING-DATA", "name": "JournalEntryRepository, ProductToGLAccountMappingRepository, etc.", "description": "The class uses multiple Spring Data repositories to interact with the database. It reads configuration data (GL Accounts, Mappings, Closures) and writes transaction data (Journal Entries).", "databaseName": "unknown", "tablesAccessed": [ "acc_gl_journal_entry", "acc_product_mapping", "acc_gl_closure", "acc_gl_account", "m_office", "m_loan_transaction", "m_client_transaction", "m_savings_account_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, getReferenceById, findBy...) and some custom finders for mappings.", "transactionHandling": "Implicitly handled by Spring Data repository calls, though the service itself is annotated with @Service and likely participates in transactions initiated by callers.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "JournalEntry savedJournalEntry = this.glJournalEntryRepository.saveAndFlush(journalEntry);" }, { "path": "org.apache.fineract.accounting.journalentry.service.JournalEntryWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "JournalEntryRepository, GLAccountRepository, GLClosureRepository", "description": "The class uses multiple Spring Data JPA repositories to interact with the database. It performs CRUD operations on JournalEntry, GLAccount, and GLClosure entities. It uses @Transactional to ensure data consistency across multiple repository calls.", "databaseName": "unknown", "tablesAccessed": [ "JournalEntry", "GLAccount", "GLClosure", "Office", "AccountingRule", "PaymentDetail", "FinancialActivityAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, save) and some custom finders (findUnReversedManualJournalEntriesByTransactionId).", "transactionHandling": "Spring @Transactional", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final List journalEntries = this.glJournalEntryRepository.findUnReversedManualJournalEntriesByTransactionId(command.getTransactionId());" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.domain", "mechanism": "SPRING-DATA", "name": "ProductToGLAccountMappingRepository", "description": "The interface extends JpaRepository to provide database access for ProductToGLAccountMapping entities. It uses JPQL annotations to define complex selection logic involving null checks and specific constant values for account types.", "databaseName": "unknown", "tablesAccessed": [ "ProductToGLAccountMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with specific filtering criteria including NULL checks and hardcoded integer constants for account types.", "transactionHandling": "Spring @Transactional (default for JpaRepository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select mapping from ProductToGLAccountMapping mapping where mapping.productId =:productId ... and mapping.paymentType is NULL\")" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service", "mechanism": "SPRING-DATA", "name": "GLAccountRepository, ProductToGLAccountMappingRepository", "description": "The class injects Spring Data repositories via its constructor and passes them to its superclass. It delegates persistence operations (save, update, delete) to the superclass methods, which utilize these repositories to manage the lifecycle of product-to-account mappings in the database.", "databaseName": "unknown", "tablesAccessed": [ "ProductToGLAccountMapping", "GLAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM-based CRUD operations managed by Spring Data JPA repositories in the superclass.", "transactionHandling": "Likely handled by Spring @Transactional at the service layer invoking this helper.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "public void deleteSharesProductToGLAccountMapping(final Long sharesProductId) {\n deleteProductToGLAccountMapping(sharesProductId, PortfolioProductType.SHARES);\n}" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service", "mechanism": "SPRING-DATA", "name": "GLAccountRepository, ProductToGLAccountMappingRepository", "description": "The class interacts with the database through Spring Data repositories injected into its constructor (and passed to the superclass). It performs CRUD operations on GL Account mappings.", "databaseName": "unknown", "tablesAccessed": [ "GLAccount", "ProductToGLAccountMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository methods.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "public void deleteSavingsProductToGLAccountMapping(final Long savingsProductId) {\n deleteProductToGLAccountMapping(savingsProductId, PortfolioProductType.SAVING);\n}" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service.LoanProductToGLAccountMappingHelper", "mechanism": "SPRING-DATA", "name": "GLAccountRepository, ProductToGLAccountMappingRepository", "description": "The class interacts with the database through Spring Data repositories injected into the constructor (and passed to the superclass). It performs operations to save, update, and delete mappings between products and GL accounts.", "databaseName": "unknown", "tablesAccessed": [ "gl_account", "acc_product_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations via Spring Data JPA repositories.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "saveProductToAccountMapping(element, paramName, productId, placeHolderTypeId, GLAccountType.ASSET, PortfolioProductType.LOAN);" }, { "path": "org.apache.fineract.accounting.producttoaccountmapping.service.ProductToGLAccountMappingHelper", "mechanism": "SPRING-DATA", "name": "ProductToGLAccountMappingRepository, GLAccountRepository", "description": "The class uses Spring Data repositories to interact with the database. It performs CRUD operations on `ProductToGLAccountMapping` and `GLAccount` entities. It uses `saveAndFlush` for immediate persistence and `deleteAllInBatch` for bulk deletions.", "databaseName": "unknown", "tablesAccessed": [ "ProductToGLAccountMapping", "GLAccount", "Charge", "PaymentType" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository methods, including find by ID, find by product ID, and batch delete.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "this.accountMappingRepository.saveAndFlush(accountMapping);" }, { "path": "org.apache.fineract.accounting.provisioning.domain", "mechanism": "SPRING-DATA", "name": "ProvisioningEntryRepository", "description": "The interface extends JpaRepository to provide database access for ProvisioningEntry entities. It uses JPQL annotations for custom retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningEntry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries using simple selection and subqueries for aggregation (max date).", "transactionHandling": "Spring Data JPA repositories typically participate in Spring managed transactions.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select entry1 from ProvisioningEntry entry1 where entry1.createdDate = :createdDate\")" }, { "path": "org.apache.fineract.accounting.provisioning.service.ProvisioningEntriesWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ProvisioningEntryRepository, LoanProductRepository, GLAccountRepository", "description": "The class uses multiple Spring Data JPA repositories to interact with the database. It performs read and write operations on ProvisioningEntry, LoanProduct, GLAccount, and related entities. It uses saveAndFlush for immediate persistence.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningEntry", "LoanProduct", "GLAccount", "Office", "ProvisioningCategory", "LoanProductProvisioningEntry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, saveAndFlush) and custom find methods (findByProvisioningEntryDate).", "transactionHandling": "Implicitly handled by Spring Data repositories or service layer transaction management (though @Transactional is not explicitly present on this class, it is standard in this architecture).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.provisioningEntryRepository.saveAndFlush(requestedEntry);" }, { "path": "org.apache.fineract.accounting.rule.domain", "mechanism": "SPRING-DATA", "name": "AccountingRuleRepository", "description": "The class interacts with the database through the AccountingRuleRepository, which is a Spring Data repository interface. It performs read operations to fetch AccountingRule entities by their primary key.", "databaseName": "unknown", "tablesAccessed": [ "AccountingRule" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (Find by ID)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new AccountingRuleNotFoundException(id));" }, { "path": "org.apache.fineract.accounting.rule.domain.AccountingRuleRepository", "mechanism": "SPRING-DATA", "name": "AccountingRuleRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access capabilities and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "AccountingRule" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "JPQL query with conditional logic (OR clause) checking for null or specific ID match.", "transactionHandling": "Spring @Transactional (Implicit in Spring Data repositories)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select accountingRule from AccountingRule accountingRule where accountingRule.office is null or accountingRule.office.id =:officeId\")" }, { "path": "org.apache.fineract.accounting.rule.service.AccountingRuleWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "AccountingRuleRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects `AccountingRuleRepository`, `GLAccountRepositoryWrapper`, `OfficeRepositoryWrapper`, and `CodeValueRepository` to perform CRUD operations. Transaction management is handled via the `@Transactional` annotation.", "databaseName": "unknown", "tablesAccessed": [ "AccountingRule", "GLAccount", "Office", "CodeValue", "AccountingTagRule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, delete, findById) and wrapper methods for entity retrieval.", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.accountingRuleRepository.saveAndFlush(accountingRule);" }, { "path": "org.apache.fineract.adhocquery.domain.AdHocRepository", "mechanism": "SPRING-DATA", "name": "AdHocRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically generates the implementation for the repository interface at runtime. It manages the persistence lifecycle of the AdHoc entity.", "databaseName": "unknown", "tablesAccessed": [ "AdHoc" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria-based queries provided by JpaSpecificationExecutor.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface AdHocRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.adhocquery.service.AdHocWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "AdHocRepository", "description": "The class uses a Spring Data JPA repository (AdHocRepository) to interact with the database. It performs standard CRUD operations such as save, findById, and delete on the AdHoc entity.", "databaseName": "unknown", "tablesAccessed": [ "AdHoc" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations using Spring Data JPA methods (saveAndFlush, findById, delete).", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.adHocRepository.saveAndFlush(entity);" }, { "path": "org.apache.fineract.cob", "mechanism": "SPRING-DATA", "name": "BatchBusinessStepRepository", "description": "The class uses a Spring Data JPA repository (`BatchBusinessStepRepository`) to access batch business step configurations.", "databaseName": "unknown", "tablesAccessed": [ "BatchBusinessStep" ], "operationType": [ "READ" ], "queryPatterns": "Simple read operation to find all steps by job name.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List cobStepConfigs = batchBusinessStepRepository.findAllByJobName(cobJobName);" }, { "path": "org.apache.fineract.cob.api.InternalLoanAccountLockApiResource", "mechanism": "SPRING-DATA", "name": "LoanAccountLockRepository", "description": "The class interacts with the database using a Spring Data repository interface `LoanAccountLockRepository`. It persists `LoanAccountLock` entities.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock" ], "operationType": [ "WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "loanAccountLockRepository.save(loanAccountLock);" }, { "path": "org.apache.fineract.cob.common", "mechanism": "SPRING-DATA", "name": "AppUserRepositoryWrapper", "description": "The class interacts with the database to retrieve the system user details required for authentication. This is done through the `AppUserRepositoryWrapper`, which likely wraps a Spring Data repository.", "databaseName": "unknown", "tablesAccessed": [ "AppUser" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity retrieval by system property", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "AppUser user = userRepository.fetchSystemUser();" }, { "path": "org.apache.fineract.cob.common", "mechanism": "SPRING-DATA", "name": "CustomJobParameterRepository", "description": "The class uses a Spring Data repository (`CustomJobParameterRepository`) to fetch `CustomJobParameter` entities by their primary key ID.", "databaseName": "unknown", "tablesAccessed": [ "CustomJobParameter" ], "operationType": [ "READ" ], "queryPatterns": "Simple primary key lookup (findById)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return customJobParameterRepository.findById(customJobParameterId).map(CustomJobParameter::getParameterJson)" }, { "path": "org.apache.fineract.cob.data", "mechanism": "SPRING-DATA", "name": "Loan Projection", "description": "This interface functions as a Spring Data JPA Projection. By defining getter methods that match properties of the underlying Loan entity, it enables the persistence framework to generate a query that selects only the 'id', 'externalId', and 'accountNo' columns from the database, rather than retrieving the entire row.", "databaseName": "unknown", "tablesAccessed": [ "Loan (inferred)" ], "operationType": [ "READ" ], "queryPatterns": "Projection interface for selecting specific fields", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface LoanIdAndExternalIdAndAccountNo {\n Long getId();\n ExternalId getExternalId();\n String getAccountNo();\n}" }, { "path": "org.apache.fineract.cob.data.LoanIdAndLastClosedBusinessDate", "mechanism": "SPRING-DATA", "name": "Loan Projection", "description": "This interface functions as a Spring Data Projection. It defines a subset of data to be retrieved from the database, specifically targeting the Loan entity's ID and last closed business date. This allows the persistence layer to generate an optimized SQL SELECT query fetching only these specific columns.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ" ], "queryPatterns": "Projection query fetching specific columns", "transactionHandling": "Managed by the calling repository method", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "public interface LoanIdAndLastClosedBusinessDate {\n Long getId();\n LocalDate getLastClosedBusinessDate();\n}" }, { "path": "org.apache.fineract.cob.domain", "mechanism": "SPRING-DATA", "name": "BatchBusinessStepRepository", "description": "The interface extends JpaRepository to provide data access for the BatchBusinessStep entity. It uses Spring Data's method derivation and JPQL annotations to interact with the underlying relational database.", "databaseName": "unknown", "tablesAccessed": [ "BatchBusinessStep" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD, derived find/delete methods, and one custom JPQL projection query.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"SELECT DISTINCT bbs.jobName FROM BatchBusinessStep bbs\")" }, { "path": "org.apache.fineract.cob.domain", "mechanism": "SPRING-DATA", "name": "LoanAccountLockRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository and defining method signatures that Spring translates into SQL queries. It also uses the @Query annotation for custom JPQL operations.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations, batch deletes via IN clauses, and one custom JPQL delete query for cleanup.", "transactionHandling": "Spring Data repositories typically participate in the caller's transaction context. The @Modifying annotation on removeLockByOwner suggests it performs a DML operation within a transaction.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"\"\"\n delete from LoanAccountLock lck where lck.lockPlacedOnCobBusinessDate is not null and lck.error is not null and\n lck.lockOwner in (org.apache.fineract.cob.domain.LockOwner.LOAN_COB_CHUNK_PROCESSING,org.apache.fineract.cob.domain.LockOwner.LOAN_INLINE_COB_PROCESSING)\n \"\"\")\n@Modifying(flushAutomatically = true)\nvoid removeLockByOwner();" }, { "path": "org.apache.fineract.cob.domain.CustomLoanAccountLockRepository", "mechanism": "SPRING-DATA", "name": "CustomLoanAccountLockRepository", "description": "This interface represents a custom extension to a Spring Data repository, defining a specific data manipulation operation. It implies the execution of a database update command to synchronize loan data with account lock data.", "databaseName": "unknown", "tablesAccessed": [ "Loan (inferred)", "AccountLock (inferred)" ], "operationType": [ "WRITE" ], "queryPatterns": "batch operations", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "void updateLoanFromAccountLocks();" }, { "path": "org.apache.fineract.cob.listener", "mechanism": "SPRING-DATA", "name": "LoanLockingService", "description": "The class interacts with the database to update 'LoanAccountLock' entities when errors occur. It uses a 'TransactionTemplate' to execute these updates in a separate transaction (REQUIRES_NEW), ensuring error logs are persisted even if the main batch transaction fails. It delegates the actual entity retrieval to 'LoanLockingService'.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Retrieves entity by ID and LockOwner, then updates fields on the entity.", "transactionHandling": "Programmatic transaction management using TransactionTemplate with PROPAGATION_REQUIRES_NEW.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "transactionTemplate.setPropagationBehavior(PROPAGATION_REQUIRES_NEW);\ntransactionTemplate.execute(new TransactionCallbackWithoutResult() {\n @Override\n protected void doInTransactionWithoutResult(@NotNull TransactionStatus status) {\n for (Long loanId : loanIds) {\n LoanAccountLock loanAccountLock = loanLockingService.findByLoanIdAndLockOwner(loanId, getLockOwner());\n if (loanAccountLock != null) {\n loanAccountLock.setError(String.format(msg, loanId), ThrowableSerialization.serialize(e));\n }\n }\n }\n});" }, { "path": "org.apache.fineract.cob.loan", "mechanism": "SPRING-DATA", "name": "LoanLockingService Configuration", "description": "This class configures database access by injecting and passing the JdbcTemplate and LoanAccountLockRepository to the service layer. While this specific file does not execute queries, it wires the components (JDBC and Spring Data Repository) that perform database operations for loan locking.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "Configuration and wiring of data access components.", "transactionHandling": "None (Configuration level)", "protocol": "JDBC / Spring Data", "connectionInfo": "Configured via Spring Context (DataSource)", "codeExample": "return new LoanLockingServiceImpl(jdbcTemplate, fineractProperties, loanAccountLockRepository);" }, { "path": "org.apache.fineract.cob.loan", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The class injects a `LoanRepository` via its constructor and passes it to its superclass `AbstractLoanItemReader`. While this specific file primarily reads IDs from the `ExecutionContext` (memory), it is part of a data access component hierarchy that relies on Spring Data JPA repositories for loan data retrieval.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ" ], "queryPatterns": "The specific code here does not execute queries, but initializes a queue for the parent class which likely performs READ operations.", "transactionHandling": "Spring Batch transaction management", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "public InlineCOBLoanItemReader(LoanRepository loanRepository) {\n super(loanRepository);\n}" }, { "path": "org.apache.fineract.cob.loan", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The class uses a Spring Data repository (`LoanRepository`) to retrieve `Loan` entities by their primary key ID.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD read by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return loanRepository.findById(loanId).orElseThrow(() -> new LoanNotFoundException(loanId));" }, { "path": "org.apache.fineract.cob.loan", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The configuration sets up Spring Batch components (Reader and Writer) that interact with the database via the LoanRepository. The LoanItemReader reads loan data, and the LoanItemWriter persists changes to Loan entities.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch processing with chunk-oriented reads and writes", "transactionHandling": "Spring Batch managed transactions via PlatformTransactionManager and TransactionTemplate", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "LoanItemWriter repositoryItemWriter = new LoanItemWriter(loanLockingService);\nrepositoryItemWriter.setRepository(loanRepository);" }, { "path": "org.apache.fineract.cob.loan.AbstractLoanItemWriter", "mechanism": "SPRING-DATA", "name": "LoanLockingService", "description": "The class interacts with the database in two ways: implicitly through the `RepositoryItemWriter` superclass which persists `Loan` entities, and explicitly through the `LoanLockingService` to delete lock records.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanLock" ], "operationType": [ "WRITE" ], "queryPatterns": "Batch write of entities followed by a bulk delete operation by ID list.", "transactionHandling": "Likely participates in a Spring Batch step transaction.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "super.write(items);\nList loanIds = items.getItems().stream().map(AbstractPersistableCustom::getId).toList();\nloanLockingService.deleteByLoanIdInAndLockOwner(loanIds, getLockOwner());" }, { "path": "org.apache.fineract.cob.loan.ApplyLoanLockTasklet", "mechanism": "SPRING-DATA", "name": "LoanLockingService / RetrieveLoanIdService", "description": "The class interacts with the database indirectly through injected services (`LoanLockingService` and `RetrieveLoanIdService`) to read loan data and manage lock entities. It explicitly controls transaction boundaries using `TransactionTemplate` to ensure locks are committed in a new transaction.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs bulk reads (finding existing locks by ID list) and writes (applying locks). It uses partitioning to handle large lists of IDs in 'IN' clauses.", "transactionHandling": "Uses Spring's `TransactionTemplate` with `PROPAGATION_REQUIRES_NEW` to isolate the locking operation from the main batch transaction.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "transactionTemplate.setPropagationBehavior(PROPAGATION_REQUIRES_NEW);\ntransactionTemplate.execute(new TransactionCallbackWithoutResult() {\n @Override\n protected void doInTransactionWithoutResult(@NotNull TransactionStatus status) {\n loanLockingService.applyLock(toBeProcessedLoanIds, LockOwner.LOAN_COB_CHUNK_PROCESSING);\n }\n});" }, { "path": "org.apache.fineract.cob.loan.InlineLoanCOBBuildExecutionContextTasklet", "mechanism": "SPRING-DATA", "name": "CustomJobParameterRepository", "description": "The class uses a Spring Data repository (CustomJobParameterRepository) to retrieve custom job parameters stored in the database. These parameters contain JSON payloads defining the inputs for the batch job.", "databaseName": "unknown", "tablesAccessed": [ "CustomJobParameter" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (findById)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "CustomJobParameter customJobParameter = customJobParameterRepository.findById(customJobParameterId)\n .orElseThrow(() -> new LoanNotFoundException(customJobParameterId));" }, { "path": "org.apache.fineract.cob.loan.LoanInlineCOBConfig", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The configuration sets up a Spring Batch job that interacts with the database via Spring Data Repositories. The 'InlineCOBLoanItemReader' uses 'LoanRepository' to fetch Loan entities, and the 'InlineCOBLoanItemWriter' uses the same repository to persist updates. Transaction management is handled via the PlatformTransactionManager.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch processing with chunk-based reads and writes.", "transactionHandling": "Spring @Transactional via PlatformTransactionManager and TransactionTemplate", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Bean\npublic InlineCOBLoanItemReader inlineCobWorkerItemReader() {\n return new InlineCOBLoanItemReader(loanRepository);\n}" }, { "path": "org.apache.fineract.cob.loan.LoanItemReader", "mechanism": "SPRING-DATA", "name": "LoanRepository / LoanLockingService", "description": "The class interacts with the database indirectly through injected services (`RetrieveLoanIdService`, `LoanLockingService`) and the `LoanRepository` passed to the superclass. These services likely use Spring Data JPA repositories to query loan data and lock tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_account_lock" ], "operationType": [ "READ" ], "queryPatterns": "The code performs read operations to fetch loan IDs based on criteria (min/max ID, business date) and to fetch lock status for specific loan IDs.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "accountLocks.addAll(loanLockingService.findAllByLoanIdInAndLockOwner(loanIds, LockOwner.LOAN_COB_CHUNK_PROCESSING));" }, { "path": "org.apache.fineract.cob.loan.LoanLockingService", "mechanism": "SPRING-DATA", "name": "LoanLockingService", "description": "Although this is an interface, the method naming conventions (e.g., 'deleteBy...', 'findAllBy...') strongly suggest it is implemented using Spring Data JPA or acts as a service wrapper around a Spring Data repository for the 'LoanAccountLock' entity.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations including batch finds, batch deletes, and single entity lookups.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "n/a" }, { "path": "org.apache.fineract.cob.loan.RetrieveLoanIdConfiguration", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The configuration class injects and utilizes a Spring Data 'LoanRepository' and a Spring JDBC 'NamedParameterJdbcTemplate'. While this specific file does not execute queries, it wires these database access components into the 'RetrieveLoanIdService', enabling downstream database interactions.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "n/a", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Autowired\nprivate LoanRepository loanRepository;\n\n@Autowired\nprivate NamedParameterJdbcTemplate namedParameterJdbcTemplate;" }, { "path": "org.apache.fineract.cob.loan.RetrieveLoanIdService", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The interface defines data access contracts for retrieving loan information. The presence of the @Param annotation on 'findAllStayedLockedByCobBusinessDate' indicates that this interface is likely used as a Spring Data Repository or implemented by a class that utilizes Spring Data JPA features to bind method parameters to database queries.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ" ], "queryPatterns": "The methods imply complex selection criteria based on dates, status (closed/non-closed), and ID ranges, likely involving WHERE clauses with multiple conditions.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "List findAllStayedLockedByCobBusinessDate(@Param(\"cobBusinessDate\") LocalDate cobBusinessDate);" }, { "path": "org.apache.fineract.cob.service", "mechanism": "SPRING-DATA", "name": "LoanAccountLockRepository, CustomJobParameterRepository", "description": "The class interacts with the database primarily through Spring Data JPA repositories to manage loan account locks and custom job parameters. It also utilizes a TransactionTemplate to enforce specific transaction propagation behaviors (REQUIRES_NEW) when locking loan accounts to ensure locks are committed independently of the main flow.", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock", "CustomJobParameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via JPA repositories.", "transactionHandling": "Spring @Transactional annotations and manual TransactionTemplate usage with PROPAGATION_REQUIRES_NEW.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "loanAccountLockRepository.saveAndFlush(loanAccountLock);" }, { "path": "org.apache.fineract.cob.service", "mechanism": "SPRING-DATA", "name": "ScheduledJobDetailRepository", "description": "The class uses Spring Data repositories to access job configuration details. Specifically, it uses ScheduledJobDetailRepository to find job details by name. It also relies on RetrieveLoanIdService which likely performs database queries to fetch loan dates.", "databaseName": "unknown", "tablesAccessed": [ "ScheduledJobDetail" ], "operationType": [ "READ" ], "queryPatterns": "Simple repository find method", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "ScheduledJobDetail scheduledJobDetail = scheduledJobDetailRepository.findByJobName(LoanCOBConstant.JOB_HUMAN_READABLE_NAME);" }, { "path": "org.apache.fineract.cob.service", "mechanism": "SPRING-DATA", "name": "JobExecutionRepository", "description": "The class interacts with the database primarily through the `JobExecutionRepository` (likely a Spring Data JPA repository) to query job execution history and status. It also indirectly accesses data via `RetrieveLoanIdService`.", "databaseName": "unknown", "tablesAccessed": [ "BATCH_JOB_EXECUTION", "BATCH_JOB_EXECUTION_PARAMS" ], "operationType": [ "READ" ], "queryPatterns": "The code performs specific lookups for job execution data based on parameter values.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "LocalDate runningCatchUpBusinessDate = jobExecutionRepository.getBusinessDateOfRunningJobByExecutionParameter(\n LoanCOBConstant.JOB_NAME, LoanCOBConstant.LOAN_COB_CUSTOM_JOB_PARAMETER_KEY, LoanCOBConstant.IS_CATCH_UP_PARAMETER_NAME,\n \"true\", LoanCOBConstant.BUSINESS_DATE_PARAMETER_NAME);" }, { "path": "org.apache.fineract.cob.service.ConfigJobParameterServiceImpl", "mechanism": "SPRING-DATA", "name": "BatchBusinessStepRepository", "description": "The class uses a Spring Data JPA repository (BatchBusinessStepRepository) to perform CRUD operations on the BatchBusinessStep entity.", "databaseName": "unknown", "tablesAccessed": [ "BatchBusinessStep" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard Spring Data JPA repository methods (findAllByJobName, deleteAllByJobName, save, findConfiguredJobNames).", "transactionHandling": "Spring @Transactional (implied by Service/Repository usage, though not explicitly annotated on this class)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "batchBusinessStepRepository.deleteAllByJobName(jobName);" }, { "path": "org.apache.fineract.cob.service.LoanAccountLockServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanAccountLockRepository", "description": "The class interacts with the database through the LoanAccountLockRepository, which is a Spring Data repository interface. It performs standard CRUD operations (findAll) as well as custom queries (existsByLoanIdAndLockOwner, updateLoanFromAccountLocks, removeLockByOwner).", "databaseName": "unknown", "tablesAccessed": [ "LoanAccountLock" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Includes pagination (findAll), existence checks with criteria (existsByLoanIdAndLockOwner), and likely custom update/delete queries defined in the repository.", "transactionHandling": "Uses Spring's @Transactional annotation with Propagation.REQUIRES_NEW for the updateCobAndRemoveLocks method.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Page loanAccountLocks = loanAccountLockRepository.findAll(loanAccountLockPage);" }, { "path": "org.apache.fineract.commands.domain.CommandSourceRepository", "mechanism": "SPRING-DATA", "name": "CommandSourceRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines custom JPQL queries for specific business requirements.", "databaseName": "unknown", "tablesAccessed": [ "CommandSource" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The repository uses a derived query method for simple lookups and a custom JPQL query for batch deletion.", "transactionHandling": "Spring @Transactional (implied by @Modifying annotation usage)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"delete from CommandSource c where c.status = :status and c.madeOnDate is not null and c.madeOnDate <= :dateForPurgeCriteria\")" }, { "path": "org.apache.fineract.commands.jobs", "mechanism": "SPRING-DATA", "name": "CommandSourceRepository", "description": "The class interacts with the database through the CommandSourceRepository interface, which is likely a Spring Data JPA repository. It performs a bulk delete operation based on status and date criteria.", "databaseName": "unknown", "tablesAccessed": [ "m_command_source" ], "operationType": [ "WRITE" ], "queryPatterns": "The code performs a delete operation based on a specific status (PROCESSED) and a timestamp comparison (older than a calculated date).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "repository.deleteOlderEventsWithStatus(CommandProcessingResultType.PROCESSED.getValue(), dateForPurgeCriteria);" }, { "path": "org.apache.fineract.commands.service", "mechanism": "SPRING-DATA", "name": "CommandSourceRepository", "description": "The class uses a Spring Data repository (CommandSourceRepository) to perform CRUD operations on CommandSource entities. It retrieves entities by ID, saves updates (for rejections), and deletes entities.", "databaseName": "unknown", "tablesAccessed": [ "CommandSource" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, save, deleteById)", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.commandSourceRepository.deleteById(makerCheckerId);" }, { "path": "org.apache.fineract.commands.service.CommandSourceService", "mechanism": "SPRING-DATA", "name": "CommandSourceRepository", "description": "The class uses a Spring Data JPA repository (`CommandSourceRepository`) to perform CRUD operations on the `CommandSource` entity. It utilizes standard methods like `saveAndFlush` and `findById`, as well as a custom finder method for idempotency checks.", "databaseName": "unknown", "tablesAccessed": [ "CommandSource" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and a specific lookup by composite business keys (action, entity, idempotency key).", "transactionHandling": "Spring @Transactional annotations are used extensively with specific propagation (REQUIRES_NEW, REQUIRED) and isolation (REPEATABLE_READ) settings.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return commandSourceRepository.saveAndFlush(initialCommandSource);" }, { "path": "org.apache.fineract.commands.service.SynchronousCommandProcessingService", "mechanism": "SPRING-DATA", "name": "CommandSourceService", "description": "The class interacts with the database primarily through the `CommandSourceService` to persist and update `CommandSource` entities. It uses Spring's `@Transactional` annotation to manage transaction boundaries, ensuring that command state updates (initial, success, error) are committed atomically. It also interacts with `ConfigurationDomainService` to read configuration settings from the database.", "databaseName": "unknown", "tablesAccessed": [ "m_command_source", "m_appuser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Transactional CRUD operations on CommandSource entities; lookup of configuration settings.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "commandSource = sameTransaction ? commandSourceService.saveInitialSameTransaction(wrapper, command, user, idempotencyKey)\n : commandSourceService.saveInitialNewTransaction(wrapper, command, user, idempotencyKey);" }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.domain", "mechanism": "SPRING-DATA", "name": "AccountNumberFormatRepository", "description": "The file is a Spring Data JPA repository interface that manages persistence for the AccountNumberFormat entity. It inherits standard database operations from JpaRepository and defines a custom read operation using JPQL.", "databaseName": "unknown", "tablesAccessed": [ "AccountNumberFormat" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Uses standard Spring Data CRUD operations and a custom JPQL query for filtering by account type.", "transactionHandling": "Spring Data JPA repositories typically participate in existing transactions or create read-only transactions for query methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(FIND_ACCOUNT_NUMBER_FORMAT_FOR_ENTITY)\nAccountNumberFormat findOneByAccountTypeEnum(@Param(\"accountTypeEnum\") Integer accountTypeEnum);" }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.domain", "mechanism": "SPRING-DATA", "name": "AccountNumberFormatRepository", "description": "The class wraps a Spring Data repository (`AccountNumberFormatRepository`) to perform database operations. It relies on Spring Data JPA's abstraction to generate SQL for standard CRUD operations and custom finders.", "databaseName": "unknown", "tablesAccessed": [ "AccountNumberFormat" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and a specific lookup by account type enum value.", "transactionHandling": "Likely relies on Spring's @Transactional at the service layer or default repository transaction settings.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public AccountNumberFormat findOneWithNotFoundDetection(final Long id) {\n return this.repository.findById(id).orElseThrow(() -> new AccountNumberFormatNotFoundException(id));\n}" }, { "path": "org.apache.fineract.infrastructure.accountnumberformat.service", "mechanism": "SPRING-DATA", "name": "AccountNumberFormatRepositoryWrapper", "description": "The class uses a repository wrapper (likely wrapping a Spring Data JpaRepository) to interact with the database. It performs CRUD operations on the AccountNumberFormat entity. Transactions are managed using Spring's @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "AccountNumberFormat" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository methods (saveAndFlush, findOneWithNotFoundDetection, delete).", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.accountNumberFormatRepository.saveAndFlush(accountNumberFormat);" }, { "path": "org.apache.fineract.infrastructure.bulkimport.domain", "mechanism": "SPRING-DATA", "name": "ImportDocumentRepository", "description": "The interface is a Spring Data JPA repository. It automatically generates SQL queries at runtime to interact with the database table mapped to the ImportDocument entity.", "databaseName": "unknown", "tablesAccessed": [ "ImportDocument" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, delete, findById) and dynamic specification-based queries.", "transactionHandling": "Transactions are handled by the Spring Data JPA framework, which typically applies @Transactional to repository methods by default.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ImportDocumentRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.infrastructure.bulkimport.importhandler.chartofaccounts.ChartOfAccountsImportHandler", "mechanism": "SPRING-DATA", "name": "GLAccountRepositoryWrapper", "description": "The class uses a repository wrapper to query existing GL Accounts from the database. This is primarily used during the processing of opening balances to verify that the GL Account referenced in the Excel file exists and to retrieve its ID.", "databaseName": "unknown", "tablesAccessed": [ "m_gl_account" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by GL Code", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "GLAccount glAccount = this.glAccountRepository.findOneByGlCodeWithNotFoundDetection(glCode);" }, { "path": "org.apache.fineract.infrastructure.bulkimport.service.BulkImportEventListener", "mechanism": "SPRING-DATA", "name": "ImportDocumentRepository", "description": "The class uses a Spring Data repository to retrieve and update `ImportDocument` entities. It fetches the document metadata before processing and updates it with success/error counts after processing.", "databaseName": "unknown", "tablesAccessed": [ "ImportDocument" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via Spring Data JPA (findById, saveAndFlush).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ImportDocument importDocument = this.importRepository.findById(event.getImportId()).orElse(null);\n// ... processing ...\nthis.importRepository.saveAndFlush(importDocument);" }, { "path": "org.apache.fineract.infrastructure.bulkimport.service.BulkImportWorkbookServiceImpl", "mechanism": "SPRING-DATA", "name": "ImportDocumentRepository & JdbcTemplate", "description": "The class uses a hybrid approach: it uses Spring Data JPA (ImportDocumentRepository) for saving new import records and Spring JDBC (JdbcTemplate) for querying import history and document locations with raw SQL.", "databaseName": "unknown", "tablesAccessed": [ "m_import_document", "m_document" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The write operations use JPA saveAndFlush. The read operations use inline SQL queries with joins between the import document table and the document table.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final String sql = \"select \" + rm.schema() + \" order by i.id desc\";\nreturn this.jdbcTemplate.query(sql, rm, new Object[] { type.getValue() });" }, { "path": "org.apache.fineract.infrastructure.businessdate.domain.BusinessDateRepository", "mechanism": "SPRING-DATA", "name": "BusinessDateRepository", "description": "The interface extends JpaRepository to provide automatic database interaction for the BusinessDate entity.", "databaseName": "unknown", "tablesAccessed": [ "BusinessDate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD and derived query methods", "transactionHandling": "Spring @Transactional (default for JpaRepository)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "Optional findByType(BusinessDateType type);" }, { "path": "org.apache.fineract.infrastructure.businessdate.service", "mechanism": "SPRING-DATA", "name": "BusinessDateRepository", "description": "The class uses a Spring Data repository interface (BusinessDateRepository) to interact with the underlying database for retrieving BusinessDate entities.", "databaseName": "unknown", "tablesAccessed": [ "BusinessDate" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations (findAll, findByType)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List businessDateList = repository.findAll();" }, { "path": "org.apache.fineract.infrastructure.businessdate.service.BusinessDateWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "BusinessDateRepository", "description": "The class uses a Spring Data JPA repository (`BusinessDateRepository`) to interact with the database. It performs lookups by business date type and saves new or updated `BusinessDate` entities.", "databaseName": "unknown", "tablesAccessed": [ "BusinessDate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findByType, save)", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "Optional businessDate = repository.findByType(businessDateType);\nif (businessDate.isEmpty()) {\n repository.save(newBusinessDate);\n}" }, { "path": "org.apache.fineract.infrastructure.cache.command.UpdateCacheCommandHandler", "mechanism": "SPRING-DATA", "name": "CacheWritePlatformService", "description": "The class uses Spring's @Transactional annotation to manage database transactions for the cache update operation. While the direct database access logic resides in the injected CacheWritePlatformService, this handler defines the transaction boundary.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ_WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {" }, { "path": "org.apache.fineract.infrastructure.cache.domain.PlatformCacheRepository", "mechanism": "SPRING-DATA", "name": "PlatformCacheRepository", "description": "The file uses Spring Data JPA to manage persistence for the PlatformCache entity. By extending JpaRepository, it inherits standard CRUD operations, pagination, and sorting capabilities. By extending JpaSpecificationExecutor, it allows for dynamic query construction using the Criteria API.", "databaseName": "unknown", "tablesAccessed": [ "PlatformCache" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specifications provided by Spring Data JPA.", "transactionHandling": "Spring Data Repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JPA", "connectionInfo": "configured in application.properties/yml", "codeExample": "public interface PlatformCacheRepository extends JpaRepository, JpaSpecificationExecutor {\n //\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain", "mechanism": "SPRING-DATA", "name": "EmailMessageRepository, GroupRepositoryWrapper, ClientRepositoryWrapper, StaffRepositoryWrapper", "description": "The class interacts with the database to retrieve existing entities (Group, Client, Staff, EmailMessage) using repository patterns. It uses both direct Spring Data repositories and wrapper classes that likely encapsulate JPA `EntityManager` or Spring Data calls with additional error handling (like 'Not Found' detection).", "databaseName": "unknown", "tablesAccessed": [ "EmailMessage", "Group", "Client", "Staff" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID (CRUD READ operations).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "group = this.groupRepository.findOneWithNotFoundDetection(groupId);" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain.EmailCampaignRepository", "mechanism": "SPRING-DATA", "name": "EmailCampaignRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends `JpaRepository` to inherit standard methods and defines a custom JPQL query for specific filtering logic.", "databaseName": "unknown", "tablesAccessed": [ "EmailCampaign" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with dynamic criteria and standard CRUD operations", "transactionHandling": "Spring @Transactional annotations (implicit in Spring Data)", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Query(\"SELECT campaign FROM EmailCampaign campaign WHERE campaign.paramValue LIKE :reportPattern...\")" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain.EmailConfigurationRepository", "mechanism": "SPRING-DATA", "name": "EmailConfigurationRepository", "description": "The interface utilizes Spring Data JPA to manage database interactions for the EmailConfiguration entity. It abstracts the JDBC and JPA boilerplate code, providing a high-level API for data persistence.", "databaseName": "unknown", "tablesAccessed": [ "EmailConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a simple property-based lookup (findByName).", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface EmailConfigurationRepository extends JpaRepository { EmailConfiguration findByName(String name); }" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.domain.EmailMessageRepository", "mechanism": "SPRING-DATA", "name": "EmailMessageRepository", "description": "The interface extends JpaRepository and JpaSpecificationExecutor, indicating it is a Spring Data JPA repository used for database persistence.", "databaseName": "unknown", "tablesAccessed": [ "EmailMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Derived query methods and standard CRUD operations provided by JpaRepository.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository implementation)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface EmailMessageRepository extends JpaRepository, JpaSpecificationExecutor {\n List findByStatusType(Integer emailMessageStatus);\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "SPRING-DATA", "name": "EmailMessageRepository", "description": "The service uses an injected EmailMessageRepository (likely extending JpaRepository) to perform CRUD operations on EmailMessage entities. It uses @Transactional to ensure atomicity of database operations.", "databaseName": "unknown", "tablesAccessed": [ "EmailMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, delete, find)", "transactionHandling": "Spring @Transactional annotations on service methods", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.saveAndFlush(message);" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "SPRING-DATA", "name": "EmailCampaignRepository", "description": "The service interacts with the database to retrieve active email campaigns using a Spring Data repository. It executes a query to find campaigns matching a specific parameter value (trigger type) and status.", "databaseName": "unknown", "tablesAccessed": [ "EmailCampaign" ], "operationType": [ "READ" ], "queryPatterns": "Repository finder method with wildcard search parameters", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "emailCampaignRepository.findActiveEmailCampaigns(\"%\" + paramValue + \"%\",\n SmsCampaignTriggerType.TRIGGERED.getValue());" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service", "mechanism": "SPRING-DATA", "name": "EmailConfigurationRepository", "description": "The service uses a Spring Data repository to interact with the database. It retrieves all configuration entities and updates them individually.", "databaseName": "unknown", "tablesAccessed": [ "EmailConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations: findAll to retrieve all records and saveAndFlush for updates.", "transactionHandling": "Implicitly handled by Spring Data repository methods or service layer transaction management (though @Transactional is not explicitly present on this class).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Collection configurations = this.repository.findAll();\n// ...\nthis.repository.saveAndFlush(config);" }, { "path": "org.apache.fineract.infrastructure.campaigns.email.service.EmailCampaignWritePlatformCommandHandlerImpl", "mechanism": "SPRING-DATA", "name": "EmailCampaignRepository, EmailMessageRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on EmailCampaign and EmailMessage entities. It also interacts with the ReportRepository to fetch business rules.", "databaseName": "unknown", "tablesAccessed": [ "EmailCampaign", "EmailMessage", "Report", "Client", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, save) combined with some complex reporting queries executed via a separate service.", "transactionHandling": "Spring @Transactional annotations on public methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.emailCampaignRepository.saveAndFlush(emailCampaign);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.executeemail", "mechanism": "SPRING-DATA", "name": "Fineract Repositories", "description": "The class injects multiple Spring Data repositories (EmailMessageRepository, EmailCampaignRepository, LoanRepository, SavingsAccountRepository) and passes them to the tasklet. While this configuration class does not execute queries directly, it wires the components that perform database operations.", "databaseName": "unknown", "tablesAccessed": [ "EmailMessage", "EmailCampaign", "Loan", "SavingsAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The repositories likely perform CRUD operations required for processing email campaigns.", "transactionHandling": "Spring Batch Step transaction management via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Autowired\nprivate EmailMessageRepository emailMessageRepository;\n// ...\n@Bean\npublic ExecuteEmailTasklet executeEmailTasklet() {\n return new ExecuteEmailTasklet(emailMessageRepository, ...);\n}" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.executeemail.ExecuteEmailTasklet", "mechanism": "SPRING-DATA", "name": "EmailMessageRepository, EmailCampaignRepository, LoanRepository, SavingsAccountRepository", "description": "The class uses Spring Data JPA repositories to fetch pending email messages, retrieve campaign details, and look up related business entities (Loans, SavingsAccounts) for report generation. It also updates the status of EmailMessage entities.", "databaseName": "unknown", "tablesAccessed": [ "EmailMessage", "EmailCampaign", "Loan", "SavingsAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository finders (findByStatusType, findById, findLoanByClientId, findSavingAccountByClientId) and save operations.", "transactionHandling": "Implicitly handled by Spring Batch step transaction management, though not explicitly annotated in this class.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final List emailMessages = emailMessageRepository.findByStatusType(EmailMessageStatusType.PENDING.getValue());" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.executereportmailingjobs.ExecuteReportMailingJobsConfig", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRepository", "description": "The class injects Spring Data repositories (`ReportMailingJobRepository` and `ReportMailingJobRunHistoryRepository`) and passes them to the tasklet. While this configuration class does not execute queries directly, it wires the components that perform database operations.", "databaseName": "unknown", "tablesAccessed": [ "m_report_mailing_job", "m_report_mailing_job_run_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository methods used for CRUD operations on report mailing jobs and history.", "transactionHandling": "Spring Batch manages transactions at the Step level via the PlatformTransactionManager.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Autowired\nprivate ReportMailingJobRepository reportMailingJobRepository;\n@Autowired\nprivate ReportMailingJobRunHistoryRepository reportMailingJobRunHistoryRepository;" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.executereportmailingjobs.ExecuteReportMailingJobsTasklet", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It retrieves job configurations and saves execution history and updates job schedules.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJob", "ReportMailingJobRunHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository find methods and save operations.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Collection reportMailingJobCollection = reportMailingJobRepository.findByIsActiveTrueAndIsDeletedFalse();\n// ...\nreportMailingJobRepository.save(reportMailingJob);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.getdeliveryreportsfromsmsgateway", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The code uses a Spring Data repository (`SmsMessageRepository`) to interact with the database. It retrieves `SmsMessage` entities by ID and saves them after updating their status and external ID. It also uses a service (`SmsReadPlatformService`) which likely executes a read-only query to find messages waiting for reports.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, save) combined with a service-level query for retrieving pending items.", "transactionHandling": "Implicitly handled by Spring Data repository methods or the surrounding Spring Batch transaction management.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "SmsMessage smsMessage = smsMessageRepository.findById(smsMessageDeliveryReportData.getId()).orElse(null);\n// ... status mapping logic ...\nsmsMessage.setStatusType(statusType);\nsmsMessageRepository.save(smsMessage);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.getdeliveryreportsfromsmsgateway", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The class injects a Spring Data repository interface (SmsMessageRepository) and passes it to the tasklet bean. This indicates that the resulting job will perform database operations (likely reading and updating SMS message records) via this repository.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository method calls within the tasklet", "transactionHandling": "Spring Batch Step transaction management via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Autowired\nprivate SmsMessageRepository smsMessageRepository;\n...\nreturn new GetDeliveryReportsFromSmsGatewayTasklet(..., smsMessageRepository);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.sendmessagetosmsgateway.SendMessageToSmsGatewayConfig", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The class injects a Spring Data repository (`SmsMessageRepository`) and passes it to the batch tasklet. This repository is used to interact with the database table storing SMS messages.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard Spring Data repository patterns (likely finding pending messages and updating their status).", "transactionHandling": "Spring Batch Step transaction management via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Autowired\nprivate SmsMessageRepository smsMessageRepository;\n...\nreturn new SendMessageToSmsGatewayTasklet(smsMessageRepository, ...);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.sendmessagetosmsgateway.SendMessageToSmsGatewayTasklet", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The class uses a Spring Data repository interface to interact with the database for retrieving and updating SMS message entities.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations with pagination (findByStatusType, saveAll).", "transactionHandling": "Likely handled by Spring Batch transaction management at the step level.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "org.springframework.data.domain.Page pendingMessages = smsMessageRepository\n .findByStatusType(SmsMessageStatusType.PENDING.getValue(), pageRequest);\n// ... processing ...\nsmsMessageRepository.saveAll(toSaveMessages);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.updateemailoutboundwithcampaignmessage", "mechanism": "SPRING-DATA", "name": "EmailCampaignRepository, EmailMessageRepository", "description": "The class injects Spring Data repositories and passes them to the batch tasklet. While this configuration file does not execute queries directly, it wires the components that perform database operations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The repositories likely perform CRUD operations required to update email campaigns.", "transactionHandling": "Spring Batch Step transaction management via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Autowired\nprivate EmailCampaignRepository emailCampaignRepository;\n// ...\nreturn new UpdateEmailOutboundWithCampaignMessageTasklet(..., emailCampaignRepository, ...);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.updateemailoutboundwithcampaignmessage", "mechanism": "SPRING-DATA", "name": "EmailCampaignRepository, EmailMessageRepository", "description": "The class interacts with the database using Spring Data JPA repositories to manage campaign and message entities. It reads campaign configurations, fetches client details via a wrapper, and persists generated email messages to an outbound table.", "databaseName": "unknown", "tablesAccessed": [ "EmailCampaign", "EmailMessage", "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository findById and save operations, plus report execution via service.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "EmailMessage emailMessage = EmailMessage.pendingEmail(null, client, null, emailCampaign, emailSubject, message, emailAddress, campaignName);\nemailMessageRepository.save(emailMessage);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.updatesmsoutboundwithcampaignmessage", "mechanism": "SPRING-DATA", "name": "SmsCampaignRepository", "description": "The configuration class injects a Spring Data repository (SmsCampaignRepository) and passes it to the Tasklet bean. While this class does not execute queries directly, it wires the component that performs database operations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository usage delegated to Tasklet", "transactionHandling": "Spring Batch manages transactions via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Autowired\nprivate SmsCampaignRepository smsCampaignRepository;\n// ...\nreturn new UpdateSmsOutboundWithCampaignMessageTasklet(smsCampaignRepository, smsCampaignWritePlatformService);" }, { "path": "org.apache.fineract.infrastructure.campaigns.jobs.updatesmsoutboundwithcampaignmessage.UpdateSmsOutboundWithCampaignMessageTasklet", "mechanism": "SPRING-DATA", "name": "SmsCampaignRepository", "description": "The class interacts with the database using a Spring Data JPA repository (`SmsCampaignRepository`) to fetch and update `SmsCampaign` entities. It also uses a service (`SmsCampaignWritePlatformService`) which implies further database interactions for inserting outbound messages.", "databaseName": "unknown", "tablesAccessed": [ "SmsCampaign", "sms_outbound_messages" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository find methods and save operations.", "transactionHandling": "Likely handled by the Spring Batch framework or the service layer methods invoked.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Collection smsCampaignDataCollection = smsCampaignRepository\n .findByTriggerTypeAndStatus(SmsCampaignTriggerType.SCHEDULE.getValue(), SmsCampaignStatus.ACTIVE.getValue());\n// ...\nthis.smsCampaignRepository.saveAndFlush(smsCampaign);" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.domain", "mechanism": "SPRING-DATA", "name": "SmsCampaignRepository", "description": "The file is a Spring Data JPA repository interface that manages persistence for the `SmsCampaign` entity. It provides database interaction without boilerplate code by extending `JpaRepository`. It uses method naming conventions to generate SQL queries automatically and includes a custom JPQL query for more complex filtering logic involving pattern matching and hardcoded status checks.", "databaseName": "unknown", "tablesAccessed": [ "SmsCampaign" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The repository uses Spring Data's derived query methods for simple equality checks (e.g., `findByCampaignType`) and a custom JPQL query with a `LIKE` clause for pattern matching.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data JPA implementation proxy)", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT campaign FROM SmsCampaign campaign WHERE campaign.paramValue LIKE :reportPattern AND campaign.triggerType=:triggerType AND campaign.status=300\")" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.serialization.SmsCampaignValidator", "mechanism": "SPRING-DATA", "name": "DeviceRegistrationRepositoryWrapper", "description": "The class uses a repository wrapper to query the database for device registrations. This is used to validate if a client is eligible to receive push notifications.", "databaseName": "unknown", "tablesAccessed": [ "DeviceRegistration" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by Client ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "DeviceRegistration deviceRegistration = this.deviceRegistrationRepository.findDeviceRegistrationByClientId(client.getId());" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignDomainServiceImpl", "mechanism": "SPRING-DATA", "name": "SmsCampaignRepository, SmsMessageRepository, OfficeRepository, GroupRepository", "description": "The service uses Spring Data JPA repositories to interact with the database. It retrieves SMS campaign configurations, office hierarchy information, and group details. It also persists generated SMS messages.", "databaseName": "unknown", "tablesAccessed": [ "m_sms_campaign", "m_sms_message", "m_office", "m_group" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs lookups for active campaigns using LIKE queries, finds entities by ID, and saves new message entities.", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "List smsCampaigns = smsCampaignRepository.findActiveSmsCampaigns(\"%\" + paramValue + \"%\",\n SmsCampaignTriggerType.TRIGGERED.getValue());" }, { "path": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignWritePlatformServiceJpaImpl", "mechanism": "SPRING-DATA", "name": "SmsCampaignRepository, SmsMessageRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on SmsCampaign and SmsMessage entities, and also interacts with Report, Client, and Group entities via their respective repositories.", "databaseName": "unknown", "tablesAccessed": [ "SmsCampaign", "SmsMessage", "Report", "Client", "Group", "SavingsAccount", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, saveAndFlush, save) combined with some dynamic report execution via ReadReportingService.", "transactionHandling": "Spring @Transactional annotations on write methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.smsCampaignRepository.saveAndFlush(smsCampaign);" }, { "path": "org.apache.fineract.infrastructure.codes.domain", "mechanism": "SPRING-DATA", "name": "CodeValueRepository", "description": "The class interacts with the database through the CodeValueRepository interface, which is likely a Spring Data JPA repository. It performs read operations to fetch CodeValue entities by ID, or by combinations of code name, ID, and label.", "databaseName": "unknown", "tablesAccessed": [ "CodeValue" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookups using ID and field combinations.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new CodeValueNotFoundException(id));" }, { "path": "org.apache.fineract.infrastructure.codes.domain.CodeRepository", "mechanism": "SPRING-DATA", "name": "CodeRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. By extending JpaRepository, it gains automatic implementation of standard data access operations for the 'Code' entity.", "databaseName": "unknown", "tablesAccessed": [ "Code" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific property-based lookup (findOneByName).", "transactionHandling": "Spring Data repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JPA/JDBC", "connectionInfo": "unknown", "codeExample": "public interface CodeRepository extends JpaRepository, JpaSpecificationExecutor {\n Code findOneByName(String name);\n}" }, { "path": "org.apache.fineract.infrastructure.codes.domain.CodeValueRepository", "mechanism": "SPRING-DATA", "name": "CodeValueRepository", "description": "The file is a Spring Data JPA repository interface. It provides database access for the 'CodeValue' entity by extending JpaRepository, which offers standard CRUD and paging operations, and JpaSpecificationExecutor for dynamic criteria-based queries.", "databaseName": "unknown", "tablesAccessed": [ "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived queries (findBy...) and standard CRUD operations inherited from JpaRepository.", "transactionHandling": "Spring @Transactional (default behavior for JpaRepository methods)", "protocol": "JDBC (via Hibernate/JPA)", "connectionInfo": "unknown", "codeExample": "public interface CodeValueRepository extends JpaRepository, JpaSpecificationExecutor { ... }" }, { "path": "org.apache.fineract.infrastructure.codes.handler.DeleteCodeCommandHandler", "mechanism": "SPRING-DATA", "name": "CodeWritePlatformService", "description": "The class manages database transactions via the Spring `@Transactional` annotation, delegating the actual persistence operations to the `CodeWritePlatformService`. While it does not contain direct SQL or repository calls, it orchestrates the transactional write operation.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.deleteCode(command.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.codes.service", "mechanism": "SPRING-DATA", "name": "CodeValueRepository", "description": "The class uses Spring Data JPA repositories (CodeRepository and CodeValueRepository) to interact with the database. It performs CRUD operations on Code and CodeValue entities within transactional boundaries.", "databaseName": "unknown", "tablesAccessed": [ "Code", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, saveAndFlush) without complex custom queries.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.codeValueRepository.saveAndFlush(codeValue);" }, { "path": "org.apache.fineract.infrastructure.codes.service.CodeWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "CodeRepository", "description": "The class uses a Spring Data JPA repository (CodeRepository) to interact with the database. It performs CRUD operations on the 'Code' entity.", "databaseName": "unknown", "tablesAccessed": [ "Code" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, findById, delete) delegated to the JPA repository.", "transactionHandling": "Spring @Transactional annotations on public methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.codeRepository.saveAndFlush(code);" }, { "path": "org.apache.fineract.infrastructure.configuration.domain", "mechanism": "SPRING-DATA", "name": "GlobalConfigurationRepository", "description": "The class interacts with the database through the injected GlobalConfigurationRepository, which is likely a Spring Data JPA repository interface. It performs standard CRUD operations (find, save, delete) on GlobalConfigurationProperty entities.", "databaseName": "unknown", "tablesAccessed": [ "GlobalConfigurationProperty" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Repository interface", "transactionHandling": "Likely handled by the underlying Spring Data Repository or service layer transaction boundaries (not explicitly defined in this file)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findOneByName(propertyName);" }, { "path": "org.apache.fineract.infrastructure.configuration.domain", "mechanism": "SPRING-DATA", "name": "ExternalServicesPropertiesRepository", "description": "The file uses Spring Data JPA to interact with the database, mapping the ExternalServicesProperties entity to a relational table.", "databaseName": "unknown", "tablesAccessed": [ "ExternalServicesProperties" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in Spring Data Repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"SELECT ep from ExternalServicesProperties ep where ep.externalServicePropertiesPK.name=:name...\")" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.ConfigurationDomainServiceJpa", "mechanism": "SPRING-DATA", "name": "GlobalConfigurationRepositoryWrapper, PermissionRepository, PlatformCacheRepository", "description": "The class uses injected repository interfaces (likely extending Spring Data JpaRepository) to interact with the database. It retrieves global configuration settings, permissions, and cache settings. The 'GlobalConfigurationRepositoryWrapper' is a custom wrapper around the standard repository to handle caching and exception handling.", "databaseName": "unknown", "tablesAccessed": [ "c_configuration", "m_permission", "c_cache" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and find-by-name queries.", "transactionHandling": "Spring @Transactional annotations are used on the class and specific methods (e.g., updateCache).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.cacheTypeRepository.findById(1L).ifPresent(cache -> {\n cache.setCacheType(cacheType.getValue());\n this.cacheTypeRepository.save(cache);\n});" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.ExternalServicesPropertiesRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ExternalServicesPropertiesRepository", "description": "The class interacts with the database through a Spring Data repository interface. It performs read operations to fetch configuration properties based on a composite primary key.", "databaseName": "unknown", "tablesAccessed": [ "ExternalServicesProperties" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookup by composite key", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ExternalServicesProperties externalServicesProperties = this.repository.findOneByExternalServicePropertiesPK(name, id);" }, { "path": "org.apache.fineract.infrastructure.configuration.domain.GlobalConfigurationRepository", "mechanism": "SPRING-DATA", "name": "GlobalConfigurationRepository", "description": "The interface uses Spring Data JPA to interact with the database. It inherits standard CRUD operations (save, findAll, delete) from JpaRepository and defines a custom finder method.", "databaseName": "unknown", "tablesAccessed": [ "GlobalConfigurationProperty" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific property lookup by name.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface GlobalConfigurationRepository\n extends JpaRepository..." }, { "path": "org.apache.fineract.infrastructure.configuration.service", "mechanism": "SPRING-DATA", "name": "ExternalServicesPropertiesRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects ExternalServicesPropertiesRepository and a wrapper to perform read and write operations on ExternalServicesProperties entities.", "databaseName": "unknown", "tablesAccessed": [ "ExternalServicesProperties" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findOneByIdAndName, saveAndFlush).", "transactionHandling": "Spring @Transactional annotation on the class and method level.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.saveAndFlush(externalServicesProperties);" }, { "path": "org.apache.fineract.infrastructure.configuration.service", "mechanism": "SPRING-DATA", "name": "GlobalConfigurationRepositoryWrapper", "description": "The class interacts with the database through a repository wrapper (GlobalConfigurationRepositoryWrapper) which likely delegates to a Spring Data JPA repository. It performs read and write operations on GlobalConfigurationProperty entities within a transactional context.", "databaseName": "unknown", "tablesAccessed": [ "GlobalConfigurationProperty" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (find by ID, save)", "transactionHandling": "Spring @Transactional annotations on methods", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.save(configItemForUpdate);" }, { "path": "org.apache.fineract.infrastructure.core.auditing.CustomAuditingHandler", "mechanism": "SPRING-DATA", "name": "Spring Data Auditing", "description": "This class is a core component of the Spring Data JPA auditing infrastructure. While it does not execute SQL directly, it intercepts entity persistence operations (save/update) to automatically populate auditing fields (createdDate, lastModifiedDate, etc.) on entities before they are written to the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "n/a", "transactionHandling": "Spring @Transactional (implicit in repository operations)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "setDateTimeProvider(fetchDateTimeProvider(source));\nreturn super.markCreated(source);" }, { "path": "org.apache.fineract.infrastructure.core.filters", "mechanism": "SPRING-DATA", "name": "CommandSourceRepository", "description": "The class uses a Spring Data repository (`CommandSourceRepository`) to find entities by ID and a service (`CommandSourceService`) to save updates to the database. It handles transaction boundaries explicitly for these updates.", "databaseName": "unknown", "tablesAccessed": [ "CommandSource" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById) and entity updates via service methods.", "transactionHandling": "Delegates to service methods `saveResultSameTransaction` or `saveResultNewTransaction` based on context.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "commandSourceRepository.findById(commandId).ifPresent(commandSource -> { ... commandSourceService.saveResultNewTransaction(commandSource); });" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "SPRING-DATA", "name": "CreditBureauRepository", "description": "Database integration is achieved through Spring Data JPA repositories. The interface defines the contract for data access, and Spring generates the implementation to interact with the underlying relational database using Hibernate/JPA.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by the framework.", "transactionHandling": "Transactions are managed by the Spring container, typically applying @Transactional behavior to repository methods by default.", "protocol": "JDBC/JPA", "connectionInfo": "configured externally", "codeExample": "public interface CreditBureauRepository extends JpaRepository, JpaSpecificationExecutor {" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "SPRING-DATA", "name": "TokenRepository", "description": "The class interacts with the database through a Spring Data repository interface named TokenRepository. It performs standard CRUD operations (save, delete, read) on the CreditBureauToken entity.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauToken" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to a repository interface.", "transactionHandling": "Likely handled by the underlying Spring Data repository or higher-level services.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.save(token);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "SPRING-DATA", "name": "TokenRepository", "description": "The file is a Spring Data JPA repository interface that manages persistence for the CreditBureauToken entity. It inherits standard database operations from JpaRepository and defines custom JPQL queries.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauToken" ], "operationType": [ "READ_WRITE", "READ" ], "queryPatterns": "JPQL queries via @Query annotation and standard Spring Data CRUD operations.", "transactionHandling": "Spring @Transactional (default for Spring Data repositories)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select creditbureautoken from CreditBureauToken creditbureautoken\")\nCreditBureauToken getToken();" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "SPRING-DATA", "name": "CreditBureauConfigurationRepository", "description": "The class interacts with the database through a Spring Data repository interface. It delegates read operations to the repository, which likely maps to a database table storing credit bureau configurations.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauConfiguration" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by ID and parameter name", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.creditBureauConfigurationRepository.getCreditBureauConfigData(creditBureauID, parameterName);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain", "mechanism": "SPRING-DATA", "name": "CreditBureauConfigurationRepository", "description": "The interface uses Spring Data JPA to interact with the database. It defines custom JPQL queries to select data from the 'CreditBureauConfiguration' entity/table.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL SELECT queries with WHERE clauses filtering by ID and string keys.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JDBC (via JPA)", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT creditBureauConfig from CreditBureauConfiguration creditBureauConfig where creditBureauConfig.organisationCreditbureau.id = :creditBureauID\")" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.CreditBureauLoanProductMappingRepository", "mechanism": "SPRING-DATA", "name": "CreditBureauLoanProductMappingRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends `JpaRepository` to provide standard data access capabilities without boilerplate code.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauLoanProductMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived query methods (findBy...) and standard CRUD operations inherited from JpaRepository.", "transactionHandling": "Spring @Transactional (implicitly handled by the JpaRepository implementation)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "CreditBureauLoanProductMapping findOneByLoanProduct(LoanProduct loanProduct);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.CreditReportRepository", "mechanism": "SPRING-DATA", "name": "CreditReportRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard CRUD operations and JpaSpecificationExecutor for dynamic queries. It also defines a custom JPQL query for specific data retrieval.", "databaseName": "unknown", "tablesAccessed": [ "CreditReport" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM queries using JPQL and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT creditBureauReport from CreditReport creditBureauReport where creditBureauReport.nationalId = :nationalId and creditBureauReport.creditBureauId = :creditBureauId \")" }, { "path": "org.apache.fineract.infrastructure.creditbureau.domain.OrganisationCreditBureauRepository", "mechanism": "SPRING-DATA", "name": "OrganisationCreditBureauRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to inherit standard CRUD operations and JpaSpecificationExecutor for dynamic queries.", "databaseName": "unknown", "tablesAccessed": [ "OrganisationCreditBureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data repository proxies)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface OrganisationCreditBureauRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.handler", "mechanism": "SPRING-DATA", "name": "CreditBureauConfigurationWritePlatformService", "description": "The class participates in database integration by defining a transactional boundary using Spring's `@Transactional` annotation. It delegates the actual persistence logic to the `CreditBureauConfigurationWritePlatformService`, which performs the write operation.", "databaseName": "unknown", "tablesAccessed": [ "CREDITBUREAU_CONFIGURATION" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for creation logic", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.addCreditBureauConfiguration(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "SPRING-DATA", "name": "OrganisationCreditBureauRepository", "description": "The class uses Spring Data JPA repositories (OrganisationCreditBureauRepository and CreditBureauRepository) to interact with the database. It performs operations to retrieve entity references by ID and to save/flush entities.", "databaseName": "unknown", "tablesAccessed": [ "OrganisationCreditBureau", "CreditBureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations using repository methods like getReferenceById and saveAndFlush.", "transactionHandling": "Spring @Transactional annotation is used on the update method.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.organisationCreditBureauRepository.saveAndFlush(organisationCreditBureau);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "SPRING-DATA", "name": "CreditBureauLoanProductMappingRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs retrieval (`getReferenceById`) and persistence (`saveAndFlush`) operations on domain entities.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauLoanProductMapping", "OrganisationCreditBureau", "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA Repository methods (getReferenceById, saveAndFlush).", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.creditBureauLoanProductMappingRepository.saveAndFlush(cb_lp);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service", "mechanism": "SPRING-DATA", "name": "CreditBureauConfigurationRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects CreditBureauConfigurationRepository and OrganisationCreditBureauRepository to perform CRUD operations. It uses @Transactional to manage transaction boundaries.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauConfiguration", "OrganisationCreditBureau" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, saveAndFlush, findById, getReferenceById).", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.creditBureauConfigurationRepository.saveAndFlush(cb_config);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service.CreditReportWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "CreditReportRepository, CreditBureauRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects `CreditBureauRepository` to look up bureau details and `CreditReportRepository` to perform CRUD operations (save, delete, find) on credit reports. Transactions are managed via the `@Transactional` annotation.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureau", "CreditReport" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations using Spring Data repository methods (findById, saveAndFlush, delete) and a custom finder method (getThitsaWorksCreditReport).", "transactionHandling": "Spring @Transactional annotations on service methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "creditReport = CreditReport.instance(creditBureauId, nationalId, creditReportArray);\nthis.creditReportRepository.saveAndFlush(creditReport);" }, { "path": "org.apache.fineract.infrastructure.creditbureau.service.ThitsaWorksCreditBureauIntegrationWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "CreditBureauRepositories", "description": "The class uses repository wrappers (TokenRepositoryWrapper, CreditBureauConfigurationRepositoryWrapper) which likely wrap Spring Data JPA repositories to interact with the database. It performs CRUD operations on tokens and reads configuration data.", "databaseName": "unknown", "tablesAccessed": [ "CreditBureauToken", "CreditBureauConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via repository wrappers.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.tokenRepositoryWrapper.save(generatedtoken);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain", "mechanism": "SPRING-DATA", "name": "EntityDatatableChecksRepository", "description": "The file is a Spring Data JPA repository interface. It provides database interaction capabilities without boilerplate code by extending 'JpaRepository'. It defines custom JPQL queries to perform specific lookups on the 'EntityDatatableChecks' table and joins with 'RegisteredDatatable'.", "databaseName": "unknown", "tablesAccessed": [ "EntityDatatableChecks", "RegisteredDatatable" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with inner joins, parameter binding, and null checks.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select t from EntityDatatableChecks t WHERE t.status =:status and t.entity=:entity and t.productId = :productId \")\nList findByEntityStatusAndProduct(@Param(\"entity\") String entity, ...);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.RegisteredDatatableRepository", "mechanism": "SPRING-DATA", "name": "RegisteredDatatableRepository", "description": "The interface utilizes Spring Data JPA to manage database interactions for the RegisteredDatatable entity. It inherits standard data access methods without requiring explicit SQL or JPQL implementation in the file.", "databaseName": "unknown", "tablesAccessed": [ "RegisteredDatatable" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data infrastructure.", "transactionHandling": "Spring Data repositories typically participate in Spring @Transactional contexts defined at the service layer, or use default transaction settings for repository methods.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface RegisteredDatatableRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportParameterRepository", "mechanism": "SPRING-DATA", "name": "ReportParameterRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically generates the implementation for the repository interface to interact with the underlying database tables mapped to the ReportParameter entity.", "databaseName": "unknown", "tablesAccessed": [ "ReportParameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic queries via JPA Specifications.", "transactionHandling": "Transactions are handled implicitly by the Spring Data JPA repository implementation (default @Transactional behavior).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ReportParameterRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportParameterUsageRepository", "mechanism": "SPRING-DATA", "name": "ReportParameterUsageRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access operations without boilerplate code.", "databaseName": "unknown", "tablesAccessed": [ "ReportParameterUsage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and a specific finder method (findByReport) which likely translates to a simple SELECT with a WHERE clause.", "transactionHandling": "Spring @Transactional", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface ReportParameterUsageRepository\n extends JpaRepository..." }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportRepository", "mechanism": "SPRING-DATA", "name": "ReportRepository", "description": "The file uses Spring Data JPA to manage database interactions for the Report entity. By extending JpaRepository, it automatically gains methods for saving, deleting, and finding entities. By extending JpaSpecificationExecutor, it supports complex, dynamic filtering.", "databaseName": "unknown", "tablesAccessed": [ "Report" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria-based queries provided by JpaSpecificationExecutor.", "transactionHandling": "Spring @Transactional (default behavior for Spring Data Repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ReportRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.infrastructure.dataqueries.domain.ReportRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ReportRepository", "description": "The class interacts with the database through a Spring Data repository interface (`ReportRepository`). It performs read operations to fetch entities by their primary key.", "databaseName": "unknown", "tablesAccessed": [ "Report" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD retrieval by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.reportRepository.findById(id).orElseThrow(() -> new ReportNotFoundException(id));" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service", "mechanism": "SPRING-DATA", "name": "ReportRepository, PermissionRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on Report and Permission entities, including saving, flushing, and deleting records. Transaction management is handled via the @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "Report", "ReportParameter", "ReportParameterUsage", "Permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, delete, findById, findOneByCode) with some entity relationship management.", "transactionHandling": "Spring @Transactional annotations on class and methods", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.reportRepository.saveAndFlush(report);" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service.EntityDatatableChecksWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "EntityDatatableChecksRepository", "description": "The class uses a Spring Data JPA repository (`EntityDatatableChecksRepository`) to manage the `EntityDatatableChecks` entity. It also interacts with a `ReadWriteNonCoreDataService` to perform dynamic SQL operations on variable datatables.", "databaseName": "unknown", "tablesAccessed": [ "EntityDatatableChecks", "x_registered_table_name" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA CRUD operations for configuration; Dynamic queries for checking datatable entries.", "transactionHandling": "Spring @Transactional annotations on methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.entityDatatableChecksRepository.saveAndFlush(check);" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.domain", "mechanism": "SPRING-DATA", "name": "DocumentRepository", "description": "This interface is a Spring Data JPA repository that manages the persistence of Document entities. It automatically generates SQL queries based on the inherited methods for saving, deleting, and finding entities.", "databaseName": "unknown", "tablesAccessed": [ "Document" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specifications provided by Spring Data JPA.", "transactionHandling": "Transactions are managed by the Spring container, typically with default @Transactional behavior on inherited methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface DocumentRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.domain.ImageRepository", "mechanism": "SPRING-DATA", "name": "ImageRepository", "description": "The file uses Spring Data JPA to manage database interactions. It extends JpaRepository to inherit standard CRUD operations for the Image entity and JpaSpecificationExecutor to support dynamic queries.", "databaseName": "unknown", "tablesAccessed": [ "Image", "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria-based queries via JpaSpecificationExecutor.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface ImageRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.service", "mechanism": "SPRING-DATA", "name": "ImageRepository, ClientRepositoryWrapper, StaffRepositoryWrapper", "description": "The class interacts with the database using Spring Data repositories (likely wrapped by custom wrappers). It performs CRUD operations on Client, Staff, and Image entities within a transactional context.", "databaseName": "unknown", "tablesAccessed": [ "Image", "Client", "Staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, delete, findOne) via repository abstractions.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.imageRepository.delete(image);" }, { "path": "org.apache.fineract.infrastructure.documentmanagement.service", "mechanism": "SPRING-DATA", "name": "DocumentRepository", "description": "The class uses a Spring Data JPA repository (DocumentRepository) to perform CRUD operations on Document entities.", "databaseName": "unknown", "tablesAccessed": [ "Document" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, delete) are used for simple CRUD operations.", "transactionHandling": "Spring @Transactional annotations are used on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.documentRepository.saveAndFlush(document);" }, { "path": "org.apache.fineract.infrastructure.entityaccess.data.FineractEntityDataValidator", "mechanism": "SPRING-DATA", "name": "Entity Repositories", "description": "The class uses Spring Data repositories and wrapper services to verify the existence of entities referenced in the API requests. It performs read-only operations to ensure referential integrity.", "databaseName": "unknown", "tablesAccessed": [ "m_office", "m_product_loan", "m_savings_product", "m_charge", "m_role" ], "operationType": [ "READ" ], "queryPatterns": "Simple primary key lookups (findById) to check for existence.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "public void checkForLoanProducts(final Long id) {\n this.loanProductRepository.findById(id).orElseThrow(() -> new LoanProductNotFoundException(id));\n}" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain", "mechanism": "SPRING-DATA", "name": "FineractEntityToEntityMappingRepository", "description": "The class interacts with the database through a Spring Data repository interface (FineractEntityToEntityMappingRepository). It performs read operations by ID and delete operations on the FineractEntityToEntityMapping entity.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityToEntityMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, delete) delegated to Spring Data JPA.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.fineractEntityToEntityMappingRepository.findById(id).orElseThrow(...)" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain", "mechanism": "SPRING-DATA", "name": "FineractEntityRelationRepository", "description": "The class interacts with the database through a Spring Data JPA repository interface. It performs read-only operations to fetch entity relation data based on ID or code name.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityRelation" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookups by ID and unique field (codeName).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.fineractEntityRelationRepository.findById(id).orElseThrow(...)" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain", "mechanism": "SPRING-DATA", "name": "FineractEntityToEntityMappingRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard CRUD operations and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityToEntityMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via @Query annotations", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA/JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select feem from FineractEntityToEntityMapping feem where feem.fromId= :fromId and feem.toId= :toId and feem.relationId= :relId\")" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityAccessRepository", "mechanism": "SPRING-DATA", "name": "FineractEntityAccessRepository", "description": "The interface uses Spring Data JPA to interact with the database, abstracting SQL operations for the FineractEntityAccess entity.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityAccess" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicit in Spring Data Repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface FineractEntityAccessRepository\n extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityAccessRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "FineractEntityAccessRepository", "description": "The class wraps a Spring Data repository interface to perform CRUD operations on the database.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityAccess" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to a Spring Data repository.", "transactionHandling": "Relies on the underlying repository's transaction management or the caller's context.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findById(id).orElseThrow(() -> new FineractEntityAccessNotFoundException(id));" }, { "path": "org.apache.fineract.infrastructure.entityaccess.domain.FineractEntityRelationRepository", "mechanism": "SPRING-DATA", "name": "FineractEntityRelationRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityRelation" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implied by Spring Data JPA default implementation)", "protocol": "JDBC (underlying)", "connectionInfo": "unknown", "codeExample": "@Query(\"select fea from FineractEntityRelation fea where fea.codeName= :codeName\")" }, { "path": "org.apache.fineract.infrastructure.entityaccess.service", "mechanism": "SPRING-DATA", "name": "FineractEntityAccessRepository, FineractEntityToEntityMappingRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects repository interfaces and wrapper classes to perform CRUD operations on `FineractEntityAccess` and `FineractEntityToEntityMapping` entities.", "databaseName": "unknown", "tablesAccessed": [ "FineractEntityAccess", "FineractEntityToEntityMapping", "FineractEntityRelation" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA repositories (save, saveAndFlush, delete, findOne).", "transactionHandling": "Spring @Transactional annotations on methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.fineractEntityToEntityMappingRepository.saveAndFlush(newMap);" }, { "path": "org.apache.fineract.infrastructure.entityaccess.service.FineractEntityAccessUtil", "mechanism": "SPRING-DATA", "name": "FineractEntityToEntityMappingRepository", "description": "The class uses Spring Data repositories (via wrappers) to read global configurations and entity relations, and to persist new entity-to-entity mappings.", "databaseName": "unknown", "tablesAccessed": [ "m_entity_to_entity_mapping", "m_entity_relation", "c_configuration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via repository methods (save, findOne).", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.fineractEntityToEntityMappingRepository.save(newMap);" }, { "path": "org.apache.fineract.infrastructure.event.business.service", "mechanism": "SPRING-DATA", "name": "ExternalEventConfigurationRepository", "description": "The class uses a Spring Data repository to query configuration settings for external events. It checks if specific event types are enabled for external broadcasting.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by event type", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "eventConfigurationRepository.findExternalEventConfigurationByTypeWithNotFoundDetection(eventType).isEnabled()" }, { "path": "org.apache.fineract.infrastructure.event.external.jobs.PurgeExternalEventsTasklet", "mechanism": "SPRING-DATA", "name": "ExternalEventRepository", "description": "The class uses a Spring Data repository (ExternalEventRepository) to perform bulk deletion of records based on status and date criteria.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEvent" ], "operationType": [ "WRITE" ], "queryPatterns": "Batch deletion based on criteria (status and date)", "transactionHandling": "Likely handled by the Spring Batch framework or the repository implementation", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "repository.deleteOlderEventsWithSentStatus(ExternalEventStatus.SENT, dateForPurgeCriteria);" }, { "path": "org.apache.fineract.infrastructure.event.external.jobs.SendAsynchronousEventsTasklet", "mechanism": "SPRING-DATA", "name": "ExternalEventRepository", "description": "The class uses `ExternalEventRepository` to interact with the database. It reads events with a specific status and updates them after processing.", "databaseName": "unknown", "tablesAccessed": [ "external_event" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD for retrieval and batch updates for status changes.", "transactionHandling": "Spring @Transactional (implied by Spring Batch context)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "repository.findByStatusOrderById(ExternalEventStatus.TO_BE_SENT, batchSize)" }, { "path": "org.apache.fineract.infrastructure.event.external.jobs.SendAsynchronousEventsTaskletTest", "mechanism": "SPRING-DATA", "name": "ExternalEventRepository", "description": "The code under test interacts with a Spring Data repository (ExternalEventRepository) to fetch pending events and update their status. The test mocks this interaction.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEvent" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs a read operation with pagination (findByStatusOrderById) and a write operation to update status (markEventsSent).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "when(repository.findByStatusOrderById(Mockito.any(), Mockito.any())).thenReturn(events);\nverify(repository).markEventsSent(Mockito.eq(events.stream().map(ExternalEventView::getId).toList()), Mockito.any());" }, { "path": "org.apache.fineract.infrastructure.event.external.repository", "mechanism": "SPRING-DATA", "name": "ExternalEventRepository", "description": "The interface extends JpaRepository to provide standard CRUD operations and defines custom JPQL queries for specific business requirements. It interacts with the 'ExternalEvent' table.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEvent" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries including SELECT with pagination, bulk DELETE based on criteria, and bulk UPDATE by ID list.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories, explicit @Modifying usage)", "protocol": "JPA/JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"UPDATE ExternalEvent e SET e.status = ... WHERE e.id IN :ids\")\nvoid markEventsSent(@Param(\"ids\") List ids, ...);" }, { "path": "org.apache.fineract.infrastructure.event.external.repository.CustomExternalEventConfigurationRepository", "mechanism": "SPRING-DATA", "name": "CustomExternalEventConfigurationRepository", "description": "This interface represents a Data Access Object (DAO) or Repository component, likely part of a Spring Data JPA setup. It defines a read operation to fetch configuration data from the database.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEventConfiguration" ], "operationType": [ "READ" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "ExternalEventConfiguration findExternalEventConfigurationByTypeWithNotFoundDetection(String externalEventType);" }, { "path": "org.apache.fineract.infrastructure.event.external.repository.ExternalEventConfigurationRepository", "mechanism": "SPRING-DATA", "name": "ExternalEventConfigurationRepository", "description": "The file is a Spring Data JPA repository interface. It provides database access for the ExternalEventConfiguration entity by extending JpaRepository, which automatically provides CRUD operations.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEventConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by Spring Data JPA, plus potentially complex queries defined in the custom parent interface.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ExternalEventConfigurationRepository\n extends JpaRepository, CustomExternalEventConfigurationRepository {}" }, { "path": "org.apache.fineract.infrastructure.event.external.repository.domain", "mechanism": "SPRING-DATA", "name": "ExternalEventView", "description": "This interface functions as a Spring Data JPA Projection (Closed Projection). It allows the application to retrieve a read-only view of the 'ExternalEvent' entity (or underlying table) containing only the fields defined by the getter methods. This mechanism optimizes database performance by fetching only necessary columns rather than the entire entity graph.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEvent" ], "operationType": [ "READ" ], "queryPatterns": "Simple projection queries generated by Spring Data", "transactionHandling": "Managed by the calling repository method (usually read-only)", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "public interface ExternalEventView {\n Long getId();\n String getType();\n // ... other getters map to columns\n}" }, { "path": "org.apache.fineract.infrastructure.event.external.service", "mechanism": "SPRING-DATA", "name": "ExternalEventConfigurationRepository", "description": "The class interacts with the database through the ExternalEventConfigurationRepository, which is likely a Spring Data JPA repository interface. It performs a read operation to fetch all records of the ExternalEventConfiguration entity.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEventConfiguration" ], "operationType": [ "READ" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List eventConfigurations = repository.findAll();" }, { "path": "org.apache.fineract.infrastructure.event.external.service", "mechanism": "SPRING-DATA", "name": "ExternalEventConfigurationRepository", "description": "The class uses a Spring Data repository interface (`ExternalEventConfigurationRepository`) to perform CRUD operations on `ExternalEventConfiguration` entities.", "databaseName": "unknown", "tablesAccessed": [ "ExternalEventConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs a lookup by event type (likely a SELECT) inside a loop, followed by a batch save operation (INSERT/UPDATE).", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ExternalEventConfiguration configuration = repository\n .findExternalEventConfigurationByTypeWithNotFoundDetection(eventType);\n// ... modification logic ...\nthis.repository.saveAll(modifiedConfigurations);" }, { "path": "org.apache.fineract.infrastructure.event.external.service.serialization.serializer.loan", "mechanism": "SPRING-DATA", "name": "LoanTransactionRepository", "description": "The class uses `LoanTransactionRepository` to retrieve data related to unpaid charges for a specific loan during the serialization process.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_transaction" ], "operationType": [ "READ" ], "queryPatterns": "Simple retrieval of aggregated or list data (unpaid charges) associated with a loan entity.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "List unpaidChargeDataList = loanTransactionRepository.fetchTotalUnpaidChargesForLoan(event.get().getLoan());" }, { "path": "org.apache.fineract.infrastructure.gcm.domain", "mechanism": "SPRING-DATA", "name": "DeviceRegistrationRepository", "description": "The class interacts with the database through a Spring Data repository interface (DeviceRegistrationRepository). It performs standard CRUD operations and custom lookups without writing explicit SQL.", "databaseName": "unknown", "tablesAccessed": [ "DeviceRegistration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and a lookup by Client ID.", "transactionHandling": "Implicitly handled by the Spring Data repository implementation.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findById(deviceRegistrationId)\n .orElseThrow(() -> new DeviceRegistrationNotFoundException(deviceRegistrationId));" }, { "path": "org.apache.fineract.infrastructure.gcm.domain", "mechanism": "SPRING-DATA", "name": "DeviceRegistrationRepository", "description": "The code uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to inherit standard CRUD operations and defines a custom JPQL query to filter data.", "databaseName": "unknown", "tablesAccessed": [ "DeviceRegistration" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "JPQL queries via @Query annotation and standard Spring Data CRUD", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(FIND_DEVICE_REGISTRATION_BY_CLIENT)\nDeviceRegistration findDeviceRegistrationByClientId(@Param(\"clientId\") Long clientId);" }, { "path": "org.apache.fineract.infrastructure.gcm.service", "mechanism": "SPRING-DATA", "name": "DeviceRegistrationRepositoryWrapper", "description": "The class uses repository wrappers (likely wrapping Spring Data JPA repositories) to perform CRUD operations on DeviceRegistration and Client entities. It relies on JPA annotations on the domain objects for mapping.", "databaseName": "unknown", "tablesAccessed": [ "DeviceRegistration", "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, findOne, delete) via repository abstraction.", "transactionHandling": "Spring @Transactional annotations on the class/methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.deviceRegistrationRepository.save(deviceRegistration);" }, { "path": "org.apache.fineract.infrastructure.gcm.service", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The service uses Spring Data repositories to interact with the database. It reads device registration information via `DeviceRegistrationRepositoryWrapper` (which likely wraps a repository) and persists the status of SMS messages using `SmsMessageRepository`.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage", "DeviceRegistration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations: finding an entity by ID (DeviceRegistration) and batch saving entities (SmsMessage).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "smsMessageRepository.saveAll(smsList);" }, { "path": "org.apache.fineract.infrastructure.hooks.domain", "mechanism": "SPRING-DATA", "name": "HookRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends `JpaRepository` to provide standard data access methods and defines custom JPQL queries for specific business requirements.", "databaseName": "unknown", "tablesAccessed": [ "Hook", "Hook.events" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with inner joins and parameter binding", "transactionHandling": "Spring Data JPA default transaction management", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select hook from Hook hook inner join hook.events event where event.entityName = :entityName...\")" }, { "path": "org.apache.fineract.infrastructure.hooks.domain", "mechanism": "SPRING-DATA", "name": "HookTemplateRepository", "description": "The code uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard data access capabilities and defines custom JPQL queries via annotations.", "databaseName": "unknown", "tablesAccessed": [ "HookTemplate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined in @Query annotations and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select template from HookTemplate template where template.name = :name\")\nHookTemplate findOne(@Param(\"name\") String name);" }, { "path": "org.apache.fineract.infrastructure.hooks.domain", "mechanism": "SPRING-DATA", "name": "HookConfigurationRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access for the HookConfiguration entity and defines a custom JPQL query.", "databaseName": "unknown", "tablesAccessed": [ "HookConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select config.fieldValue from HookConfiguration config where config.hook.id = :hookId and config.fieldName = :fieldName\")" }, { "path": "org.apache.fineract.infrastructure.hooks.processor.MessageGatewayHookProcessor", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository, ClientRepositoryWrapper, TemplateRepository", "description": "The class uses Spring Data repositories (and wrappers) to interact with the database. It reads templates and client information and writes new SMS message records.", "databaseName": "unknown", "tablesAccessed": [ "m_template", "m_client", "sms_messages" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository methods (findByTemplateMapper, findOne, save).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "SmsMessage smsMessage = SmsMessage.pendingSms(null, null, client, null, smsText, client.mobileNo(), null, false);\nthis.smsMessageRepository.save(smsMessage);" }, { "path": "org.apache.fineract.infrastructure.hooks.processor.TwilioHookProcessor", "mechanism": "SPRING-DATA", "name": "HookConfigurationRepository, ClientRepositoryWrapper", "description": "The class interacts with the database to retrieve and store hook configurations (specifically API keys) and to look up client information (mobile numbers) for template processing.", "databaseName": "unknown", "tablesAccessed": [ "HookConfiguration", "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations to find configuration by ID and field name, save new configurations, and find client entities by ID.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "String apiKey = this.hookConfigurationRepository.findOneByHookIdAndFieldName(hook.getId(), apiKeyName);\n...\nthis.hookConfigurationRepository.save(apiKeyEntry);\n...\nfinal Client client = this.clientRepositoryWrapper.findOneWithNotFoundDetection(clientId);" }, { "path": "org.apache.fineract.infrastructure.hooks.service.HookWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "HookRepository", "description": "The class uses Spring Data JPA repositories (HookRepository, HookTemplateRepository, TemplateRepository) to perform CRUD operations on Hook entities and related data. It relies on the underlying JPA implementation (likely Hibernate) for object-relational mapping.", "databaseName": "unknown", "tablesAccessed": [ "Hook", "HookTemplate", "Template" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, findOne, delete) are used. No complex custom queries are visible in this service layer.", "transactionHandling": "Spring @Transactional annotations are used on public methods to ensure atomicity of operations.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.hookRepository.saveAndFlush(hook);" }, { "path": "org.apache.fineract.infrastructure.jobs.domain", "mechanism": "SPRING-DATA", "name": "JobParameterRepository", "description": "The file uses Spring Data JPA to interact with the database. By extending JpaRepository, it automatically gains methods for saving, deleting, and finding JobParameter entities. It also defines a custom JPQL query to filter results.", "databaseName": "unknown", "tablesAccessed": [ "JobParameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select jobParameter from JobParameter jobParameter where jobParameter.jobId=:jobId\")\nList findJobParametersByJobId(@Param(\"jobId\") Long jobId);" }, { "path": "org.apache.fineract.infrastructure.jobs.domain", "mechanism": "SPRING-DATA", "name": "ScheduledJobRunHistoryRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific business logic.", "databaseName": "unknown", "tablesAccessed": [ "ScheduledJobRunHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with aggregations", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select max(sjrh.version) from ScheduledJobRunHistory sjrh where sjrh.scheduledJobDetail.jobKey = :jobKey\")" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.CustomJobParameterRepository", "mechanism": "SPRING-DATA", "name": "CustomJobParameterRepository", "description": "This interface represents a Data Access Object (DAO) or Repository pattern, likely used within a Spring Data context (common in the Fineract project structure). It defines methods for CRUD operations (Create and Read) on the CustomJobParameter entity.", "databaseName": "unknown", "tablesAccessed": [ "CustomJobParameter" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save and find by ID).", "transactionHandling": "Likely handled by Spring @Transactional at the service layer or default repository implementation.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Long save(Set customJobParameters);" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.ScheduledJobDetailRepository", "mechanism": "SPRING-DATA", "name": "ScheduledJobDetailRepository", "description": "The file is a Spring Data JPA repository interface that manages database interactions for the ScheduledJobDetail entity. It uses JPQL annotations for custom queries and standard JPA locking annotations for concurrency control.", "databaseName": "unknown", "tablesAccessed": [ "ScheduledJobDetail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with named parameters, pessimistic locking, and derived query methods.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select jobDetail from ScheduledJobDetail jobDetail where jobDetail.jobKey = :jobKey\")\nScheduledJobDetail findByJobKey(@Param(\"jobKey\") String jobKey);" }, { "path": "org.apache.fineract.infrastructure.jobs.domain.SchedulerDetailRepository", "mechanism": "SPRING-DATA", "name": "SchedulerDetailRepository", "description": "The code defines a Spring Data JPA repository interface. This mechanism automatically generates the implementation for database access, mapping the 'SchedulerDetail' Java entity to a relational database table. It supports standard CRUD operations and dynamic queries via Specifications.", "databaseName": "unknown", "tablesAccessed": [ "SchedulerDetail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data JPA.", "transactionHandling": "Spring Data repositories are transactional by default (@Transactional is applied to the proxy methods).", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface SchedulerDetailRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.infrastructure.jobs.filter.LoanCOBFilterHelper", "mechanism": "SPRING-DATA", "name": "Loan and GLIM Repositories", "description": "The class uses Spring Data JPA repositories to resolve loan identifiers from external IDs or reschedule request IDs, and to retrieve GLIM account details. It also indirectly queries loan business dates via a service.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "GroupLoanIndividualMonitoringAccount", "LoanRescheduleRequest" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookups by ID or External ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return loanRepository.findIdByExternalId(new ExternalId(externalId));" }, { "path": "org.apache.fineract.infrastructure.jobs.service", "mechanism": "SPRING-DATA", "name": "JobExecutionRepository", "description": "The service interacts with the database via a Spring Data repository to query job execution states, count stuck jobs, and update job statuses.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Counts entities, finds IDs by criteria, and updates status fields.", "transactionHandling": "Uses Spring TransactionTemplate with PROPAGATION_REQUIRES_NEW for status updates.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Long stuckJobCount = jobExecutionRepository.getStuckJobCountByJobName(jobName);" }, { "path": "org.apache.fineract.infrastructure.jobs.service", "mechanism": "SPRING-DATA", "name": "JobParameterRepository", "description": "The class uses a Spring Data repository interface to fetch job parameters stored in the database associated with a specific job ID.", "databaseName": "unknown", "tablesAccessed": [ "job_parameters" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by foreign key (job ID)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "List jobParameterList = jobParameterRepository\n .findJobParametersByJobId(scheduledJobDetail.getId());" }, { "path": "org.apache.fineract.infrastructure.jobs.service.SchedularWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ScheduledJobRepositories", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations and utilizes specific query methods defined in the repository interfaces.", "databaseName": "unknown", "tablesAccessed": [ "ScheduledJobDetail", "ScheduledJobRunHistory", "SchedulerDetail" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findAll) plus custom finders (findByJobKey, findMaxVersionByJobKey) and locking (findByJobKeyWithLock).", "transactionHandling": "Spring @Transactional annotations on write methods.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.scheduledJobDetailsRepository.save(scheduledJobDetails);" }, { "path": "org.apache.fineract.infrastructure.jobs.service.SchedulerJobListener", "mechanism": "SPRING-DATA", "name": "SchedularWritePlatformService / AppUserRepositoryWrapper", "description": "The class interacts with the database indirectly through injected service components. It uses `AppUserRepositoryWrapper` to read system user details and `SchedularWritePlatformService` to read job details and write job execution history.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser", "job", "job_run_history" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations via service layer abstractions.", "transactionHandling": "Likely handled by the called services (Spring @Transactional)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.schedularService.saveOrUpdate(scheduledJobDetails, runHistory);" }, { "path": "org.apache.fineract.infrastructure.jobs.service.executealldirtyjobs", "mechanism": "SPRING-DATA", "name": "ScheduledJobDetailRepository", "description": "The class uses a Spring Data repository interface to query for scheduled job details.", "databaseName": "unknown", "tablesAccessed": [ "ScheduledJobDetail" ], "operationType": [ "READ" ], "queryPatterns": "Repository method call to find mismatched jobs", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List jobDetails = scheduledJobDetailsRepository.findAllMismatchedJobs(true);" }, { "path": "org.apache.fineract.infrastructure.jobs.service.increasedateby1day.IncreaseDateBy1DayServiceImpl", "mechanism": "SPRING-DATA", "name": "BusinessDateRepository", "description": "The class interacts with the database primarily through the `BusinessDateRepository` to read existing date configurations. It also delegates write operations to `BusinessDateWritePlatformService`, which implies further database interaction for updating records.", "databaseName": "unknown", "tablesAccessed": [ "BusinessDate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple entity lookup by type via Spring Data repository.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Optional businessDateEntity = businessDateRepository.findByType(businessDateType);" }, { "path": "org.apache.fineract.infrastructure.jobs.service.jobparameterprovider", "mechanism": "SPRING-DATA", "name": "CustomJobParameterRepository", "description": "The class uses a Spring Data repository (`CustomJobParameterRepository`) to persist job parameter data into the database. This allows the application to store dynamic parameters associated with a specific batch job execution instance.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Long customJobParameterId = customJobParameterRepository.save(getJobParameterDTOListWithCorrectBusinessDate(jobParameterDTOSet));" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and JpaSpecificationExecutor for dynamic queries. It maps the ReportMailingJob entity to a database table.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJob" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived query methods and standard CRUD operations.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ReportMailingJobRepository extends JpaRepository, JpaSpecificationExecutor { ... }" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRepository", "description": "The class interacts with the database through a Spring Data repository interface (ReportMailingJobRepository). It performs read operations to fetch entities by primary key.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJob" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD retrieval by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.reportMailingJobRepository.findById(id)" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain.ReportMailingJobConfigurationRepository", "mechanism": "SPRING-DATA", "name": "ReportMailingJobConfigurationRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to inherit standard CRUD operations and JpaSpecificationExecutor for dynamic queries.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJobConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific derived query method for finding by name.", "transactionHandling": "Spring @Transactional (implicitly handled by the JpaRepository implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ReportMailingJobConfigurationRepository\n extends JpaRepository..." }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.domain.ReportMailingJobRunHistoryRepository", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRunHistoryRepository", "description": "The file uses Spring Data JPA to manage database interactions for the ReportMailingJobRunHistory entity. It inherits standard CRUD capabilities and specification execution logic without requiring manual SQL implementation.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJobRunHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic criteria-based queries via JpaSpecificationExecutor.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data JPA repository implementation)", "protocol": "JDBC (abstracted by JPA)", "connectionInfo": "unknown", "codeExample": "public interface ReportMailingJobRunHistoryRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.handler", "mechanism": "SPRING-DATA", "name": "ReportMailingJobWritePlatformService", "description": "The class manages database transactions via the Spring @Transactional annotation. While it does not execute SQL directly, it defines the transaction boundary for the 'createReportMailingJob' operation, ensuring that the database writes performed by the injected service are committed or rolled back as a single unit.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Override\n@Transactional\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.reportMailingJobWritePlatformService.createReportMailingJob(jsonCommand);\n}" }, { "path": "org.apache.fineract.infrastructure.reportmailingjob.service", "mechanism": "SPRING-DATA", "name": "ReportMailingJobRepository", "description": "The class uses Spring Data JPA repositories (ReportMailingJobRepository and ReportRepositoryWrapper) to perform CRUD operations on ReportMailingJob and Report entities. It uses @Transactional to ensure atomicity.", "databaseName": "unknown", "tablesAccessed": [ "ReportMailingJob", "Report" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, saveAndFlush, findOne) with some domain logic handling updates.", "transactionHandling": "Spring @Transactional annotations on public methods", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.reportMailingJobRepository.saveAndFlush(reportMailingJob);" }, { "path": "org.apache.fineract.infrastructure.security.command", "mechanism": "SPRING-DATA", "name": "TwoFactorConfigurationService", "description": "The class manages database transactions via the Spring '@Transactional' annotation while delegating the actual data persistence logic to the 'TwoFactorConfigurationService'.", "databaseName": "unknown", "tablesAccessed": [ "TWOFACTOR_CONFIGURATION" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates update logic to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n // ...\n final Map changes = configurationService.update(command);\n // ...\n}" }, { "path": "org.apache.fineract.infrastructure.security.command.InvalidateTFAccessTokenCommandHandler", "mechanism": "SPRING-DATA", "name": "TwoFactorService", "description": "The class delegates data persistence operations to `TwoFactorService`, which manages the `TFAccessToken` entity. The method is annotated with `@Transactional`, indicating it participates in a database transaction managed by Spring.", "databaseName": "unknown", "tablesAccessed": [ "TFAccessToken" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for entity updates.", "transactionHandling": "Spring @Transactional annotation", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final TFAccessToken accessToken = twoFactorService.invalidateAccessToken(user, command);" }, { "path": "org.apache.fineract.infrastructure.security.domain", "mechanism": "SPRING-DATA", "name": "TFAccessTokenRepository", "description": "The interface extends JpaRepository, leveraging Spring Data JPA to manage database interactions for the TFAccessToken entity. It provides abstraction over the underlying SQL queries.", "databaseName": "unknown", "tablesAccessed": [ "TFAccessToken" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and simple property-based filtering (findByUserAndToken).", "transactionHandling": "Spring Data Repositories are transactional by default (read-only for find methods, read-write for save/delete).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface TFAccessTokenRepository extends JpaRepository {\n TFAccessToken findByUserAndToken(AppUser user, String token);\n}" }, { "path": "org.apache.fineract.infrastructure.security.domain", "mechanism": "SPRING-DATA", "name": "TwoFactorConfigurationRepository", "description": "The interface extends JpaRepository, utilizing Spring Data JPA to manage persistence for the TwoFactorConfiguration entity.", "databaseName": "unknown", "tablesAccessed": [ "TwoFactorConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and a specific finder by name.", "transactionHandling": "Transactions are managed by the Spring container, typically applying read-only transactions to find methods and read-write to others.", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "TwoFactorConfiguration config = repository.findByName(\"otp_provider\");" }, { "path": "org.apache.fineract.infrastructure.security.domain.PlatformUserRepository", "mechanism": "SPRING-DATA", "name": "PlatformUserRepository", "description": "The interface functions as a Spring Data repository, leveraging method name derivation to perform database queries without writing explicit SQL.", "databaseName": "unknown", "tablesAccessed": [ "PlatformUser" ], "operationType": [ "READ" ], "queryPatterns": "Derived finder method (Simple CRUD)", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "PlatformUser findByUsernameAndDeletedAndEnabled(String username, boolean deleted, boolean enabled);" }, { "path": "org.apache.fineract.infrastructure.security.service", "mechanism": "SPRING-DATA", "name": "PlatformUserRepository", "description": "The class uses a Spring Data JPA repository (PlatformUserRepository) to query the database for user information.", "databaseName": "unknown", "tablesAccessed": [ "PlatformUser (entity)" ], "operationType": [ "READ" ], "queryPatterns": "Simple finder method (findByUsernameAndDeletedAndEnabled)", "transactionHandling": "Implicit (Spring Data default)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.platformUserRepository.findByUsernameAndDeletedAndEnabled(username, deleted, enabled);" }, { "path": "org.apache.fineract.infrastructure.security.service", "mechanism": "SPRING-DATA", "name": "TwoFactorConfigurationRepository", "description": "The class uses a Spring Data JPA repository (`TwoFactorConfigurationRepository`) to access and modify `TwoFactorConfiguration` entities stored in the database.", "databaseName": "unknown", "tablesAccessed": [ "TwoFactorConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findAll, findByName, save)", "transactionHandling": "Spring @Transactional (implied by Service/Repository usage)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List configurationList = configurationRepository.findAll();" }, { "path": "org.apache.fineract.infrastructure.security.service.TwoFactorServiceImpl", "mechanism": "SPRING-DATA", "name": "SecurityRepositories", "description": "The service uses Spring Data repositories to interact with the database. It persists OTP requests, access tokens, and SMS messages using injected repository interfaces.", "databaseName": "unknown", "tablesAccessed": [ "OTPRequest", "TFAccessToken", "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, delete, findBy) provided by Spring Data repositories.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.smsMessageRepository.save(smsMessage);" }, { "path": "org.apache.fineract.infrastructure.sms.domain", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository, GroupRepositoryWrapper, ClientRepositoryWrapper, StaffRepositoryWrapper, SmsCampaignRepository", "description": "The class uses Spring Data repositories and custom repository wrappers to fetch related entities (Group, Client, Staff, SmsCampaign) and the SmsMessage itself from the database. It performs read operations to resolve foreign keys and validate existence.", "databaseName": "unknown", "tablesAccessed": [ "m_sms_message", "m_group", "m_client", "m_staff", "sms_campaign" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookups by ID using repository methods like findOneWithNotFoundDetection and findById.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "smsCampaign = this.smsCampaignRepository.findById(campaignId).orElseThrow(() -> new SmsCampaignNotFound(campaignId));" }, { "path": "org.apache.fineract.infrastructure.sms.domain", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends `JpaRepository` to provide standard data access operations for the `SmsMessage` entity.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository, plus a derived query method for filtering by status.", "transactionHandling": "Spring @Transactional (implicit in Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface SmsMessageRepository extends JpaRepository {\n Page findByStatusType(Integer status, Pageable pageable);\n}" }, { "path": "org.apache.fineract.infrastructure.sms.handler", "mechanism": "SPRING-DATA", "name": "SmsWritePlatformService", "description": "The class defines a transactional boundary using Spring's `@Transactional` annotation. While it does not execute SQL or call a repository directly, it orchestrates a database write operation (delete) by delegating to the `SmsWritePlatformService` within a transaction context.", "databaseName": "unknown", "tablesAccessed": [ "SMS" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates deletion by ID to service layer", "transactionHandling": "Spring @Transactional annotation on processCommand method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.delete(command.entityId());\n}" }, { "path": "org.apache.fineract.infrastructure.sms.scheduler.SmsMessageScheduledJobServiceImpl", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The class uses a Spring Data repository (`SmsMessageRepository`) to persist the state of SMS messages. It performs batch updates to message statuses before sending them to external systems.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "WRITE" ], "queryPatterns": "Batch save operations (saveAll) and flush.", "transactionHandling": "Implicitly handled by Spring Data repository methods, though no explicit @Transactional annotation is present on the service methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.smsMessageRepository.saveAll(toSaveMessages);\nthis.smsMessageRepository.flush();" }, { "path": "org.apache.fineract.infrastructure.sms.service", "mechanism": "SPRING-DATA", "name": "SmsMessageRepository", "description": "The class uses a Spring Data JPA repository (SmsMessageRepository) to perform CRUD operations on the SmsMessage entity. It relies on standard JPA annotations and Spring's exception translation for database interactions.", "databaseName": "unknown", "tablesAccessed": [ "SmsMessage" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, saveAndFlush, delete) delegated to the repository interface.", "transactionHandling": "Spring @Transactional annotations on methods", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.saveAndFlush(message);" }, { "path": "org.apache.fineract.infrastructure.survey.domain", "mechanism": "SPRING-DATA", "name": "LikelihoodRepository", "description": "The file uses Spring Data JPA to interact with the database. By extending JpaRepository, it gains standard CRUD methods, and it defines a custom JPQL query for specific filtering requirements.", "databaseName": "unknown", "tablesAccessed": [ "Likelihood" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select liklihood FROM Likelihood liklihood WHERE liklihood.ppiName =:ppiName AND liklihood.id <>:id\")" }, { "path": "org.apache.fineract.infrastructure.survey.service", "mechanism": "SPRING-DATA", "name": "LikelihoodRepository", "description": "The class uses a Spring Data JPA repository (LikelihoodRepository) to perform CRUD operations on Likelihood entities.", "databaseName": "unknown", "tablesAccessed": [ "Likelihood" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (findById, save) and a custom finder method (findByPpiNameAndLikeliHoodId) followed by a batch save (saveAll).", "transactionHandling": "UNKNOWN", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "final Likelihood likelihood = this.repository.findById(likelihoodId).orElse(null);\nthis.repository.save(likelihood);" }, { "path": "org.apache.fineract.interoperation.domain.InteropIdentifierRepository", "mechanism": "SPRING-DATA", "name": "InteropIdentifierRepository", "description": "The interface extends JpaRepository to provide database interaction for the InteropIdentifier entity using Spring Data JPA.", "databaseName": "unknown", "tablesAccessed": [ "InteropIdentifier" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and derived query methods based on method names.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository implementation)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface InteropIdentifierRepository extends JpaRepository ..." }, { "path": "org.apache.fineract.interoperation.service.InteropServiceImpl", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepository, InteropIdentifierRepository, JdbcTemplate", "description": "The class primarily uses Spring Data JPA repositories for CRUD operations on entities like SavingsAccount, InteropIdentifier, and Loan. It also uses Spring's JdbcTemplate for executing a complex SQL join query to retrieve KYC data efficiently.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_client_address", "m_address", "m_code_value", "m_client_identifier", "m_savings_account", "m_interop_identifier", "m_loan", "m_note", "m_payment_type", "m_savings_account_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Uses standard JPA repository methods for most operations. Uses a complex SQL join query for KYC data retrieval.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final String sql = \"select \" + rm.schema() + \" where c.id = ?\";\nfinal InteropKycData accountKyc = this.jdbcTemplate.queryForObject(sql, rm, new Object[] { clientId });" }, { "path": "org.apache.fineract.investor.accounting.journalentry.service", "mechanism": "SPRING-DATA", "name": "JournalEntryRepository, ProductToGLAccountMappingRepository, FinancialActivityAccountRepositoryWrapper, GLClosureRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs read operations to fetch GL closures, account mappings, and financial activity accounts. It performs write operations to save new `JournalEntry` records.", "databaseName": "unknown", "tablesAccessed": [ "JournalEntry", "GLClosure", "ProductToGLAccountMapping", "FinancialActivityAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findBy...) and custom repository methods (getLatestGLClosureByBranch, findCoreProductToFinAccountMapping).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.glJournalEntryRepository.saveAndFlush(journalEntry);" }, { "path": "org.apache.fineract.investor.cob.loan.LoanAccountOwnerTransferBusinessStep", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs complex queries using JPA Specifications (CriteriaBuilder) to find transfers based on multiple conditions (loanId, settlementDate, status, effectiveDate) and performs CRUD operations (save, delete) on transfer and mapping entities.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwnerTransferLoanMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPA Specifications with dynamic criteria (AND conditions, IN clauses, GreaterThanOrEqualTo comparisons) and standard CRUD operations.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "externalAssetOwnerTransferRepository.findAll(\n (root, query, criteriaBuilder) -> criteriaBuilder.and(criteriaBuilder.equal(root.get(\"loanId\"), loanId),\n criteriaBuilder.equal(root.get(\"settlementDate\"), settlementDate),\n root.get(\"status\").in(List.of(ExternalTransferStatus.PENDING, ExternalTransferStatus.BUYBACK)),\n criteriaBuilder.greaterThanOrEqualTo(root.get(\"effectiveDateTo\"), FUTURE_DATE_9999_12_31)),\n Sort.by(Sort.Direction.ASC, \"id\"));" }, { "path": "org.apache.fineract.investor.domain", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferLoanMappingRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD capabilities, and defines custom JPQL queries for specific lookups.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransferLoanMapping", "ExternalAssetOwnerTransfer" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with joins/relationship traversal and standard CRUD operations.", "transactionHandling": "Spring Data repositories are transactional by default (usually read-only for find methods and read-write for others).", "protocol": "JDBC (abstracted via JPA)", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT mapping FROM ExternalAssetOwnerTransferLoanMapping mapping WHERE mapping.ownerTransfer.externalLoanId =:externalLoanId\")" }, { "path": "org.apache.fineract.investor.domain", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerJournalEntryMappingRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerJournalEntryMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via @Query annotations and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JPA", "connectionInfo": "configured externally", "codeExample": "@Query(\"SELECT mapping FROM ExternalAssetOwnerJournalEntryMapping mapping WHERE mapping.owner.externalId = :ownerExternalId\")" }, { "path": "org.apache.fineract.investor.domain", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerRepository", "description": "The code uses Spring Data JPA to manage database interactions. By extending JpaRepository, it automatically gains methods for standard database operations without explicit implementation.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwner" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and a specific lookup by external ID.", "transactionHandling": "Spring Data JPA default transaction management (usually read-only for find methods and transactional for modifications).", "protocol": "JPA", "connectionInfo": "configured in application properties", "codeExample": "public interface ExternalAssetOwnerRepository extends JpaRepository ..." }, { "path": "org.apache.fineract.investor.domain", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferJournalEntryMappingRepository", "description": "The file uses Spring Data JPA to manage database interactions for the `ExternalAssetOwnerTransferJournalEntryMapping` entity. It inherits standard database operations and defines a custom JPQL query.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransferJournalEntryMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"SELECT mapping FROM ExternalAssetOwnerTransferJournalEntryMapping mapping WHERE mapping.ownerTransfer.id =:transferId\")" }, { "path": "org.apache.fineract.investor.domain.ExternalAssetOwnerTransferRepository", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database using JPA entities and JPQL queries defined via annotations.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwnerTransferLoanMapping", "ExternalAssetOwner" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "The repository uses a mix of Spring Data method naming conventions for simple queries and @Query annotations with JPQL for more complex logic involving subqueries, joins, and specific field selections.", "transactionHandling": "Spring Data JPA repositories typically participate in existing transactions or create read-only transactions for query methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select e from ExternalAssetOwnerTransfer e where e.loanId = :loanId and e.id = (select max(ex.id) from ExternalAssetOwnerTransfer ex where ex.loanId = :loanId)\")\nOptional findLatestByLoanId(@Param(\"loanId\") Long loanId);" }, { "path": "org.apache.fineract.investor.domain.search", "mechanism": "SPRING-DATA", "name": "SearchingExternalAssetOwnerRepository", "description": "This interface is part of the Spring Data repository layer. It defines a custom search method that interacts with the database to retrieve investor data. The return type 'Page' indicates it leverages Spring Data's pagination support.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwner" ], "operationType": [ "READ" ], "queryPatterns": "The method signature implies a dynamic search query based on the fields present in ExternalAssetOwnerSearchRequest.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Page searchInvestorData(PagedRequest searchRequest);" }, { "path": "org.apache.fineract.investor.enricher", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The class interacts with the database via a Spring Data repository to retrieve ownership transfer information associated with a loan.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by Loan ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "externalAssetOwnerTransferRepository.findActiveOwnerByLoanId(data.getLoanId())" }, { "path": "org.apache.fineract.investor.enricher.LoanAccountDataV1Enricher", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The class uses a Spring Data repository interface to query the database for active external asset owner transfers associated with a specific loan ID.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by Loan ID using a repository method.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "externalAssetOwnerTransferRepository.findActiveByLoanId(data.getId()).ifPresent(transfer -> { ... })" }, { "path": "org.apache.fineract.investor.enricher.LoanTransactionDataV1Enricher", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The class uses a Spring Data repository interface to query the database for asset owner transfer information.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by Loan ID returning an Optional entity.", "transactionHandling": "Implicitly handled by Spring Data repository invocation (likely read-only transaction).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "externalAssetOwnerTransferRepository.findActiveOwnerByLoanId(data.getLoanId())" }, { "path": "org.apache.fineract.investor.service", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferJournalEntryMappingRepository", "description": "The class uses Spring Data JPA repositories to persist mapping entities that link external asset owner transfers and owners to the generated accounting journal entries. It also uses a repository wrapper to retrieve financial activity account configurations.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerJournalEntryMapping", "ExternalAssetOwnerTransferJournalEntryMapping", "FinancialActivityAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (saveAndFlush) and finding by type.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "externalAssetOwnerJournalEntryMappingRepository.saveAndFlush(mapping);" }, { "path": "org.apache.fineract.investor.service", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwner Repositories", "description": "The class uses multiple Spring Data JPA repositories to interact with the database. It performs read-only operations to fetch transfer data, loan mappings, and journal entry mappings based on various criteria like Loan ID, External ID, or Transfer ID.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwnerTransferLoanMapping", "ExternalAssetOwnerTransferJournalEntryMapping", "ExternalAssetOwnerJournalEntryMapping" ], "operationType": [ "READ" ], "queryPatterns": "Standard Spring Data findBy... methods with pagination and sorting.", "transactionHandling": "Spring @Transactional(readOnly = true) at class level", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "result = externalAssetOwnerTransferRepository.findAllByLoanId(loanId, pageRequest);" }, { "path": "org.apache.fineract.investor.service", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwner Repositories", "description": "The service interacts with the database using Spring Data JPA repositories to read loan transaction details, check for asset owner mappings, and persist new journal entry mappings.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerJournalEntryMapping", "ExternalAssetOwnerTransferLoanMapping", "LoanTransaction", "JournalEntry" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations: finding a loan ID by transaction ID, finding an active mapping by loan ID, and saving a new mapping entity.", "transactionHandling": "Implicitly handled by Spring Data repository methods; no explicit @Transactional annotation on the service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "externalAssetOwnerTransferLoanMappingRepository.findByLoanId(loanId).ifPresent(transferLoanMapping -> {\n ExternalAssetOwnerJournalEntryMapping mapping = new ExternalAssetOwnerJournalEntryMapping();\n mapping.setJournalEntry(journalEntry);\n mapping.setOwner(transferLoanMapping.getOwnerTransfer().getOwner());\n externalAssetOwnerJournalEntryMappingRepository.saveAndFlush(mapping);\n});" }, { "path": "org.apache.fineract.investor.service", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository", "description": "The class uses Spring Data JPA repositories to manage `ExternalAssetOwnerTransfer` entities. It utilizes JPA Criteria API (Specifications) within the repository calls to perform complex filtering based on loan IDs, statuses, and dates.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwnerTransferDetails", "ExternalAssetOwnerTransferLoanMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPA Criteria API queries with dynamic predicates (AND conditions, IN clauses) and standard CRUD operations (save, delete).", "transactionHandling": "Spring @Transactional", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "externalAssetOwnerTransferRepository.findAll((root, query, criteriaBuilder) -> criteriaBuilder.and(criteriaBuilder.equal(root.get(\"loanId\"), loanId), root.get(\"status\").in(List.of(PENDING, BUYBACK))..." }, { "path": "org.apache.fineract.investor.service.ExternalAssetOwnersWriteServiceImpl", "mechanism": "SPRING-DATA", "name": "ExternalAssetOwnerTransferRepository, ExternalAssetOwnerRepository, LoanRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations and executes custom queries (via specifications or method naming conventions) to manage the lifecycle of asset transfers and validate loan states.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwnerTransfer", "ExternalAssetOwner", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, findById, existsById) and custom finder methods (findEffectiveTransfersOrderByIdDesc, findByExternalId).", "transactionHandling": "Spring @Transactional annotations on public methods ensure atomicity of operations.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "externalAssetOwnerTransferRepository.saveAndFlush(externalAssetOwnerTransfer);" }, { "path": "org.apache.fineract.investor.service.search", "mechanism": "SPRING-DATA", "name": "SearchingExternalAssetOwnerRepository", "description": "The service interacts with the database through a Spring Data repository interface named `SearchingExternalAssetOwnerRepository`. It retrieves paged results based on search criteria.", "databaseName": "unknown", "tablesAccessed": [ "ExternalAssetOwner" ], "operationType": [ "READ" ], "queryPatterns": "Paged search query via Repository abstraction", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return externalAssetOwnerRepository.searchInvestorData(searchRequest).map(externalAssetOwnerSearchDataMapper::map);" }, { "path": "org.apache.fineract.mix.domain", "mechanism": "SPRING-DATA", "name": "MixTaxonomyMappingRepository", "description": "This interface is a Spring Data JPA repository that abstracts database interactions for the `MixTaxonomyMapping` entity. It delegates low-level JDBC and SQL operations to the Hibernate/JPA provider configured in the Spring context.", "databaseName": "unknown", "tablesAccessed": [ "MixTaxonomyMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, delete, findById, findAll) and dynamic queries via Specifications.", "transactionHandling": "Transactions are handled by the Spring container, typically applying @Transactional behavior to repository methods by default.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface MixTaxonomyMappingRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.mix.service", "mechanism": "SPRING-DATA", "name": "MixTaxonomyMappingRepository", "description": "The class uses a Spring Data repository (MixTaxonomyMappingRepository) to perform CRUD operations on the MixTaxonomyMapping entity.", "databaseName": "unknown", "tablesAccessed": [ "MixTaxonomyMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, saveAndFlush)", "transactionHandling": "Spring @Transactional annotation on the updateMapping method", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.mappingRepository.saveAndFlush(mapping);" }, { "path": "org.apache.fineract.notification.domain.NotificationMapperRepository", "mechanism": "SPRING-DATA", "name": "NotificationMapperRepository", "description": "This interface is a Spring Data JPA repository that provides database access for the NotificationMapper entity. It inherits standard CRUD operations from JpaRepository.", "databaseName": "unknown", "tablesAccessed": [ "NotificationMapper" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository without custom queries.", "transactionHandling": "Spring @Transactional (default behavior for JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface NotificationMapperRepository extends JpaRepository {}" }, { "path": "org.apache.fineract.notification.domain.NotificationRepository", "mechanism": "SPRING-DATA", "name": "NotificationRepository", "description": "The interface extends JpaRepository, allowing Spring Data to generate the implementation for database access at runtime. It manages the persistence of the Notification entity.", "databaseName": "unknown", "tablesAccessed": [ "Notification" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JDBC (via JPA)", "connectionInfo": "unknown", "codeExample": "public interface NotificationRepository extends JpaRepository {}" }, { "path": "org.apache.fineract.notification.service", "mechanism": "SPRING-DATA", "name": "AppUserRepository, NotificationGeneratorWritePlatformService", "description": "The class interacts with the database using Spring Data repositories and wrapper services. It performs read operations to fetch `AppUser` entities and write operations to persist `Notification` and `NotificationMapper` entities. The entire operation is wrapped in a Spring `@Transactional` annotation.", "databaseName": "unknown", "tablesAccessed": [ "Notification", "NotificationMapper", "AppUser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations involving finding entities by ID and saving new entities.", "transactionHandling": "Spring @Transactional annotation on the class level.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "AppUser appUser = this.appUserRepository.findById(userId).orElseThrow();\nNotificationMapper notificationMapper = new NotificationMapper().setNotification(...).setUserId(appUser)...;\nthis.notificationMapperWritePlatformService.create(notificationMapper);" }, { "path": "org.apache.fineract.notification.service", "mechanism": "SPRING-DATA", "name": "AppUserRepository", "description": "The class uses the AppUserRepository, which is likely a Spring Data JPA repository, to query user information from the database. It retrieves users by ID and by office ID to determine notification recipients.", "databaseName": "unknown", "tablesAccessed": [ "AppUser" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookups by ID and Office ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Collection users = appUserRepository.findByOfficeId(officeId);" }, { "path": "org.apache.fineract.notification.service", "mechanism": "SPRING-DATA", "name": "NotificationRepository", "description": "The class interacts with the database via the NotificationRepository, which is a Spring Data repository interface. It performs standard CRUD operations (Read and Delete) on the Notification entity.", "databaseName": "unknown", "tablesAccessed": [ "Notification" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.notificationRepository.findById(id).orElse(null);" }, { "path": "org.apache.fineract.notification.service", "mechanism": "SPRING-DATA", "name": "NotificationMapperRepository", "description": "The class interacts with the database through the NotificationMapperRepository, which is a Spring Data repository interface. It performs write operations to persist NotificationMapper entities using JPA mechanisms.", "databaseName": "unknown", "tablesAccessed": [ "NotificationMapper" ], "operationType": [ "WRITE" ], "queryPatterns": "Simple CRUD save operation using JPA repository methods.", "transactionHandling": "Implicitly handled by Spring Data repository or service layer transaction configuration.", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "this.notificationMapperRepository.saveAndFlush(notificationMapper);" }, { "path": "org.apache.fineract.notification.service.NotificationGeneratorWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "NotificationRepository", "description": "The class interacts with the database through a Spring Data repository interface (`NotificationRepository`). It uses the `saveAndFlush` method to persist entities immediately.", "databaseName": "unknown", "tablesAccessed": [ "Notification" ], "operationType": [ "WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.notificationRepository.saveAndFlush(notification);" }, { "path": "org.apache.fineract.notification.service.NotificationMapperReadRepositoryWrapperImpl", "mechanism": "SPRING-DATA", "name": "NotificationMapperRepository", "description": "The class uses a Spring Data repository (NotificationMapperRepository) to interact with the database. This abstracts the underlying SQL or JPA queries.", "databaseName": "unknown", "tablesAccessed": [ "NotificationMapper" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, findAll, deleteById) provided by Spring Data infrastructure.", "transactionHandling": "Spring Data Repository default transaction handling (likely read-only for reads and transactional for deletes at the repository level).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.notificationMapperRepository.findById(id).orElse(null);" }, { "path": "org.apache.fineract.organisation.holiday.domain", "mechanism": "SPRING-DATA", "name": "HolidayRepository", "description": "The file is a Spring Data JPA repository that manages persistence for the Holiday entity. It uses JPQL annotations to define specific read operations involving joins and filtering.", "databaseName": "unknown", "tablesAccessed": [ "Holiday" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with joins and conditional filtering", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select holiday from Holiday holiday... where holiday.processed = false\")" }, { "path": "org.apache.fineract.organisation.holiday.domain.HolidayRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "HolidayRepository", "description": "The class wraps a Spring Data repository (HolidayRepository) to perform CRUD operations and custom queries on Holiday entities. It abstracts the direct repository calls.", "databaseName": "unknown", "tablesAccessed": [ "Holiday" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and custom finders with filtering by status and date.", "transactionHandling": "Likely relies on Spring's default repository transaction management or service-layer @Transactional (though not present on this class directly).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new HolidayNotFoundException(id));" }, { "path": "org.apache.fineract.organisation.holiday.service.HolidayWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "HolidayRepositoryWrapper, OfficeRepositoryWrapper, WorkingDaysRepositoryWrapper", "description": "The class interacts with the database through repository wrapper classes (`HolidayRepositoryWrapper`, `OfficeRepositoryWrapper`, `WorkingDaysRepositoryWrapper`), which are injected via Spring's dependency injection. These wrappers are assumed to encapsulate Spring Data JPA repositories. All public methods that modify data are annotated with `@Transactional`, delegating transaction management to the Spring framework. The class performs create, read, and update operations using methods like `saveAndFlush` and `findOneWithNotFoundDetection` on the repository wrappers.", "databaseName": "unknown", "tablesAccessed": [ "Holiday", "Office", "WorkingDays" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.holidayRepository.saveAndFlush(holiday);" }, { "path": "org.apache.fineract.organisation.monetary.domain", "mechanism": "SPRING-DATA", "name": "ApplicationCurrencyRepository", "description": "The class interacts with the database through the ApplicationCurrencyRepository interface, which is likely a Spring Data JPA repository. It performs read operations to fetch currency details by their unique code.", "databaseName": "unknown", "tablesAccessed": [ "ApplicationCurrency" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookup by unique code", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.findOneByCode(currencyCode)" }, { "path": "org.apache.fineract.organisation.monetary.domain.ApplicationCurrencyRepository", "mechanism": "SPRING-DATA", "name": "ApplicationCurrencyRepository", "description": "The file uses Spring Data JPA to interact with the database. By extending JpaRepository, it gains automatic implementations for standard database operations, and by defining method signatures like findOneByCode, it triggers automatic query generation.", "databaseName": "unknown", "tablesAccessed": [ "ApplicationCurrency" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD, derived query methods", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "public interface ApplicationCurrencyRepository\n extends JpaRepository..." }, { "path": "org.apache.fineract.organisation.monetary.service", "mechanism": "SPRING-DATA", "name": "OrganisationCurrencyRepository", "description": "The class uses Spring Data repositories (OrganisationCurrencyRepository and ApplicationCurrencyRepositoryWrapper) to perform CRUD operations. It reads application currencies, checks existing organization currencies, and performs a bulk delete followed by a save operation to update the allowed currencies list.", "databaseName": "unknown", "tablesAccessed": [ "OrganisationCurrency (table unknown)", "ApplicationCurrency (table unknown)" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations including findOne, findAll, deleteAll, and saveAll.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.organisationCurrencyRepository.deleteAll();\nthis.organisationCurrencyRepository.saveAll(allowedCurrencies);" }, { "path": "org.apache.fineract.organisation.office.domain", "mechanism": "SPRING-DATA", "name": "OrganisationCurrencyRepository", "description": "The class interacts with the database through a Spring Data repository interface (OrganisationCurrencyRepository). It performs read operations to fetch currency configuration data based on a unique code.", "databaseName": "unknown", "tablesAccessed": [ "OrganisationCurrency" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD read operation (find by code)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final OrganisationCurrency organisationCurrency = this.repository.findOneByCode(currencyCode);" }, { "path": "org.apache.fineract.organisation.office.domain", "mechanism": "SPRING-DATA", "name": "OfficeRepository", "description": "The class wraps a Spring Data repository (OfficeRepository) to perform CRUD operations on the Office entity. It uses standard JPA/Spring Data patterns for retrieval and persistence.", "databaseName": "unknown", "tablesAccessed": [ "Office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Spring Data JPA methods (findById, save, delete).", "transactionHandling": "Uses Spring @Transactional(readOnly = true) for the hierarchy retrieval method to support lazy loading.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.findById(id).orElseThrow(() -> new OfficeNotFoundException(id));" }, { "path": "org.apache.fineract.organisation.office.domain.OfficeRepository", "mechanism": "SPRING-DATA", "name": "OfficeRepository", "description": "The interface uses Spring Data JPA to manage database interactions for the Office entity. It inherits standard CRUD operations and specification execution capabilities, allowing for database abstraction.", "databaseName": "unknown", "tablesAccessed": [ "Office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and derived query methods based on method names.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for find methods, read-write for save/delete).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface OfficeRepository extends JpaRepository ... {\n Optional findByExternalId(ExternalId externalId);\n}" }, { "path": "org.apache.fineract.organisation.office.domain.OfficeTransactionRepository", "mechanism": "SPRING-DATA", "name": "OfficeTransactionRepository", "description": "Database integration is achieved through Spring Data JPA. The interface extends JpaRepository to provide standard CRUD operations and JpaSpecificationExecutor for dynamic queries on the OfficeTransaction entity.", "databaseName": "unknown", "tablesAccessed": [ "OfficeTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic criteria-based queries via Specifications.", "transactionHandling": "Spring @Transactional (default for Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface OfficeTransactionRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.organisation.office.domain.OrganisationCurrencyRepository", "mechanism": "SPRING-DATA", "name": "OrganisationCurrencyRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard CRUD operations and JpaSpecificationExecutor for complex criteria-based queries.", "databaseName": "unknown", "tablesAccessed": [ "OrganisationCurrency" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific derived query method for finding by code.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data repositories)", "protocol": "JDBC (abstracted by JPA)", "connectionInfo": "unknown", "codeExample": "public interface OrganisationCurrencyRepository\n extends JpaRepository, JpaSpecificationExecutor {\n OrganisationCurrency findOneByCode(String currencyCode);\n}" }, { "path": "org.apache.fineract.organisation.office.service", "mechanism": "SPRING-DATA", "name": "Office and Transaction Repositories", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrappers for some entities) to perform CRUD operations on Office and OfficeTransaction entities. It handles transaction management using Spring's @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "m_office", "m_office_transaction", "m_currency" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA repositories, with some hierarchy-related logic.", "transactionHandling": "Spring @Transactional annotations on service methods", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.officeRepositoryWrapper.saveAndFlush(office);" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCategoryRepository", "mechanism": "SPRING-DATA", "name": "ProvisioningCategoryRepository", "description": "The interface uses Spring Data JPA to provide automatic CRUD and specification-based query capabilities for the ProvisioningCategory entity.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningCategory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic JPA Specifications provided by the framework.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface ProvisioningCategoryRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCriteriaDefinitionRepository", "mechanism": "SPRING-DATA", "name": "ProvisioningCriteriaDefinitionRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically implements the repository interface to interact with the database tables mapped to the ProvisioningCriteriaDefinition entity.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningCriteriaDefinition" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface ProvisioningCriteriaDefinitionRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.organisation.provisioning.domain.ProvisioningCriteriaRepository", "mechanism": "SPRING-DATA", "name": "ProvisioningCriteriaRepository", "description": "Database integration is achieved via Spring Data JPA. The interface inherits methods for interacting with the database table mapped to the ProvisioningCriteria entity.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningCriteria" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic criteria-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ProvisioningCriteriaRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.organisation.provisioning.service", "mechanism": "SPRING-DATA", "name": "Repositories (LoanProduct, ProvisioningCategory, GLAccount)", "description": "The class uses Spring Data repositories to fetch entities required to assemble the ProvisioningCriteria object. It performs read-only operations to retrieve LoanProducts, ProvisioningCategories, and GLAccounts by ID or all at once.", "databaseName": "unknown", "tablesAccessed": [ "LoanProduct", "ProvisioningCategory", "GLAccount" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations (findById, findAll)", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "loanProducts.add(loanProductRepository.findById(productId).orElse(null));" }, { "path": "org.apache.fineract.organisation.provisioning.service.ProvisioningCategoryWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ProvisioningCategoryRepository", "description": "The class primarily uses a Spring Data JPA repository (ProvisioningCategoryRepository) for CRUD operations on the ProvisioningCategory entity. Additionally, it uses Spring's JdbcTemplate to execute a raw SQL query for checking referential integrity constraints that might not be easily handled by JPA alone (checking usage in loan products).", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningCategory", "m_loanproduct_provisioning_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA CRUD operations (save, delete, findById) and one native SQL SELECT query using EXISTS logic.", "transactionHandling": "Spring Data default transaction handling (likely @Transactional at interface or repository level)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "this.provisioningCategoryRepository.saveAndFlush(provisioningCategory);" }, { "path": "org.apache.fineract.organisation.provisioning.service.ProvisioningCriteriaWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ProvisioningCriteriaRepository", "description": "The class uses Spring Data JPA repositories (ProvisioningCriteriaRepository and GLAccountRepository) to interact with the database. It performs CRUD operations on ProvisioningCriteria and GLAccount entities, relying on the underlying Hibernate implementation managed by Spring.", "databaseName": "unknown", "tablesAccessed": [ "ProvisioningCriteria", "GLAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA Repository methods (saveAndFlush, findById, deleteById).", "transactionHandling": "Implicitly handled by Spring Data repositories or service layer transaction management.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.provisioningCriteriaRepository.saveAndFlush(provisioningCriteria);" }, { "path": "org.apache.fineract.organisation.staff.domain", "mechanism": "SPRING-DATA", "name": "StaffRepository", "description": "The class uses a Spring Data repository (StaffRepository) to perform CRUD operations on the Staff entity.", "databaseName": "unknown", "tablesAccessed": [ "Staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and custom finders by office.", "transactionHandling": "Likely handled by Spring Data default transaction management or at the service layer invoking this wrapper.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new StaffNotFoundException(id));" }, { "path": "org.apache.fineract.organisation.staff.domain.StaffRepository", "mechanism": "SPRING-DATA", "name": "StaffRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository, which provides standard CRUD operations, and JpaSpecificationExecutor for dynamic queries. It also defines a custom JPQL query.", "databaseName": "unknown", "tablesAccessed": [ "Staff" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and one custom JPQL query for filtering by office.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(FIND_BY_OFFICE_QUERY)\nStaff findByOffice(@Param(\"id\") Long id, @Param(\"officeId\") Long officeId);" }, { "path": "org.apache.fineract.organisation.staff.service", "mechanism": "SPRING-DATA", "name": "StaffRepository", "description": "The class uses Spring Data JPA repositories (StaffRepository) to perform CRUD operations on Staff entities. It also uses OfficeRepositoryWrapper to retrieve Office entities. Transactions are managed via the @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "Staff", "Office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, findById) via JPA repositories.", "transactionHandling": "Spring @Transactional annotations on methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.staffRepository.saveAndFlush(staff);" }, { "path": "org.apache.fineract.organisation.teller.domain", "mechanism": "SPRING-DATA", "name": "TellerRepository", "description": "The interface extends JpaRepository and JpaSpecificationExecutor, indicating it is a Spring Data repository used to interact with the database for the Teller entity.", "databaseName": "unknown", "tablesAccessed": [ "Teller" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a derived query method for filtering by office ID.", "transactionHandling": "Spring Data JPA repositories typically use default @Transactional settings on inherited methods.", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface TellerRepository extends JpaRepository, JpaSpecificationExecutor { ... }" }, { "path": "org.apache.fineract.organisation.teller.domain", "mechanism": "SPRING-DATA", "name": "CashierRepository", "description": "The interface uses Spring Data JPA to manage persistence for the Cashier entity, inheriting standard CRUD and specification execution capabilities.", "databaseName": "unknown", "tablesAccessed": [ "Cashier" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository", "transactionHandling": "Spring Data JPA default transaction management", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface CashierRepository extends JpaRepository, JpaSpecificationExecutor {" }, { "path": "org.apache.fineract.organisation.teller.domain.CashierRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "CashierRepository", "description": "The class interacts with the database via a Spring Data repository interface (`CashierRepository`). It performs read operations to fetch entities by primary key.", "databaseName": "unknown", "tablesAccessed": [ "Cashier" ], "operationType": [ "READ" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new TellerNotFoundException(id));" }, { "path": "org.apache.fineract.organisation.teller.domain.CashierTransactionRepository", "mechanism": "SPRING-DATA", "name": "CashierTransactionRepository", "description": "This interface is a Spring Data JPA repository that manages persistence for the CashierTransaction entity. It automatically provides methods for saving, deleting, and finding entities, as well as executing complex criteria-based queries.", "databaseName": "unknown", "tablesAccessed": [ "CashierTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification queries handled by the framework.", "transactionHandling": "Spring Data JPA repositories typically apply @Transactional behavior by default (read-only for retrieval, read-write for modifications).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface CashierTransactionRepository\n extends JpaRepository, JpaSpecificationExecutor {\n // no added behavior\n}" }, { "path": "org.apache.fineract.organisation.teller.domain.TellerRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "TellerRepository", "description": "The class interacts with the database via a Spring Data repository interface (TellerRepository). It performs standard CRUD operations and utilizes JPA/Hibernate features like lazy loading initialization.", "databaseName": "unknown", "tablesAccessed": [ "Teller" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (findById, save, delete) provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional annotations used explicitly on read operations and implicitly via the repository for write operations.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Teller teller = this.repository.findById(id).orElseThrow(() -> new TellerNotFoundException(id));" }, { "path": "org.apache.fineract.organisation.teller.domain.TellerTransactionRepository", "mechanism": "SPRING-DATA", "name": "TellerTransactionRepository", "description": "The file is a Spring Data JPA repository interface. It provides database abstraction for the TellerTransaction entity, enabling CRUD operations and dynamic specification queries without explicit implementation code.", "databaseName": "unknown", "tablesAccessed": [ "TellerTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data JPA implementation proxy)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface TellerTransactionRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behavior\n}" }, { "path": "org.apache.fineract.organisation.teller.service.TellerWritePlatformServiceJpaImpl", "mechanism": "SPRING-DATA", "name": "Teller and Accounting Repositories", "description": "The class uses Spring Data JPA repositories (wrapped in Fineract wrappers) to interact with the database. It performs CRUD operations on Teller and Cashier entities and creates JournalEntry records for accounting.", "databaseName": "unknown", "tablesAccessed": [ "m_teller", "m_cashier", "m_cashier_transactions", "acc_gl_journal_entry", "m_office", "m_staff", "acc_gl_account", "acc_gl_financial_activity_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, delete, findById) and some custom finders via wrappers.", "transactionHandling": "Spring @Transactional annotations on public methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.tellerRepositoryWrapper.saveAndFlush(teller);" }, { "path": "org.apache.fineract.organisation.workingdays.domain", "mechanism": "SPRING-DATA", "name": "WorkingDaysRepository", "description": "The class wraps a Spring Data repository interface (WorkingDaysRepository) to perform CRUD operations on the WorkingDays entity.", "databaseName": "unknown", "tablesAccessed": [ "WorkingDays" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to Spring Data JPA repository.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final List workingDaysList = this.repository.findAll();" }, { "path": "org.apache.fineract.organisation.workingdays.domain.WorkingDaysRepository", "mechanism": "SPRING-DATA", "name": "WorkingDaysRepository", "description": "The interface uses Spring Data JPA to manage database interactions for the WorkingDays entity. By extending JpaRepository, it automatically provides implementations for standard CRUD operations, and JpaSpecificationExecutor allows for complex, dynamic queries.", "databaseName": "unknown", "tablesAccessed": [ "WorkingDays" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for find methods, read-write for others).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface WorkingDaysRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.organisation.workingdays.service", "mechanism": "SPRING-DATA", "name": "WorkingDaysRepositoryWrapper", "description": "The class uses a repository wrapper (likely wrapping a Spring Data JPA repository) to retrieve and save the WorkingDays entity.", "databaseName": "unknown", "tablesAccessed": [ "WorkingDays" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findOne, saveAndFlush) via a repository wrapper.", "transactionHandling": "Spring @Transactional annotation on the update method.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final WorkingDays workingDays = this.daysRepositoryWrapper.findOne();\n// ... updates ...\nthis.daysRepositoryWrapper.saveAndFlush(workingDays);" }, { "path": "org.apache.fineract.portfolio.account.domain", "mechanism": "SPRING-DATA", "name": "ClientRepositoryWrapper, OfficeRepositoryWrapper", "description": "The class uses repository wrappers to fetch Client and Office entities by ID. It also relies on other assemblers (SavingsAccountAssembler, LoanAssembler) which implicitly fetch account data from the database.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_office", "m_savings_account", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final Long fromClientId = this.fromApiJsonHelper.extractLongNamed(fromClientIdParamName, element);\nfinal Client fromClient = this.clientRepository.findOneWithNotFoundDetection(fromClientId);" }, { "path": "org.apache.fineract.portfolio.account.domain", "mechanism": "SPRING-DATA", "name": "StandingInstructionRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard data access methods, and by defining custom JPQL queries via the @Query annotation to perform complex filtering based on entity relationships.", "databaseName": "unknown", "tablesAccessed": [ "AccountTransferStandingInstruction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with logical OR conditions to check relationships (toLoanAccount/fromLoanAccount) and status filtering.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data repository proxies)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(FIND_BY_LOAN_AND_STATUS_QUERY)\nCollection findByLoanAccountAndStatus(@Param(\"loan\") Loan loan, @Param(\"status\") Integer status);" }, { "path": "org.apache.fineract.portfolio.account.domain", "mechanism": "SPRING-DATA", "name": "AccountAssociationsRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and defines custom JPQL queries for specific lookups.", "databaseName": "unknown", "tablesAccessed": [ "AccountAssociations" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries using @Query annotations with named parameters.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select aa from AccountAssociations aa where aa.loanAccount.id= :loanId and aa.associationType = :associationType\")" }, { "path": "org.apache.fineract.portfolio.account.domain", "mechanism": "SPRING-DATA", "name": "AccountTransferRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending `JpaRepository` and defining methods annotated with `@Query` containing JPQL to select data from the `AccountTransferTransaction` entity.", "databaseName": "unknown", "tablesAccessed": [ "AccountTransferTransaction" ], "operationType": [ "READ" ], "queryPatterns": "JPQL queries with filtering by foreign key IDs (loan accounts, loan transactions) and boolean flags (reversed status). Includes OR conditions and IN clauses.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "@Query(\"select att from AccountTransferTransaction att where att.accountTransferDetails.fromLoanAccount.id= :accountNumber and att.reversed=false\")" }, { "path": "org.apache.fineract.portfolio.account.domain.AccountTransferDetailRepository", "mechanism": "SPRING-DATA", "name": "AccountTransferDetailRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically implements the repository interface to interact with the underlying database using Hibernate/JPA.", "databaseName": "unknown", "tablesAccessed": [ "AccountTransferDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for find methods, read-write for save/delete).", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface AccountTransferDetailRepository\n extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.account.service", "mechanism": "SPRING-DATA", "name": "AccountTransferDetailRepository, StandingInstructionRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects AccountTransferDetailRepository and StandingInstructionRepository to save new transfer details and retrieve/update existing standing instructions. The operations are wrapped in a Spring @Transactional annotation to ensure atomicity.", "databaseName": "unknown", "tablesAccessed": [ "AccountTransferDetails", "AccountTransferStandingInstruction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById).", "transactionHandling": "Spring @Transactional annotation on the class level and methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.accountTransferDetailRepository.saveAndFlush(standingInstruction);" }, { "path": "org.apache.fineract.portfolio.account.service.AccountTransfersWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "AccountTransferRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It persists transfer details and transactions, and updates account balances via domain services that also use JPA.", "databaseName": "unknown", "tablesAccessed": [ "m_account_transfer_details", "m_account_transfer_transaction", "m_loan", "m_savings_account", "gsim_accounts" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, saveAndFlush, findBy...) and domain service operations.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.accountTransferDetailRepository.saveAndFlush(accountTransferDetails);" }, { "path": "org.apache.fineract.portfolio.account.starter", "mechanism": "SPRING-DATA", "name": "Account and Standing Instruction Services", "description": "This configuration class wires up services that interact with the database using two primary mechanisms: Spring JDBC (via JdbcTemplate) for read-only platform services, and Spring Data JPA (via Repositories) for write platform services. The read services execute SQL queries directly, while the write services use repositories for entity persistence.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The configured services likely use a mix of direct SQL SELECTs (read services) and JPA entity operations (write services).", "transactionHandling": "Spring @Transactional (likely used within the service implementations being configured)", "protocol": "unknown", "connectionInfo": "Configured via Spring Boot DataSource (injected into JdbcTemplate)", "codeExample": "public AccountAssociationsReadPlatformService accountAssociationsReadPlatformService(JdbcTemplate jdbcTemplate) {\n return new AccountAssociationsReadPlatformServiceImpl(jdbcTemplate);\n}" }, { "path": "org.apache.fineract.portfolio.address.domain.AddressRepository", "mechanism": "SPRING-DATA", "name": "AddressRepository", "description": "The interface utilizes Spring Data JPA to automatically generate database access logic. By extending JpaRepository, it gains standard CRUD capabilities, and by extending JpaSpecificationExecutor, it gains the ability to run dynamic queries based on JPA Criteria.", "databaseName": "unknown", "tablesAccessed": [ "Address" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic criteria-based queries via Specifications.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JPA", "connectionInfo": "configured externally", "codeExample": "public interface AddressRepository extends JpaRepository, JpaSpecificationExecutor
{}" }, { "path": "org.apache.fineract.portfolio.address.domain.FieldConfigurationRepository", "mechanism": "SPRING-DATA", "name": "FieldConfigurationRepository", "description": "This interface is a Spring Data JPA repository that manages database interactions for the FieldConfiguration entity. It automatically maps Java methods to database SQL operations via Hibernate/JPA.", "databaseName": "unknown", "tablesAccessed": [ "FieldConfiguration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface FieldConfigurationRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.address.service.AddressWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "AddressRepository, ClientAddressRepository", "description": "The class uses Spring Data JPA repositories to perform CRUD operations on Address and ClientAddress entities. It injects these repositories and uses methods like save(), saveAndFlush(), and getReferenceById() to persist data.", "databaseName": "unknown", "tablesAccessed": [ "Address", "ClientAddress", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA repositories.", "transactionHandling": "Implicitly handled by Spring Data repositories or the calling context (no explicit @Transactional on this class).", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "addressRepository.save(address);\nclientAddressRepository.saveAndFlush(clientAddress);" }, { "path": "org.apache.fineract.portfolio.calendar.domain", "mechanism": "SPRING-DATA", "name": "CalendarRepository", "description": "The class interacts with the database through a Spring Data repository interface named CalendarRepository. It performs standard CRUD operations.", "databaseName": "unknown", "tablesAccessed": [ "Calendar" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to Spring Data JPA repository.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findById(calendarId).orElseThrow(() -> new CalendarNotFoundException(calendarId));" }, { "path": "org.apache.fineract.portfolio.calendar.domain", "mechanism": "SPRING-DATA", "name": "CalendarHistoryRepository", "description": "The interface acts as a Spring Data JPA repository, automatically generating the implementation for database interactions involving the CalendarHistory entity.", "databaseName": "unknown", "tablesAccessed": [ "CalendarHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic queries via JPA Specifications.", "transactionHandling": "Spring Data JPA repositories typically participate in Spring-managed transactions (@Transactional) by default.", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public interface CalendarHistoryRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.calendar.domain", "mechanism": "SPRING-DATA", "name": "CalendarInstanceRepository", "description": "The class wraps a Spring Data repository interface to perform CRUD operations on the CalendarInstance entity.", "databaseName": "unknown", "tablesAccessed": [ "CalendarInstance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to the repository.", "transactionHandling": "Likely handled by the underlying Spring Data repository implementation or higher-level service transactions.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findById(CalendarInstanceId).orElseThrow(() -> new CalendarInstanceNotFoundException(CalendarInstanceId));" }, { "path": "org.apache.fineract.portfolio.calendar.domain", "mechanism": "SPRING-DATA", "name": "CalendarInstanceRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, allowing for standard CRUD operations and custom JPQL queries defined via annotations.", "databaseName": "unknown", "tablesAccessed": [ "CalendarInstance", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The repository uses both simple derived queries (CRUD) and complex JPQL queries involving subqueries and joins with the Loan entity.", "transactionHandling": "Transactions are handled by the Spring container, typically defaulting to @Transactional(readOnly = true) for query methods in JpaRepository implementations.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select ci from CalendarInstance ci where ci.entityId in (select loan.id from Loan loan where loan.client.id = :clientId...)\")" }, { "path": "org.apache.fineract.portfolio.calendar.domain.CalendarRepository", "mechanism": "SPRING-DATA", "name": "CalendarRepository", "description": "The interface uses Spring Data JPA to manage database interactions for the Calendar entity. By extending JpaRepository, it inherits methods for saving, deleting, and finding entities. By extending JpaSpecificationExecutor, it supports complex, dynamic queries based on the JPA Criteria API.", "databaseName": "unknown", "tablesAccessed": [ "Calendar" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface CalendarRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.calendar.service", "mechanism": "SPRING-DATA", "name": "CalendarRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects repositories for Calendar, CalendarHistory, CalendarInstance, and related entities (Group, Loan, Client) to perform CRUD operations and fetch relationships.", "databaseName": "unknown", "tablesAccessed": [ "Calendar", "CalendarHistory", "CalendarInstance", "Group", "Loan", "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findById, delete) and some custom finders (findByEntityIdAndEntityTypeIdAndCalendarTypeId).", "transactionHandling": "Likely managed by Spring @Transactional at the interface or service layer (not explicitly visible in this class file but implied by usage of JPA).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.calendarRepository.saveAndFlush(newCalendar);" }, { "path": "org.apache.fineract.portfolio.calendar.starter", "mechanism": "SPRING-DATA", "name": "Calendar Services Configuration", "description": "This configuration class wires up database access components. It injects a JdbcTemplate for read services (JDBC mechanism) and multiple Spring Data JPA Repositories (CalendarRepository, CalendarHistoryRepository, etc.) for write services. While this file does not execute queries directly, it constructs the services that perform READ and WRITE operations against the database.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Configures services that likely perform CRUD operations via JPA and reporting queries via JDBC.", "transactionHandling": "Transactions are likely handled by the service implementations this class configures (e.g., @Transactional on the ServiceImpl classes), not in this configuration file itself.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Bean\npublic CalendarReadPlatformService calendarReadPlatformService(JdbcTemplate jdbcTemplate, ...) {\n return new CalendarReadPlatformServiceImpl(jdbcTemplate, ...);\n}" }, { "path": "org.apache.fineract.portfolio.charge.domain", "mechanism": "SPRING-DATA", "name": "ChargeRepository", "description": "The class interacts with the database through the injected ChargeRepository, which is a Spring Data repository interface. It performs read operations to fetch Charge entities by their primary key.", "databaseName": "unknown", "tablesAccessed": [ "Charge" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (findById)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final Charge chargeDefinition = this.repository.findById(id).orElseThrow(() -> new ChargeNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.charge.domain.ChargeRepository", "mechanism": "SPRING-DATA", "name": "ChargeRepository", "description": "This interface is a Spring Data JPA repository that manages persistence for the Charge entity. It automatically provides implementations for standard database operations.", "databaseName": "unknown", "tablesAccessed": [ "Charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic JPA Specifications.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ChargeRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.portfolio.charge.service.ChargeWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ChargeRepository, JdbcTemplate", "description": "The class primarily uses Spring Data JPA repositories (ChargeRepository, LoanProductRepository, etc.) for managing the lifecycle of Charge entities. However, it also heavily relies on Spring's JdbcTemplate to execute raw SQL queries for complex validation logic, specifically to check for the existence of related records in tables like 'm_loan_charge' and 'm_savings_account_charge' which might not be efficiently loaded via JPA relationships during validation.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_loan_charge", "m_savings_account_charge", "m_product_loan_charge", "m_savings_product_charge", "m_gl_account", "m_tax_group", "m_payment_type" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM queries for CRUD operations; Inline SQL for existence checks and validation.", "transactionHandling": "Spring @Transactional annotations on public methods.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final String sql = \"select (CASE WHEN exists (select 1 from m_loan_charge lc where lc.charge_id = ? and lc.is_active = true) THEN 'true' ELSE 'false' END)\";\nfinal String isLoansUsingCharge = this.jdbcTemplate.queryForObject(sql, String.class, new Object[] { chargeId });" }, { "path": "org.apache.fineract.portfolio.client.api", "mechanism": "SPRING-DATA", "name": "ClientRepositoryWrapper", "description": "The code uses a wrapper around a Spring Data repository (ClientRepositoryWrapper) to fetch Client entities from the database by their ID.", "databaseName": "unknown", "tablesAccessed": [ "Client" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by primary key", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Client client = clientRepositoryWrapper.findOneWithNotFoundDetection(clientId);" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "SPRING-DATA", "name": "ClientTransactionRepository", "description": "The interface extends JpaRepository, indicating it is a Spring Data JPA repository used for database persistence. It manages the ClientTransaction entity.", "databaseName": "unknown", "tablesAccessed": [ "ClientTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived queries and standard CRUD operations.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface ClientTransactionRepository extends JpaRepository, JpaSpecificationExecutor" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "SPRING-DATA", "name": "ClientChargeRepository", "description": "The class interacts with the database through the ClientChargeRepository, which is a Spring Data repository interface. It performs CRUD operations on the ClientCharge entity.", "databaseName": "unknown", "tablesAccessed": [ "ClientCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Repository interface methods (findById, save, delete).", "transactionHandling": "Implicitly handled by the Spring Data repository implementation or the calling service context.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final ClientCharge clientCharge = this.repository.findById(id).orElseThrow(() -> new ChargeNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "SPRING-DATA", "name": "ClientRepository", "description": "The file is a Spring Data JPA repository interface that manages database interactions for the Client entity. It uses JPQL annotations to define custom queries involving joins and conditional logic.", "databaseName": "unknown", "tablesAccessed": [ "Client", "Office" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with joins, projections, and parameter binding.", "transactionHandling": "Spring Data default transaction management", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT c.id FROM Client c WHERE c.externalId = :externalId\")" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "SPRING-DATA", "name": "ClientAddressRepository", "description": "The class interacts with the database through a Spring Data repository interface (ClientAddressRepository). It performs read operations to fetch ClientAddress entities based on various filtering criteria.", "databaseName": "unknown", "tablesAccessed": [ "ClientAddress" ], "operationType": [ "READ" ], "queryPatterns": "Simple finder methods based on entity attributes (clientId, addressType, isActive, addressId).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ClientAddress clientAddress = this.clientAddressRepository.findByClientIdAndAddressTypeAndIsActive(clientId, addressType, isActive);" }, { "path": "org.apache.fineract.portfolio.client.domain", "mechanism": "SPRING-DATA", "name": "ClientNonPersonRepository", "description": "Database integration is achieved through Spring Data JPA, which maps the ClientNonPerson entity to a database table and provides repository methods.", "databaseName": "unknown", "tablesAccessed": [ "ClientNonPerson" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Uses standard CRUD operations provided by JpaRepository and a custom JPQL query for lookup by foreign key.", "transactionHandling": "Spring Data repositories typically participate in Spring managed transactions (@Transactional).", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "@Query(\"select clientNonPerson from ClientNonPerson clientNonPerson where clientNonPerson.client.id = :clientId\")" }, { "path": "org.apache.fineract.portfolio.client.domain.AccountNumberGenerator", "mechanism": "SPRING-DATA", "name": "Repositories (Client, Loan, SavingsAccount)", "description": "The class uses Spring Data repositories to check for account number conflicts when random number generation is enabled. It queries the database to ensure a generated random number is not already assigned to an existing entity.", "databaseName": "unknown", "tablesAccessed": [ "client", "loan", "savings_account" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookups by account number to check existence.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Client client = this.clientRepository.getClientByAccountNumber(accountNumber);" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientAddressRepository", "mechanism": "SPRING-DATA", "name": "ClientAddressRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard data access methods and defines custom JPQL queries for specific lookups.", "databaseName": "unknown", "tablesAccessed": [ "ClientAddress" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with parameter binding", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "@Query(\"SELECT clientAddress FROM ClientAddress clientAddress WHERE clientAddress.client.id = :clientId...\")" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientChargeRepository", "mechanism": "SPRING-DATA", "name": "ClientChargeRepository", "description": "This interface is a Spring Data JPA repository that manages persistence for the ClientCharge entity. It inherits standard database operations from JpaRepository.", "databaseName": "unknown", "tablesAccessed": [ "ClientCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data infrastructure.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface ClientChargeRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientFamilyMembersRepository", "mechanism": "SPRING-DATA", "name": "ClientFamilyMembersRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically generates SQL queries based on the interface definition and inherited methods. It manages the lifecycle of the ClientFamilyMembers entity.", "databaseName": "unknown", "tablesAccessed": [ "ClientFamilyMembers" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by JpaRepository and JpaSpecificationExecutor.", "transactionHandling": "Spring @Transactional (default behavior for Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "configured externally", "codeExample": "public interface ClientFamilyMembersRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientIdentifierRepository", "mechanism": "SPRING-DATA", "name": "ClientIdentifierRepository", "description": "The interface is a Spring Data JPA repository, which automatically generates SQL queries and handles database connections based on the method names and inherited interfaces.", "databaseName": "unknown", "tablesAccessed": [ "ClientIdentifier" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD and Specification-based dynamic queries provided by Spring Data JPA.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for find methods, read-write for others).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ClientIdentifierRepository extends JpaRepository, JpaSpecificationExecutor {\n // no behaviour\n}" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientNonPersonRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ClientNonPersonRepository", "description": "The class interacts with the database via a Spring Data repository interface (ClientNonPersonRepository). It performs standard CRUD operations (findById, findByClientId, save, delete) on the 'ClientNonPerson' entity.", "databaseName": "unknown", "tablesAccessed": [ "ClientNonPerson" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and find-by-field queries.", "transactionHandling": "Likely relies on Spring's @Transactional at the service layer or default repository transactionality.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "return this.repository.findById(id).orElseThrow(() -> new ClientNonPersonNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ClientRepository", "description": "The class wraps a Spring Data repository (ClientRepository) to perform database operations. It uses standard JPA/Spring Data patterns for finding, saving, and deleting entities, while adding a layer of exception handling.", "databaseName": "unknown", "tablesAccessed": [ "Client" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via Spring Data JPA, plus specific lookups by account number and hierarchy.", "transactionHandling": "Spring @Transactional annotations are used, specifically @Transactional(readOnly = true) for retrieval methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Client client = this.repository.findById(clientId).orElseThrow(() -> new ClientNotFoundException(clientId));" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientTransactionRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ClientTransactionRepository", "description": "The class interacts with the database through a Spring Data repository interface (ClientTransactionRepository). It performs standard CRUD operations (save, delete, findById) on the ClientTransaction entity.", "databaseName": "unknown", "tablesAccessed": [ "ClientTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ClientTransaction clientTransaction = this.repository.findById(transactionId)\n .orElseThrow(() -> new ClientTransactionNotFoundException(clientId, transactionId));" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientTransferDetailsRepository", "mechanism": "SPRING-DATA", "name": "ClientTransferDetailsRepository", "description": "Database integration is achieved through Spring Data JPA, which abstracts the underlying JDBC/Hibernate interactions. The repository interface allows the application to interact with the 'ClientTransferDetails' table (or mapped entity) using object-oriented methods.", "databaseName": "unknown", "tablesAccessed": [ "ClientTransferDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for find methods, read-write for save/delete).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ClientTransferDetailsRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.client.domain.ClientTransferDetailsRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ClientTransferDetailsRepository", "description": "The class interacts with the database through a Spring Data repository interface (ClientTransferDetailsRepository). It delegates persistence operations (specifically 'save') to this repository, which abstracts the underlying SQL or JPA operations.", "databaseName": "unknown", "tablesAccessed": [ "ClientTransferDetails" ], "operationType": [ "WRITE" ], "queryPatterns": "Simple CRUD operation (save)", "transactionHandling": "Delegated to Repository/Spring Data default transaction management", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.save(clientTransferDetails);" }, { "path": "org.apache.fineract.portfolio.client.domain.search.SearchingClientRepository", "mechanism": "SPRING-DATA", "name": "SearchingClientRepository", "description": "This interface is part of the Data Access Layer using Spring Data conventions. It defines a custom search operation that will interact with the underlying database to retrieve client records.", "databaseName": "unknown", "tablesAccessed": [ "SearchedClient" ], "operationType": [ "READ" ], "queryPatterns": "Search query with text matching and hierarchy filtering", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Page searchByText(String searchText, Pageable pageable, String officeHierarchy);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "SPRING-DATA", "name": "Client Charge Transaction Service", "description": "This interface defines the transactional boundaries for database write operations regarding client charges. While it does not contain the actual data access code, the use of @Transactional annotations mandates that the implementing class will interact with the database within a transaction context to ensure data integrity during add, update, delete, and state-change operations.", "databaseName": "unknown", "tablesAccessed": [ "m_client_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Transactional write operations (CRUD and state transitions)", "transactionHandling": "Spring @Transactional annotations on all methods", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\nCommandProcessingResult addCharge(Long clientId, JsonCommand command);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "SPRING-DATA", "name": "ClientIdentifierRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects `ClientIdentifierRepository` (likely extending JpaRepository) to perform CRUD operations on `ClientIdentifier` entities. It also uses `ClientRepositoryWrapper` and `CodeValueRepositoryWrapper` for related data lookups.", "databaseName": "unknown", "tablesAccessed": [ "ClientIdentifier", "Client", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, findById, delete) and entity relationship lookups.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.clientIdentifierRepository.saveAndFlush(clientIdentifier);" }, { "path": "org.apache.fineract.portfolio.client.service", "mechanism": "SPRING-DATA", "name": "ClientTransactionRepositoryWrapper", "description": "The class interacts with the database using repository wrappers (likely wrapping Spring Data JPA repositories) to fetch and persist domain entities. It performs read operations to retrieve Client and ClientTransaction entities, and write operations to update the transaction status and associated charges.", "databaseName": "unknown", "tablesAccessed": [ "Client", "ClientTransaction", "ClientCharge", "ClientChargePaidBy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository wrappers (findOneWithNotFoundDetection) and entity state transitions followed by saveAndFlush.", "transactionHandling": "Implicitly handled by the framework or calling context (likely Spring @Transactional at the interface level), with explicit 'saveAndFlush' calls.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.clientTransactionRepository.saveAndFlush(clientTransaction);" }, { "path": "org.apache.fineract.portfolio.client.service.ClientChargeWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "ClientChargeRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in Fineract specific wrappers) to perform CRUD operations on Client, Charge, and ClientCharge entities. It handles transaction management implicitly through the service layer and explicitly calls saveAndFlush for immediate persistence.", "databaseName": "unknown", "tablesAccessed": [ "m_client_charge", "m_client", "m_charge", "m_client_transaction", "m_payment_detail" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Standard JPA repository methods (findOne, save, delete) with some custom finders for active clients.", "transactionHandling": "Likely handled by Spring @Transactional at the interface or aspect level, though not explicitly annotated on this class. Uses saveAndFlush suggesting immediate DB synchronization.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.clientChargeRepository.saveAndFlush(clientCharge);" }, { "path": "org.apache.fineract.portfolio.client.service.ClientFamilyMembersWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "ClientFamilyMembersRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects ClientFamilyMembersRepository and CodeValueRepository to perform CRUD operations. It uses methods like saveAndFlush, getReferenceById, and delete.", "databaseName": "unknown", "tablesAccessed": [ "ClientFamilyMembers", "Client", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations using JPA repository methods. Some lookups by ID.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.clientFamilyRepository.saveAndFlush(clientFamilyMembers);" }, { "path": "org.apache.fineract.portfolio.client.service.search", "mechanism": "SPRING-DATA", "name": "ClientRepository", "description": "The service uses a Spring Data repository (ClientRepository) to perform database searches. It relies on the repository's abstraction to execute a query that filters clients by text and office hierarchy.", "databaseName": "unknown", "tablesAccessed": [ "Client" ], "operationType": [ "READ" ], "queryPatterns": "Search query with text filtering, hierarchy scoping, and pagination.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "clientRepository.searchByText(searchText, pageable, hierarchy).map(clientSearchDataMapper::map);" }, { "path": "org.apache.fineract.portfolio.collateral.domain.LoanCollateralRepository", "mechanism": "SPRING-DATA", "name": "LoanCollateralRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access operations and JpaSpecificationExecutor for criteria-based querying.", "databaseName": "unknown", "tablesAccessed": [ "LoanCollateral" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Method name derivation (findBy...) and standard CRUD operations provided by JpaRepository.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository default implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "LoanCollateral findByLoanIdAndId(Long loanId, Long id);" }, { "path": "org.apache.fineract.portfolio.collateral.service", "mechanism": "SPRING-DATA", "name": "LoanCollateralRepository, CodeValueRepositoryWrapper", "description": "The class interacts with the database to retrieve existing LoanCollateral entities by ID and CodeValue entities by ID. It uses Spring Data repositories (or wrappers around them) to perform these read operations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_collateral", "m_code_value" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations (findById)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final LoanCollateral loanCollateralItem = this.loanCollateralRepository.findById(id)\n .orElseThrow(() -> new CollateralNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.collateral.service.CollateralWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "LoanCollateralRepository", "description": "The class interacts with the database using Spring Data JPA repositories (LoanCollateralRepository) and wrapper classes (LoanRepositoryWrapper, CodeValueRepositoryWrapper). It performs transactional CRUD operations on LoanCollateral entities and retrieves related Loan and CodeValue entities.", "databaseName": "unknown", "tablesAccessed": [ "LoanCollateral", "Loan", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations using repository methods like findOne, saveAndFlush, and delete.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.collateralRepository.saveAndFlush(collateral);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain", "mechanism": "SPRING-DATA", "name": "ClientCollateralManagementRepository", "description": "The file uses Spring Data JPA repositories to abstract database interactions. It extends JpaRepository to provide standard data access methods and defines custom JPQL queries for specific lookups.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring Data repositories typically participate in Spring @Transactional contexts", "protocol": "JPA/JDBC", "connectionInfo": "configured externally", "codeExample": "@Query(\"select clientCollateral from ClientCollateralManagement clientCollateral where clientCollateral.client=:client\")" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain", "mechanism": "SPRING-DATA", "name": "ClientCollateralManagementRepository", "description": "The class interacts with the database via Spring Data JPA repositories (ClientCollateralManagementRepository, ClientRepositoryWrapper, LoanProductRepository). It performs standard CRUD operations and relational lookups.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement", "Client", "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, save, deleteById) and derived query methods (findByClientId).", "transactionHandling": "Implicitly handled by Spring Data repositories or the calling service context (no explicit @Transactional on this class).", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "this.clientCollateralManagementRepository.findByClientId(client);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain.CollateralManagementDomainRepository", "mechanism": "SPRING-DATA", "name": "CollateralManagementDomainRepository", "description": "The file defines a Spring Data JPA repository interface, which abstracts the interaction with the underlying relational database for the CollateralManagementDomain entity.", "databaseName": "unknown", "tablesAccessed": [ "CollateralManagementDomain" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, findById, delete) and dynamic queries via Specifications.", "transactionHandling": "Transactions are handled implicitly by the Spring Data JPA implementation, typically with read-only transactions for retrieval and read-write transactions for modifications.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface CollateralManagementDomainRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.domain.CollateralManagementRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "CollateralManagementDomainRepository", "description": "The class uses a Spring Data repository (inferred from method names like saveAndFlush, findById, deleteById) to interact with the database. It performs CRUD operations on the CollateralManagementDomain entity.", "databaseName": "unknown", "tablesAccessed": [ "CollateralManagementDomain" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Spring Data JPA methods (saveAndFlush, findById, findAll, deleteById).", "transactionHandling": "Likely handled by the underlying Spring Data repository or service layer transaction management (not explicitly visible in this wrapper).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.collateralManagementDomainRepository.saveAndFlush(collateralData);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service", "mechanism": "SPRING-DATA", "name": "LoanCollateralAssembler", "description": "The class uses Spring Data repositories and wrapper services to interact with the database. It fetches 'ClientCollateralManagement' entities to check availability and 'LoanCollateralManagement' entities to check existing state. It modifies the state of these managed entities (updating quantities), which are then persisted by the JPA context.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement", "LoanCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, getCollateral) and entity state updates.", "transactionHandling": "Implicitly relies on the transaction context of the caller (likely Spring @Transactional on the service layer invoking this assembler).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "LoanCollateralManagement loanCollateralManagement = this.loanCollateralRepository.findById(id)\n .orElseThrow(() -> new LoanCollateralManagementNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service", "mechanism": "SPRING-DATA", "name": "CollateralManagementRepositoryWrapper", "description": "The class interacts with the database indirectly through the `CollateralManagementRepositoryWrapper`. This wrapper likely encapsulates a Spring Data JPA repository or similar persistence mechanism to fetch `CollateralManagementDomain` entities.", "databaseName": "unknown", "tablesAccessed": [ "CollateralManagementDomain" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD read operations (findById, findAll)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final CollateralManagementDomain collateralManagementDomain = this.collateralManagementRepositoryWrapper.getCollateral(collateralId);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service", "mechanism": "SPRING-DATA", "name": "LoanCollateralManagementRepository, ClientCollateralManagementRepositoryWrapper", "description": "The class interacts with the database using Spring Data JPA repositories. It performs read operations to fetch entities, update operations to modify collateral quantities, and delete operations to remove loan collateral records.", "databaseName": "unknown", "tablesAccessed": [ "LoanCollateralManagement", "ClientCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (findById, saveAndFlush, deleteById) via JPA repositories.", "transactionHandling": "Spring @Transactional annotation on the delete method.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "final LoanCollateralManagement loanCollateralManagement = this.loanCollateralManagementRepository.findById(id).orElseThrow();" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service", "mechanism": "SPRING-DATA", "name": "LoanTransactionRepository", "description": "The class interacts with the database primarily through Spring Data repositories (LoanTransactionRepository) and a wrapper around another repository (ClientCollateralManagementRepositoryWrapper). It performs read operations to fetch entities by ID or by client association.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement", "LoanTransaction", "LoanCollateralManagement" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD read operations and traversal of JPA entity relationships.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "LoanTransaction loanTransaction = this.loanTransactionRepository.findById(transactionId)\n .orElseThrow(() -> new LoanTransactionNotFoundException(transactionId));" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service", "mechanism": "SPRING-DATA", "name": "ClientCollateralManagementRepositoryWrapper", "description": "The class uses Repository Wrappers (likely wrapping Spring Data JPA repositories) to interact with the database. It performs CRUD operations on ClientCollateralManagement entities and fetches related Client and CollateralManagementDomain entities.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement", "Client", "CollateralManagementDomain", "LoanCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository abstraction. Some logic involves traversing sets (LoanCollateralManagementSet) which implies lazy or eager loading of related entities.", "transactionHandling": "Spring @Transactional annotations on public methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.clientCollateralManagementRepositoryWrapper.saveAndFlush(clientCollateralManagement);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service.CollateralManagementWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "CollateralManagementRepositoryWrapper", "description": "The class uses a Repository Wrapper pattern (likely wrapping Spring Data JPA repositories) to interact with the database. It performs CRUD operations on CollateralManagementDomain and ApplicationCurrency entities. Transactions are managed via Spring's @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "CollateralManagementDomain", "ApplicationCurrency", "ClientCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (create, findOne, update, delete) via repository abstraction.", "transactionHandling": "Spring @Transactional annotations on class and methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final CollateralManagementDomain collateral = CollateralManagementDomain.createNew(jsonCommand, applicationCurrency);\nthis.collateralManagementRepositoryWrapper.create(collateral);" }, { "path": "org.apache.fineract.portfolio.collateralmanagement.service.LoanCollateralManagementReadPlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanRepository, LoanCollateralManagementRepository", "description": "The class uses Spring Data JPA repositories to perform read-only operations on the database. It accesses `Loan` and `LoanCollateralManagement` entities via `findById` and `findByLoan` methods.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanCollateralManagement" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID and association traversal.", "transactionHandling": "Spring @Transactional(readOnly = true) annotation on the class level.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "Loan loan = this.loanRepository.findById(loanId).orElseThrow(() -> new LoanNotFoundException(loanId));" }, { "path": "org.apache.fineract.portfolio.delinquency.domain", "mechanism": "SPRING-DATA", "name": "DelinquencyBucketMappingsRepository", "description": "Database integration is achieved through Spring Data JPA. The interface extends JpaRepository, which acts as a proxy to the underlying EntityManager, handling database interactions for the DelinquencyBucketMappings entity.", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyBucketMappings" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific select query filtering by a foreign key association.", "transactionHandling": "Transactions are handled by the Spring container, typically with read-only transactions for retrieval methods and read-write for state-changing methods inherited from JpaRepository.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface DelinquencyBucketMappingsRepository extends JpaRepository ..." }, { "path": "org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketRepository", "mechanism": "SPRING-DATA", "name": "DelinquencyBucketRepository", "description": "Database integration is achieved through Spring Data JPA repositories. The interface inherits standard CRUD operations (save, findById, delete, etc.) from JpaRepository and dynamic query capabilities from JpaSpecificationExecutor.", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyBucket" ], "operationType": [ "READ", "WRITE", "READ_WRITE" ], "queryPatterns": "Spring Data derived queries (findByName) and standard CRUD operations provided by JpaRepository.", "transactionHandling": "Spring @Transactional (default behavior for JpaRepository methods)", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface DelinquencyBucketRepository extends JpaRepository { ... }" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.DelinquencyRangeRepository", "mechanism": "SPRING-DATA", "name": "DelinquencyRangeRepository", "description": "The interface uses Spring Data JPA to interact with the database. It maps the DelinquencyRange entity to a database table and provides methods for data manipulation and retrieval without writing explicit SQL.", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyRange" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and a specific property-based lookup (findByClassification).", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface DelinquencyRangeRepository extends JpaRepository {\n Optional findByClassification(String classification);\n}" }, { "path": "org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistoryRepository", "mechanism": "SPRING-DATA", "name": "LoanDelinquencyTagHistoryRepository", "description": "The interface extends JpaRepository, indicating it uses Spring Data JPA for database interactions. It maps the LoanDelinquencyTagHistory entity to a database table and provides methods to perform CRUD operations and custom queries without writing explicit SQL.", "databaseName": "unknown", "tablesAccessed": [ "LoanDelinquencyTagHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived query methods (findBy..., countBy...)", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "public interface LoanDelinquencyTagHistoryRepository\n extends JpaRepository, JpaSpecificationExecutor {\n LoanDelinquencyTagHistory findFirstByLoanOrderByAddedOnDateDesc(Loan loan);" }, { "path": "org.apache.fineract.portfolio.delinquency.service.DelinquencyReadPlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "Delinquency and Loan Repositories", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs read operations on DelinquencyRange, DelinquencyBucket, LoanDelinquencyTagHistory, and Loan entities. It uses standard JPA methods like findAll, getReferenceById, and custom query methods defined in the repository interfaces (e.g., findByLoanAndLiftedOnDate).", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyRange", "DelinquencyBucket", "LoanDelinquencyTagHistory", "Loan", "LoanTransaction" ], "operationType": [ "READ" ], "queryPatterns": "Standard CRUD reads and specific finder methods (findByLoan...) provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional(readOnly = true) annotation at the class level.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final List delinquencyRangeList = repositoryRange.findAll();" }, { "path": "org.apache.fineract.portfolio.delinquency.service.DelinquencyWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "Delinquency Repositories", "description": "The class uses multiple Spring Data JPA repositories to interact with the database. It performs CRUD operations on DelinquencyRange, DelinquencyBucket, and LoanDelinquencyTagHistory entities. It also uses `saveAndFlush` for immediate persistence.", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyRange", "DelinquencyBucket", "DelinquencyBucketMappings", "LoanDelinquencyTagHistory", "Loan", "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, delete, findById, countBy...) and some custom finders like `findByClassification` or `findByLoan`.", "transactionHandling": "Likely Spring @Transactional (implied by service layer usage in Fineract), plus explicit `saveAndFlush` calls.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "DelinquencyRange newDelinquencyRange = DelinquencyRange.instance(data.getClassification(), ...);\nreturn repositoryRange.saveAndFlush(newDelinquencyRange);" }, { "path": "org.apache.fineract.portfolio.delinquency.starter.DelinquencyConfiguration", "mechanism": "SPRING-DATA", "name": "Delinquency Repositories", "description": "This configuration class wires up Spring Data repositories (e.g., DelinquencyRangeRepository, LoanRepository) into the service beans. While this specific file does not execute queries, it is the integration point that enables database access for the Delinquency module by injecting the persistence layer components.", "databaseName": "unknown", "tablesAccessed": [ "DelinquencyRange", "DelinquencyBucket", "DelinquencyBucketMappings", "LoanDelinquencyTagHistory", "Loan", "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository injection for CRUD operations", "transactionHandling": "Delegated to the service implementations (likely Spring @Transactional)", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "public DelinquencyReadPlatformService delinquencyReadPlatformService(DelinquencyRangeRepository repositoryRange, ...) {\n return new DelinquencyReadPlatformServiceImpl(repositoryRange, ...);\n}" }, { "path": "org.apache.fineract.portfolio.floatingrates.domain", "mechanism": "SPRING-DATA", "name": "FloatingRateRepository", "description": "The class interacts with the database through an injected Spring Data repository interface (FloatingRateRepository). It performs standard CRUD operations (save, findById) and custom queries defined in the repository.", "databaseName": "unknown", "tablesAccessed": [ "FloatingRate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and ID-based lookups.", "transactionHandling": "Transaction management is likely handled by the underlying Spring Data repository implementation or the calling service layer.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.floatingRateRepository.findById(id).orElseThrow(() -> new FloatingRateNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.floatingrates.domain", "mechanism": "SPRING-DATA", "name": "FloatingRateRepository", "description": "The file uses Spring Data JPA to abstract database interactions. It extends `JpaRepository` to provide standard data access methods and defines custom queries using JPQL annotations.", "databaseName": "unknown", "tablesAccessed": [ "FloatingRate", "FloatingRatePeriod" ], "operationType": [ "READ" ], "queryPatterns": "JPQL queries with inner joins and boolean logic filters.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select floatingRate from FloatingRate floatingRate where floatingRate.isBaseLendingRate = true...\")" }, { "path": "org.apache.fineract.portfolio.floatingrates.serialization.FloatingRateDataValidator", "mechanism": "SPRING-DATA", "name": "FloatingRateRepository", "description": "The class uses `FloatingRateRepository` to perform read-only checks against the database during validation. It verifies if a Base Lending Rate already exists and checks for dependencies when modifying a Base Lending Rate.", "databaseName": "unknown", "tablesAccessed": [ "FloatingRate" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookups to check existence of entities based on boolean flags (isBaseLendingRate) and relationships.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "FloatingRate baseLendingRate = this.floatingRateRepository.retrieveBaseLendingRate();" }, { "path": "org.apache.fineract.portfolio.floatingrates.service.FloatingRateWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "FloatingRateRepositoryWrapper", "description": "The class uses a repository wrapper (FloatingRateRepositoryWrapper) to interact with the database. This wrapper likely delegates to a Spring Data JPA repository for standard CRUD operations on the FloatingRate entity.", "databaseName": "unknown", "tablesAccessed": [ "FloatingRate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (saveAndFlush, findOneWithNotFoundDetection, save) via repository abstraction.", "transactionHandling": "Transactions are managed using Spring's @Transactional annotation on the service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.floatingRateRepository.saveAndFlush(newFloatingRate);" }, { "path": "org.apache.fineract.portfolio.fund.domain", "mechanism": "SPRING-DATA", "name": "FundRepository", "description": "The interface is a Spring Data JPA repository that manages the persistence of the Fund entity without requiring boilerplate JDBC code.", "databaseName": "unknown", "tablesAccessed": [ "Fund" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic queries via JpaSpecificationExecutor.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for find methods, read-write for others).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface FundRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.portfolio.fund.service", "mechanism": "SPRING-DATA", "name": "FundRepository", "description": "The class uses a Spring Data JPA repository (`FundRepository`) to perform CRUD operations on the `Fund` entity. It relies on `saveAndFlush` for persistence and `findById` for retrieval.", "databaseName": "unknown", "tablesAccessed": [ "Fund" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations using JPA Repository methods.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.fundRepository.saveAndFlush(fund);" }, { "path": "org.apache.fineract.portfolio.group.domain", "mechanism": "SPRING-DATA", "name": "GroupRoleRepository", "description": "The class interacts with the database via the GroupRoleRepository, which is likely a Spring Data JPA repository interface. It performs standard CRUD operations on the GroupRole entity.", "databaseName": "unknown", "tablesAccessed": [ "GroupRole" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring Data default transaction handling", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public GroupRole findOneWithNotFoundDetection(final Long id) {\n return this.repository.findById(id).orElseThrow(() -> new GroupRoleNotFoundException(id));\n}" }, { "path": "org.apache.fineract.portfolio.group.domain", "mechanism": "SPRING-DATA", "name": "GroupRepository", "description": "The class wraps a Spring Data repository interface (GroupRepository) to perform database operations on Group entities. It delegates standard CRUD operations and custom queries to this repository.", "databaseName": "unknown", "tablesAccessed": [ "Group" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and one specific date retrieval query.", "transactionHandling": "Delegated to the underlying repository or the calling service context (Spring @Transactional is not present on this wrapper).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public Group findOneWithNotFoundDetection(final Long id) {\n return this.repository.findById(id).orElseThrow(() -> new GroupNotFoundException(id));\n}" }, { "path": "org.apache.fineract.portfolio.group.domain", "mechanism": "SPRING-DATA", "name": "GroupRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends `JpaRepository` for standard operations and uses `@Query` for custom JPQL execution.", "databaseName": "unknown", "tablesAccessed": [ "Group" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Includes standard CRUD operations inherited from JpaRepository, a derived finder method for parent-child relationships, and a custom JPQL projection query.", "transactionHandling": "Spring Data Repositories are transactional by default (read-only for finders, read-write for others).", "protocol": "JPA/JDBC", "connectionInfo": "configured in application properties", "codeExample": "@Query(RETRIEVE_SUBMITTED_ON_DATE)\nLocalDate retrieveGroupTypeSubmitteOndDate(@Param(\"groupId\") Long groupId);" }, { "path": "org.apache.fineract.portfolio.group.domain.GroupLevelRepository", "mechanism": "SPRING-DATA", "name": "GroupLevelRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to inherit standard CRUD operations and defines custom finders that are translated into SQL by the framework.", "databaseName": "unknown", "tablesAccessed": [ "GroupLevel" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived queries (simple CRUD and property-based lookups)", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "GroupLevel findBySuperParent(boolean superParent);" }, { "path": "org.apache.fineract.portfolio.group.domain.GroupRoleRepository", "mechanism": "SPRING-DATA", "name": "GroupRoleRepository", "description": "The interface extends JpaRepository, indicating it is a Spring Data repository used for database persistence of the GroupRole entity. It allows for standard CRUD operations and dynamic specification-based queries against the underlying database table mapped to the GroupRole entity.", "databaseName": "unknown", "tablesAccessed": [ "GroupRole" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria-based queries provided by JpaSpecificationExecutor.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for retrieval, read-write for modifications).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface GroupRoleRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.group.handler", "mechanism": "SPRING-DATA", "name": "GroupingTypesWritePlatformService", "description": "The class manages database transactions using Spring's @Transactional annotation while delegating the actual persistence logic to a service component.", "databaseName": "unknown", "tablesAccessed": [ "GROUP", "CLIENT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(final JsonCommand command) {\n return this.writePlatformService.associateClientsToGroup(command.entityId(), command);\n}" }, { "path": "org.apache.fineract.portfolio.group.serialization.GroupingTypesDataValidator", "mechanism": "SPRING-DATA", "name": "GroupRepositoryWrapper", "description": "The validator uses the GroupRepositoryWrapper to retrieve existing data from the database to perform logical validation against current state (specifically dates).", "databaseName": "unknown", "tablesAccessed": [ "m_group" ], "operationType": [ "READ" ], "queryPatterns": "Simple retrieval by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "LocalDate submittedOnDate = this.groupRepositoryWrapper.retrieveSubmittedOndate(centerId);" }, { "path": "org.apache.fineract.portfolio.group.service", "mechanism": "SPRING-DATA", "name": "GroupRoleRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrapper classes) to interact with the database. It performs CRUD operations on GroupRole, Group, Client, and CodeValue entities.", "databaseName": "unknown", "tablesAccessed": [ "GroupRole", "Group", "Client", "CodeValue" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JPA repositories (findOne, saveAndFlush, delete).", "transactionHandling": "Implicitly handled by Spring Data or Service layer (saveAndFlush implies immediate persistence).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "final GroupRole groupRole = GroupRole.createGroupRole(group, client, role);\nthis.groupRoleRepository.saveAndFlush(groupRole);" }, { "path": "org.apache.fineract.portfolio.group.service.GroupingTypesWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "GroupRepositoryWrapper", "description": "The class uses multiple Repository Wrappers (which wrap Spring Data JPA repositories) to perform CRUD operations on entities like Group, Client, Office, and Staff. It uses `saveAndFlush` for immediate persistence and `findOneWithNotFoundDetection` for retrieval with error handling.", "databaseName": "unknown", "tablesAccessed": [ "Group", "Client", "Office", "Staff", "Note", "GroupLevel", "Loan", "CodeValue", "CalendarInstance", "SavingsAccount", "AccountNumberFormat" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Standard JPA CRUD operations with some custom finders (e.g., findByOfficeHierarchyWithNotFoundDetection).", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.groupRepository.saveAndFlush(newGroup);" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain", "mechanism": "SPRING-DATA", "name": "InterestRateChartSlabRepository", "description": "The class wraps a Spring Data repository interface (InterestRateChartSlabRepository) to perform standard CRUD operations on the InterestRateChartSlab entity.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChartSlab" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, save, delete) provided by Spring Data JPA.", "transactionHandling": "Transactions are likely handled by the underlying Spring Data repository implementation or the service layer invoking this wrapper.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "return this.repository.findById(chartSlabId).orElseThrow(() -> new InterestRateChartSlabNotFoundException(chartSlabId));" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain", "mechanism": "SPRING-DATA", "name": "InterestRateChartRepository", "description": "The class wraps a Spring Data repository interface to perform CRUD operations on the InterestRateChart entity.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations delegated to Spring Data JPA repository.", "transactionHandling": "Spring Data repositories typically handle transactions by default, though no explicit @Transactional annotation is present on this wrapper.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.repository.findById(intrestRateChartId).orElseThrow(() -> new InterestRateChartNotFoundException(intrestRateChartId));" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartRepository", "mechanism": "SPRING-DATA", "name": "InterestRateChartRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically generates SQL queries based on the method signatures and inherited interfaces. The repository manages the persistence lifecycle of the InterestRateChart entity.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by the framework.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface InterestRateChartRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartSlabRepository", "mechanism": "SPRING-DATA", "name": "InterestRateChartSlabRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically implements the repository interface to interact with the database using Hibernate/JPA under the hood.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChartSlab" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by the framework.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public interface InterestRateChartSlabRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.interestratechart.service", "mechanism": "SPRING-DATA", "name": "InterestRateChartSlabRepository", "description": "The class uses a Spring Data JPA repository (InterestRateChartSlabRepository) to perform CRUD operations on the InterestRateChartSlab entity. Transactions are managed using the @Transactional annotation on methods.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChartSlab" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, delete) are used without explicit custom queries.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.chartSlabRepository.saveAndFlush(interestRateChartSlab);" }, { "path": "org.apache.fineract.portfolio.interestratechart.service", "mechanism": "SPRING-DATA", "name": "InterestRateChartRepositoryWrapper", "description": "The class uses a repository wrapper (likely wrapping a Spring Data JPA repository) to fetch existing InterestRateChart entities from the database by ID.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChart" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by primary key (ID).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final InterestRateChart interestRateChart = this.interestRateChartRepositoryWrapper\n .findOneWithNotFoundDetection(interestRateChartId);" }, { "path": "org.apache.fineract.portfolio.interestratechart.service", "mechanism": "SPRING-DATA", "name": "InterestRateChartRepositoryWrapper", "description": "The class interacts with the database through `InterestRateChartRepositoryWrapper`, which wraps a Spring Data JPA repository. It performs CRUD operations on `InterestRateChart` entities within transactional boundaries managed by Spring.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChart" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations (save, findOne, delete) via repository abstraction.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.interestRateChartRepository.saveAndFlush(interestRateChart);" }, { "path": "org.apache.fineract.portfolio.interestratechart.service.InterestRateChartSlabAssembler", "mechanism": "SPRING-DATA", "name": "InterestRateChartRepositoryWrapper", "description": "The class uses a repository wrapper to fetch parent 'InterestRateChart' entities from the database. This is necessary to associate new slabs with existing charts and to validate that the parent chart exists.", "databaseName": "unknown", "tablesAccessed": [ "InterestRateChart" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final InterestRateChart chart = this.interestRateChartRepositoryWrapper.findOneWithNotFoundDetection(chartId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.api.InternalLoanInformationApiResource", "mechanism": "SPRING-DATA", "name": "LoanRepositoryWrapper / LoanTransactionRepository", "description": "The class interacts with the database using Spring Data repositories (or wrappers around them). It retrieves Loan and LoanTransaction entities by ID and queries for loan IDs based on status.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanTransaction" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD read operations (findById) and one custom query to find IDs by status.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Loan loan = loanRepositoryWrapper.findOneWithNotFoundDetection(loanId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "GLIMAccountInfoRepository", "description": "The interface extends JpaRepository, enabling automatic ORM mapping and SQL generation for the GroupLoanIndividualMonitoringAccount entity.", "databaseName": "unknown", "tablesAccessed": [ "GroupLoanIndividualMonitoringAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived query methods (findBy...) and standard CRUD operations inherited from JpaRepository.", "transactionHandling": "Spring Data JPA repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface GLIMAccountInfoRepository\n extends JpaRepository..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanTransactionRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database using JPA entities and JPQL queries. It extends JpaRepository to inherit standard CRUD operations and defines custom queries using the @Query annotation.", "databaseName": "unknown", "tablesAccessed": [ "LoanTransaction", "LoanCharge", "Loan" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "JPQL queries with constructor expressions (projections), aggregations (SUM, MIN), grouping (GROUP BY), and standard CRUD operations.", "transactionHandling": "Spring Data JPA repositories typically participate in existing transactions or create read-only transactions for query methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT lt.id FROM LoanTransaction lt WHERE lt.externalId = :externalId\")\nLong findIdByExternalId(@Param(\"externalId\") ExternalId externalId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanChargePaidByRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard CRUD operations and defines a custom JPQL query to filter records.", "databaseName": "unknown", "tablesAccessed": [ "LoanChargePaidBy", "LoanCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations", "transactionHandling": "Spring @Transactional (implicit in Spring Data)", "protocol": "JPA", "connectionInfo": "configured in application context", "codeExample": "@Query(\"select lp from LoanChargePaidBy lp where lp.loanCharge=:loanCharge and lp.installmentNumber=:installmentNumber\")" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanChargeRepository", "description": "The interface extends JpaRepository to provide data access for the LoanCharge entity. It uses Spring Data JPA to automatically generate SQL for standard operations and executes a custom JPQL query for ID lookup.", "databaseName": "unknown", "tablesAccessed": [ "LoanCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JpaRepository inheritance and one custom JPQL query for ID retrieval.", "transactionHandling": "Spring @Transactional (default for Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(FIND_ID_BY_EXTERNAL_ID)\nLong findIdByExternalId(@Param(\"externalId\") ExternalId externalId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanCollateralManagementRepository", "description": "The code uses Spring Data JPA repositories to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "LoanCollateralManagement" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM queries using JPQL", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select loanCollaterals from LoanCollateralManagement loanCollaterals where loanCollaterals.loan=:loan\")\nList findByLoan(@Param(\"loan\") Loan loan);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanRepaymentScheduleInstallmentRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines custom JPQL queries for specific reporting needs.", "databaseName": "unknown", "tablesAccessed": [ "LoanRepaymentScheduleInstallment", "Loan", "LoanProduct" ], "operationType": [ "READ" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "Spring @Transactional (implied by Spring Data)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"\"\"\n SELECT new org.apache.fineract.portfolio.loanaccount.data.LoanScheduleDelinquencyData(\n lrs.loan.id,\n min(lrs.dueDate),\n 0L,\n lrs.loan\n ) FROM LoanRepaymentScheduleInstallment lrs...\"\"\")" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The class wraps a Spring Data JPA repository (LoanRepository) to perform CRUD operations and custom queries on the Loan entity. It handles transaction management and lazy loading of related entities.", "databaseName": "unknown", "tablesAccessed": [ "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD, complex joins via lazy loading initialization, batch operations, and custom repository queries.", "transactionHandling": "Spring @Transactional annotations are used on the class and specific methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Loan loan = this.repository.findById(id).orElseThrow(() -> new LoanNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanDisbursementDetailsRepository", "mechanism": "SPRING-DATA", "name": "LoanDisbursementDetailsRepository", "description": "The file is a Spring Data JPA repository interface. It automatically provides database interaction capabilities for the LoanDisbursementDetails entity without explicit implementation code.", "databaseName": "unknown", "tablesAccessed": [ "LoanDisbursementDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface LoanDisbursementDetailsRepository\n extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanRepository", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database primarily through JPQL queries defined in @Query annotations and standard Spring Data method naming conventions. It manages the 'Loan' entity and related data.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "LoanAccountLock" ], "operationType": [ "READ" ], "queryPatterns": "The repository uses extensive JPQL queries. These include simple selects, filtering by multiple criteria (dates, IDs, statuses), aggregations (MAX, COUNT), subqueries (for finding oldest dates), and joins (implicit in path navigation like l.group.id and explicit in the lock query). It also uses constructor expressions (new ...) to return DTOs.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select loan from Loan loan where loan.client.id = :clientId\")\nList findLoanByClientId(@Param(\"clientId\") Long clientId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRelationRepository", "mechanism": "SPRING-DATA", "name": "LoanTransactionRelationRepository", "description": "The interface extends JpaRepository, enabling Spring Data to generate the implementation for database access at runtime. It maps the LoanTransactionRelation entity to a database table.", "databaseName": "unknown", "tablesAccessed": [ "LoanTransactionRelation" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD and derived query methods based on property names.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public interface LoanTransactionRelationRepository extends JpaRepository ..." }, { "path": "org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionToRepaymentScheduleMappingRepository", "mechanism": "SPRING-DATA", "name": "LoanTransactionToRepaymentScheduleMappingRepository", "description": "The interface uses Spring Data JPA to interact with the database. It maps the 'LoanTransactionToRepaymentScheduleMapping' Java entity to a corresponding database table and provides object-relational mapping capabilities.", "databaseName": "unknown", "tablesAccessed": [ "LoanTransactionToRepaymentScheduleMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived queries and standard CRUD operations.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "LoanTransactionToRepaymentScheduleMapping findByLoanTransaction(LoanTransaction loanTransaction);" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain", "mechanism": "SPRING-DATA", "name": "GuarantorFundingTransactionRepository", "description": "The code uses Spring Data JPA to interact with the database. It extends JpaRepository to inherit standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "GuarantorFundingTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations and standard CRUD operations.", "transactionHandling": "Spring @Transactional annotations (implicit in JpaRepository implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select ft from GuarantorFundingTransaction ft where ft.loanTransaction.id in :loanTransactions\")" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain", "mechanism": "SPRING-DATA", "name": "GuarantorRepository", "description": "The interface extends JpaRepository to provide automated database interactions via Hibernate/JPA.", "databaseName": "unknown", "tablesAccessed": [ "Guarantor" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD and derived query methods based on entity relationships.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JPA", "connectionInfo": "configured in application properties", "codeExample": "public interface GuarantorRepository extends JpaRepository, JpaSpecificationExecutor { ... }" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.domain.GuarantorFundingRepository", "mechanism": "SPRING-DATA", "name": "GuarantorFundingRepository", "description": "The interface utilizes Spring Data JPA to automatically generate the implementation for database access based on the GuarantorFundingDetails entity. It provides standard CRUD operations and specification execution capabilities without requiring explicit SQL or JPQL in this file.", "databaseName": "unknown", "tablesAccessed": [ "GuarantorFundingDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria queries provided by JpaSpecificationExecutor.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for find methods, read-write for save/delete).", "protocol": "JDBC (abstracted by JPA)", "connectionInfo": "unknown", "codeExample": "public interface GuarantorFundingRepository\n extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.loanaccount.guarantor.service.GuarantorDomainServiceImpl", "mechanism": "SPRING-DATA", "name": "Guarantor/Loan Repositories", "description": "The service uses Spring Data JPA repositories to interact with the database. It retrieves and saves entities related to guarantors, loans, and savings account transactions.", "databaseName": "unknown", "tablesAccessed": [ "m_guarantor", "m_guarantor_funding_details", "m_guarantor_transaction", "m_deposit_account_on_hold_transaction", "m_loan", "m_savings_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository finders (e.g., findByLoan) and save/flush operations.", "transactionHandling": "Likely relies on Spring's @Transactional at the service level (though not explicitly annotated on this class, it is common in this architecture) or repository-level transactions.", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "final List existGuarantorList = this.guarantorRepository.findByLoan(loan);\n// ...\nthis.depositAccountOnHoldTransactionRepository.saveAndFlush(onHoldTransaction);" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.applyholidaystoloans", "mechanism": "SPRING-DATA", "name": "HolidayRepositoryWrapper, LoanRepositoryWrapper", "description": "The class uses repository wrappers (likely abstractions over Spring Data JPA repositories) to fetch and persist domain entities. It retrieves `Holiday` entities to find unprocessed ones and `Loan` entities based on office IDs and status. It performs write operations to update the loan repayment schedules and the holiday processing status.", "databaseName": "unknown", "tablesAccessed": [ "m_holiday", "m_loan", "m_loan_repayment_schedule" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository finder methods (findUnprocessed, findByClientOfficeIdsAndLoanStatus) and save methods.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final List holidays = holidayRepository.findUnprocessed();\n// ...\nloans.addAll(loanRepositoryWrapper.findByClientOfficeIdsAndLoanStatus(officeIds, loanStatuses));\n// ...\nloanRepositoryWrapper.save(loans);" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.setloandelinquencytags", "mechanism": "SPRING-DATA", "name": "Loan Repositories", "description": "The class injects Spring Data repositories (LoanRepaymentScheduleInstallmentRepository and LoanTransactionRepository) and passes them to the tasklet. While this configuration class does not execute queries directly, it wires the components that perform database operations.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_repayment_schedule", "m_loan_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Repository methods used within the tasklet for batch processing.", "transactionHandling": "Spring Batch Step transaction management via PlatformTransactionManager", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "private LoanRepaymentScheduleInstallmentRepository loanRepaymentScheduleInstallmentRepository;\nprivate LoanTransactionRepository loanTransactionRepository;\n\n@Bean\npublic SetLoanDelinquencyTagsTasklet setLoanDelinquencyTagsTasklet() {\n return new SetLoanDelinquencyTagsTasklet(delinquencyWritePlatformService, loanRepaymentScheduleInstallmentRepository,\n loanTransactionRepository);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.jobs.setloandelinquencytags", "mechanism": "SPRING-DATA", "name": "LoanRepaymentScheduleInstallmentRepository, LoanTransactionRepository", "description": "The class uses Spring Data repositories to query the database for loans with specific transaction types and overdue schedules. It also delegates to a service that likely performs database updates (writes) to apply tags.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_transaction", "m_loan_repayment_schedule", "m_loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code uses custom repository methods to fetch data based on complex criteria (transaction type, date, loan status, obligations met).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "loanScheduleDelinquencyData = this.loanTransactionRepository\n .fetchLoanTransactionsByTypeAndLessOrEqualDate(LoanTransactionType.CHARGEBACK.getValue(), businessDate);" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.domain.LoanRepaymentScheduleHistoryRepository", "mechanism": "SPRING-DATA", "name": "LoanRepaymentScheduleHistoryRepository", "description": "The interface uses Spring Data JPA to manage database interactions for LoanRepaymentScheduleHistory entities. It abstracts the underlying SQL or JPQL generation.", "databaseName": "unknown", "tablesAccessed": [ "LoanRepaymentScheduleHistory" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JPA/JDBC", "connectionInfo": "configured in application properties", "codeExample": "public interface LoanRepaymentScheduleHistoryRepository\n extends JpaRepository, JpaSpecificationExecutor {\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.service.LoanScheduleAssembler", "mechanism": "SPRING-DATA", "name": "LoanProductRepository, CalendarRepository, etc.", "description": "The class uses multiple Spring Data repositories to fetch domain entities required for assembling the loan schedule. It retrieves LoanProduct, Calendar, Holiday, Client, Group, and WorkingDays entities by their IDs or other attributes.", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan", "m_currency", "m_calendar", "m_holiday", "m_client", "m_group", "m_working_days", "m_calendar_instance" ], "operationType": [ "READ" ], "queryPatterns": "Standard JPA findById and findOne lookups.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final LoanProduct loanProduct = this.loanProductRepository.findById(loanProductId)\n .orElseThrow(() -> new LoanProductNotFoundException(loanProductId));" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.service.LoanScheduleCalculationPlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanProductRepository", "description": "The class uses Spring Data repositories to access loan product information and JPA entities (via LoanAssembler) to access Loan data. It performs read operations to fetch configuration and state required for schedule calculation.", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Standard JPA repository findById calls and entity traversal.", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final LoanProduct loanProduct = this.loanProductRepository.findById(productId)\n .orElseThrow(() -> new LoanProductNotFoundException(productId));" }, { "path": "org.apache.fineract.portfolio.loanaccount.loanschedule.service.LoanScheduleHistoryWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanRepaymentScheduleHistoryRepository", "description": "The class uses a Spring Data repository (`LoanRepaymentScheduleHistoryRepository`) to perform batch insert operations (`saveAll`) for the history records. It also uses a read service (`LoanScheduleHistoryReadPlatformService`) which likely executes SQL/JDBC queries to fetch version numbers and old audit dates.", "databaseName": "unknown", "tablesAccessed": [ "LoanRepaymentScheduleHistory", "LoanRepaymentScheduleInstallment" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Batch inserts via repository and specific lookups for versioning and audit data.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.loanRepaymentScheduleHistoryRepository.saveAll(loanRepaymentScheduleHistoryList);" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.domain", "mechanism": "SPRING-DATA", "name": "LoanRescheduleRequestRepository", "description": "The file is a Spring Data JPA repository interface. It automatically generates SQL queries based on method names and annotations to interact with the underlying relational database for the `LoanRescheduleRequest` entity.", "databaseName": "unknown", "tablesAccessed": [ "LoanRescheduleRequest" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository, plus a custom JPQL projection query.", "transactionHandling": "Spring Data JPA repositories typically participate in existing Spring @Transactional contexts.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select lrr.loan.id from LoanRescheduleRequest lrr where lrr.id = :rescheduleRequestId\")" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.domain", "mechanism": "SPRING-DATA", "name": "LoanRescheduleRequestRepository", "description": "The class uses a Spring Data repository interface to interact with the database. It performs read operations to fetch LoanRescheduleRequest entities by their primary key.", "databaseName": "unknown", "tablesAccessed": [ "LoanRescheduleRequest" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (findById)", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.loanRescheduleRequestRepository.findById(id)\n .orElseThrow(() -> new LoanRescheduleRequestNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.domain.LoanTermVariationsRepository", "mechanism": "SPRING-DATA", "name": "LoanTermVariationsRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "LoanTermVariations" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations and standard CRUD operations provided by JpaRepository.", "transactionHandling": "Transactions are likely handled by the Spring container via @Transactional annotations at the service layer, or default read-only transactions for repository methods.", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select lrr from LoanTermVariations lrr where lrr.loan.id = :loanId\")" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.handler", "mechanism": "SPRING-DATA", "name": "LoanRescheduleRequestWritePlatformService", "description": "The class manages database transactions via the Spring @Transactional annotation while delegating the actual data persistence logic to the LoanRescheduleRequestWritePlatformService.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegated to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n@Override\npublic CommandProcessingResult processCommand(JsonCommand jsonCommand) {\n return this.loanRescheduleRequestWritePlatformService.reject(jsonCommand);\n}" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.service", "mechanism": "SPRING-DATA", "name": "LoanRescheduleRequestRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on LoanRescheduleRequest, Loan, and LoanRepaymentScheduleHistory entities. It uses @Transactional to ensure atomicity of complex operations involving multiple tables.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_reschedule_request", "m_loan", "m_loan_repayment_schedule", "m_loan_repayment_schedule_history", "m_loan_transaction", "m_loan_term_variations", "m_loan_reschedule_request_term_variation_mapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findById, saveAndFlush) and navigation through entity relationships.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.loanRescheduleRequestRepository.saveAndFlush(loanRescheduleRequest);" }, { "path": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.service.LoanReschedulePreviewPlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanRescheduleRequestRepositoryWrapper", "description": "The class uses a repository wrapper to fetch LoanRescheduleRequest entities from the database. It relies on the underlying JPA/Spring Data infrastructure to retrieve the request and its associated Loan entity and mappings.", "databaseName": "unknown", "tablesAccessed": [ "m_loan_reschedule_request", "m_loan" ], "operationType": [ "READ" ], "queryPatterns": "Entity lookup by ID with eager loading of associations (implied by findOneWithNotFoundDetection)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final LoanRescheduleRequest loanRescheduleRequest = this.loanRescheduleRequestRepository.findOneWithNotFoundDetection(requestId, true);" }, { "path": "org.apache.fineract.portfolio.loanaccount.serialization.LoanApplicationCommandFromApiJsonHelper", "mechanism": "SPRING-DATA", "name": "ClientCollateralManagementRepositoryWrapper", "description": "The class uses a repository wrapper to fetch client collateral details from the database during validation. This is used to verify that the collateral exists and to retrieve its quantity and value for business rule checks.", "databaseName": "unknown", "tablesAccessed": [ "ClientCollateralManagement" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final ClientCollateralManagement clientCollateralManagement = this.clientCollateralManagementRepositoryWrapper.getCollateral(clientCollateralId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.serialization.LoanEventApiJsonValidator", "mechanism": "SPRING-DATA", "name": "LoanRepository", "description": "The class uses `LoanRepository` to fetch `Loan` entities by ID. This is primarily used in `validateDisbursementWithPostDatedChecks` to retrieve the loan's repayment schedule and validate that the provided post-dated checks correspond to valid installments.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_repayment_schedule" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Loan loan = this.loanRepository.findById(loanId).orElseThrow(() -> new LoanNotFoundException(loanId));" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "SPRING-DATA", "name": "LoanTransactionRepository", "description": "The service uses a Spring Data repository to retrieve existing loan transaction entities by their primary key ID.", "databaseName": "unknown", "tablesAccessed": [ "LoanTransaction" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (findById)", "transactionHandling": "unknown", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "LoanTransaction oldTransaction = loanTransactionRepository.findById(mapEntry.getKey())\n .orElseThrow(() -> new LoanTransactionNotFoundException(mapEntry.getKey()));" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper, LoanChargeRepository, LoanProductRepository", "description": "The class uses Spring Data repositories to fetch entity definitions required for assembly. It retrieves `Charge` definitions to understand calculation rules and `LoanProduct` definitions to check configuration flags like multi-disbursement support. It also retrieves existing `LoanCharge` entities by ID for updates.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_loan_charge", "m_product_loan" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "Standard JPA findById lookups.", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final LoanProduct loanProduct = this.loanProductRepository.findById(productId)\n .orElseThrow(() -> new LoanProductNotFoundException(productId));\nfinal Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(chargeId);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service", "mechanism": "SPRING-DATA", "name": "GLIMAccountInfoRepository", "description": "The class uses Spring Data repositories (`GLIMAccountInfoRepository` and `LoanRepository`) to interact with the database. It performs write operations (save/update) on `GroupLoanIndividualMonitoringAccount` entities.", "databaseName": "unknown", "tablesAccessed": [ "GroupLoanIndividualMonitoringAccount" ], "operationType": [ "WRITE" ], "queryPatterns": "Simple CRUD operations (save/update) via repository methods.", "transactionHandling": "Implicitly handled by Spring Data repository methods or upper layers (no explicit @Transactional in this file).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.glimAccountRepository.save(glimAccountInfo);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanAssembler", "mechanism": "SPRING-DATA", "name": "LoanRepositoryWrapper, LoanProductRepository, ClientRepositoryWrapper, etc.", "description": "The class uses multiple repository wrappers and standard Spring Data repositories to fetch domain entities required to assemble a Loan. It primarily performs read operations to look up Clients, Groups, Products, Funds, and Staff.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_product_loan", "m_client", "m_group", "m_fund", "m_staff", "m_code_value", "m_holiday", "m_working_days" ], "operationType": [ "READ" ], "queryPatterns": "Standard JPA findById or findOne lookups.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Loan loanAccount = this.loanRepository.findOneWithNotFoundDetection(accountId, true);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanChargeWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "LoanRepositoryWrapper, ChargeRepositoryWrapper, LoanChargeRepository", "description": "The class uses Spring Data JPA repositories (wrapped in service wrappers) to interact with the database. It performs CRUD operations on Loan, LoanCharge, and LoanTransaction entities. It uses @Transactional to ensure data consistency across multiple repository calls.", "databaseName": "unknown", "tablesAccessed": [ "m_loan", "m_loan_charge", "m_loan_transaction", "m_charge", "m_note", "m_payment_detail", "m_account_transfer_details" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, save, saveAndFlush) and domain entity traversals (lazy loading of collections).", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.loanRepositoryWrapper.save(loan);" }, { "path": "org.apache.fineract.portfolio.loanaccount.service.LoanUtilService", "mechanism": "SPRING-DATA", "name": "RepositoryWrappers", "description": "The class interacts with the database through several injected repository wrappers (e.g., `ApplicationCurrencyRepositoryWrapper`, `CalendarInstanceRepository`, `HolidayRepository`). These are used to retrieve entity information such as currency details, calendar instances associated with loans, and holiday configurations required for schedule generation.", "databaseName": "unknown", "tablesAccessed": [ "m_currency", "m_calendar_instance", "m_calendar", "m_holiday", "m_working_days" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID or associated entity ID.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "ApplicationCurrency applicationCurrency = this.applicationCurrencyRepository.findOneWithNotFoundDetection(currency);" }, { "path": "org.apache.fineract.portfolio.loanproduct.domain", "mechanism": "SPRING-DATA", "name": "LoanProductRepository", "description": "The file is a Spring Data JPA repository interface. It provides database interaction capabilities for the LoanProduct entity without requiring boilerplate JDBC code. It supports automatic transaction management and query generation.", "databaseName": "unknown", "tablesAccessed": [ "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "Spring @Transactional", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select loanProduct from LoanProduct loanProduct, IN(loanProduct.charges) charge where charge.id = :chargeId\")" }, { "path": "org.apache.fineract.portfolio.loanproduct.productmix.domain", "mechanism": "SPRING-DATA", "name": "ProductMixRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and by defining custom JPQL queries via the @Query annotation to access the 'ProductMix' entity.", "databaseName": "unknown", "tablesAccessed": [ "ProductMix" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(GET_PRODUCTMIXES_BY_PRODUCTID_SCHEMA)\nList findByProductId(@Param(\"productId\") Long productId);" }, { "path": "org.apache.fineract.portfolio.loanproduct.productmix.service.ProductMixWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "ProductMixRepository", "description": "The class uses Spring Data JPA repositories (`ProductMixRepository` and `LoanProductRepository`) to interact with the database. It performs CRUD operations on `ProductMix` and `LoanProduct` entities.", "databaseName": "unknown", "tablesAccessed": [ "ProductMix", "LoanProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard Spring Data JPA repository methods (saveAll, deleteAll, findById, findByProductId).", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.productMixRepository.saveAll(productMixes);" }, { "path": "org.apache.fineract.portfolio.loanproduct.service", "mechanism": "SPRING-DATA", "name": "LoanProductRepository", "description": "The class uses Spring Data JPA repositories (LoanProductRepository, FundRepository, etc.) to interact with the database. It performs CRUD operations on LoanProduct entities and related tables.", "databaseName": "unknown", "tablesAccessed": [ "m_product_loan", "m_fund", "m_charge", "m_rate", "m_floating_rates", "m_delinquency_bucket" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, saveAndFlush, getReferenceById) and some custom wrapper calls.", "transactionHandling": "Spring @Transactional annotations on public methods", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.loanProductRepository.saveAndFlush(loanProduct);" }, { "path": "org.apache.fineract.portfolio.meeting.attendance.domain.ClientAttendanceRepository", "mechanism": "SPRING-DATA", "name": "ClientAttendanceRepository", "description": "The interface uses Spring Data JPA to automatically generate the implementation for database access at runtime. It maps the ClientAttendance entity to a database table.", "databaseName": "unknown", "tablesAccessed": [ "ClientAttendance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data repository implementation)", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface ClientAttendanceRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.meeting.domain.MeetingRepository", "mechanism": "SPRING-DATA", "name": "MeetingRepository", "description": "The file uses Spring Data JPA to manage database interactions. It extends JpaRepository to provide standard CRUD functionality and defines a custom finder method that is automatically translated into a database query by the framework.", "databaseName": "unknown", "tablesAccessed": [ "Meeting" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Meeting findByCalendarInstanceIdAndMeetingDate(Long calendarInstanceId, LocalDate meetingDate);" }, { "path": "org.apache.fineract.portfolio.meeting.domain.MeetingRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "MeetingRepository", "description": "The class wraps a Spring Data repository (MeetingRepository) to perform CRUD operations on the Meeting entity.", "databaseName": "unknown", "tablesAccessed": [ "Meeting" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Spring Data JPA methods (findById, save, delete).", "transactionHandling": "Likely handled by the underlying Spring Data repository implementation (SimpleJpaRepository is @Transactional by default).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public Meeting findOneWithNotFoundDetection(final Long meetingId) {\n return this.repository.findById(meetingId).orElseThrow(() -> new MeetingNotFoundException(meetingId));\n}" }, { "path": "org.apache.fineract.portfolio.meeting.service.MeetingWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "MeetingRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in Fineract's RepositoryWrapper pattern) to perform CRUD operations on Meeting entities and read-only operations on related entities like Calendar, Client, and Group.", "databaseName": "unknown", "tablesAccessed": [ "m_meeting", "m_calendar_instance", "m_calendar", "m_client", "m_group", "m_meeting_attendance" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, delete, findById) and some custom finders (findByCalendarIdAndEntityIdAndEntityTypeId).", "transactionHandling": "Implicitly handled by the Spring Data repositories or the service layer context (though @Transactional is not explicitly present on this class, it is likely present on the interface or inherited).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.meetingRepositoryWrapper.saveAndFlush(newMeeting);" }, { "path": "org.apache.fineract.portfolio.meeting.starter", "mechanism": "SPRING-DATA", "name": "Meeting Services Configuration", "description": "This configuration class wires up services that interact with the database using both JDBC (for reads) and Spring Data JPA Repositories (for writes). It injects the JdbcTemplate and various Repository interfaces into the service implementations.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The configured services likely perform raw SQL queries via JdbcTemplate for reads and ORM-based CRUD operations via JPA repositories for writes.", "transactionHandling": "Transaction handling is likely managed within the service implementations (e.g., @Transactional), not in this configuration class.", "protocol": "JDBC / JPA", "connectionInfo": "configured in application properties", "codeExample": "public MeetingReadPlatformService meetingReadPlatformService(JdbcTemplate jdbcTemplate) {\n return new MeetingReadPlatformServiceImpl(jdbcTemplate);\n}" }, { "path": "org.apache.fineract.portfolio.note.domain.NoteRepository", "mechanism": "SPRING-DATA", "name": "NoteRepository", "description": "The interface extends JpaRepository and JpaSpecificationExecutor, leveraging Spring Data JPA to manage database interactions. It automatically generates SQL queries based on method names (e.g., findByClient) and provides built-in methods for standard CRUD operations.", "databaseName": "unknown", "tablesAccessed": [ "Note" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived queries based on method names (e.g., findByLoanId, findByClient).", "transactionHandling": "Spring Data JPA repositories typically use @Transactional implicitly on their methods (read-only for finders, read-write for save/delete).", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface NoteRepository extends JpaRepository ... {\n List findByClient(Client id);\n}" }, { "path": "org.apache.fineract.portfolio.note.service.NoteWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "NoteRepository", "description": "The class uses multiple Spring Data JPA repositories (NoteRepository, ClientRepositoryWrapper, GroupRepository, etc.) to interact with the database. It performs CRUD operations on Note entities and read operations on parent entities (Client, Group, Loan, etc.) to establish relationships.", "databaseName": "unknown", "tablesAccessed": [ "Note", "Client", "Group", "Loan", "LoanTransaction", "SavingsAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations using JPA repository methods like save, saveAndFlush, delete, findById, and findOneWithNotFoundDetection.", "transactionHandling": "Likely managed by Spring @Transactional at the class or interface level (though not explicitly visible in this file snippet, it is standard for such services).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final Note newNote = Note.clientNoteFromJson(client, command);\nthis.noteRepository.saveAndFlush(newNote);" }, { "path": "org.apache.fineract.portfolio.note.starter.NoteAutoConfiguration", "mechanism": "SPRING-DATA", "name": "NoteAutoConfiguration", "description": "This configuration class wires up database access components. It injects a JdbcTemplate for the read service (indicating direct JDBC usage) and multiple Spring Data repositories (NoteRepository, GroupRepository, etc.) for the write service.", "databaseName": "unknown", "tablesAccessed": [ "m_note", "m_client", "m_group", "m_loan", "m_loan_transaction", "m_savings_account" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The read service likely uses raw SQL via JdbcTemplate, while the write service uses JPA/Hibernate via Spring Data Repositories.", "transactionHandling": "Transactions are likely handled within the service implementations (NoteWritePlatformServiceJpaRepositoryImpl) rather than this configuration class.", "protocol": "unknown", "connectionInfo": "configured via Spring Boot DataSource", "codeExample": "@Bean\npublic NoteReadPlatformService noteReadPlatformService(JdbcTemplate jdbcTemplate) {\n return new NoteReadPlatformServiceImpl(jdbcTemplate);\n}" }, { "path": "org.apache.fineract.portfolio.paymentdetail.domain", "mechanism": "SPRING-DATA", "name": "PaymentDetailRepository", "description": "Database integration is handled via Spring Data JPA. The interface inherits methods for saving, deleting, and finding PaymentDetail entities. It also inherits the ability to execute JPA Specifications, specifically typed for Loan entities.", "databaseName": "unknown", "tablesAccessed": [ "PaymentDetail", "Loan" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository and dynamic criteria queries via JpaSpecificationExecutor.", "transactionHandling": "Spring Data repositories typically use @Transactional(readOnly = true) for read methods and @Transactional for write methods by default.", "protocol": "JPA", "connectionInfo": "configured in application properties", "codeExample": "public interface PaymentDetailRepository extends JpaRepository, JpaSpecificationExecutor {\n // no added behaviour\n}" }, { "path": "org.apache.fineract.portfolio.paymentdetail.domain", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepositoryWrapper", "description": "The class uses a repository wrapper (likely wrapping a Spring Data JPA repository) to fetch PaymentType entities from the database by their ID.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final PaymentType paymentType = this.repositoryWrapper.findOneWithNotFoundDetection(paymentTypeId);" }, { "path": "org.apache.fineract.portfolio.paymentdetail.service", "mechanism": "SPRING-DATA", "name": "PaymentDetailRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It injects PaymentDetailRepository to save payment details and PaymentTypeRepositoryWrapper to read payment types.", "databaseName": "unknown", "tablesAccessed": [ "PaymentDetail", "PaymentType" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, findOne)", "transactionHandling": "Spring @Transactional annotations on persist methods", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.paymentDetailRepository.save(paymentDetail);" }, { "path": "org.apache.fineract.portfolio.paymenttype.api", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepositoryWrapper", "description": "The class interacts with the database indirectly through the 'PaymentTypeRepositoryWrapper' for entity existence checks and 'PaymentTypeReadPlatformService' for data retrieval. The wrapper likely encapsulates a Spring Data JPA repository.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Simple CRUD operations delegated to services.", "transactionHandling": "Delegated to underlying services (likely Spring @Transactional in the service layer)", "protocol": "unknown", "codeExample": "this.paymentTypeRepositoryWrapper.findOneWithNotFoundDetection(paymentTypeId);" }, { "path": "org.apache.fineract.portfolio.paymenttype.domain", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepository", "description": "The class uses a Spring Data JPA repository interface to interact with the database. It relies on method name query derivation (e.g., findAllByOrderByPositionAsc) to generate SQL queries.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations with ordering and null checks.", "transactionHandling": "Spring @Transactional (likely inherited from repository or service layer)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findAllByOrderByPositionAsc()" }, { "path": "org.apache.fineract.portfolio.paymenttype.domain.PaymentTypeRepository", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepository", "description": "The file uses Spring Data JPA to abstract database interactions. By extending JpaRepository, it gains full CRUD capabilities on the PaymentType entity. It defines specific read operations using method naming conventions that Spring translates into SQL queries.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived queries for filtering and sorting", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface PaymentTypeRepository extends JpaRepository, JpaSpecificationExecutor {\n List findAllByOrderByPositionAsc();\n}" }, { "path": "org.apache.fineract.portfolio.paymenttype.service", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepositoryWrapper", "description": "The class interacts with the database through a wrapper around a Spring Data repository (implied by the naming convention and usage). It performs read-only operations to fetch PaymentType entities.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations (findAll, findOne)", "transactionHandling": "None (Read-only operations, likely handled at repository level)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "List paymentType = this.paymentTypeRepository.findAll();" }, { "path": "org.apache.fineract.portfolio.paymenttype.service.PaymentTypeWriteServiceImpl", "mechanism": "SPRING-DATA", "name": "PaymentTypeRepository", "description": "The class uses a Spring Data JPA repository (`PaymentTypeRepository`) to interact with the database. It performs CRUD operations on the `PaymentType` entity.", "databaseName": "unknown", "tablesAccessed": [ "PaymentType" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via JPA repository methods (save, delete, find).", "transactionHandling": "Implicitly handled by Spring Data repository methods or the service context (though @Transactional is not explicitly on this class, saveAndFlush implies immediate persistence).", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.repository.saveAndFlush(newPaymentType);" }, { "path": "org.apache.fineract.portfolio.rate.domain", "mechanism": "SPRING-DATA", "name": "RateRepository", "description": "The class interacts with the database through the RateRepository interface, which is a Spring Data repository. It performs read operations to fetch Rate entities by primary key.", "databaseName": "unknown", "tablesAccessed": [ "Rate" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD operations (findById, findAllById) provided by Spring Data.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Rate rate = this.repository.findById(rateId).orElseThrow(() -> new RateNotFoundException(rateId));" }, { "path": "org.apache.fineract.portfolio.rate.domain", "mechanism": "SPRING-DATA", "name": "RateRepository", "description": "The interface extends JpaRepository, indicating it uses Spring Data JPA for database persistence. The Javadoc explicitly mentions saving to the 'm_rate' table.", "databaseName": "unknown", "tablesAccessed": [ "m_rate" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived queries (findBy...) and standard CRUD operations inherited from JpaRepository.", "transactionHandling": "Spring @Transactional (default for JpaRepository methods)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "public interface RateRepository extends JpaRepository, JpaSpecificationExecutor { ... }" }, { "path": "org.apache.fineract.portfolio.rate.service", "mechanism": "SPRING-DATA", "name": "RateRepository", "description": "The class uses Spring Data JPA repositories (RateRepository and AppUserRepository) to interact with the database. It performs CRUD operations and relies on JPA for object-relational mapping.", "databaseName": "unknown", "tablesAccessed": [ "Rate", "AppUser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations using repository methods like saveAndFlush and findById.", "transactionHandling": "Spring @Transactional annotation is used on the updateRate method; createRate relies on repository transaction management.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.rateRepository.saveAndFlush(rate);" }, { "path": "org.apache.fineract.portfolio.rate.service.RateAssembler", "mechanism": "SPRING-DATA", "name": "RateRepositoryWrapper", "description": "The class interacts with the database through the RateRepositoryWrapper. It does not execute SQL directly but relies on the repository pattern to fetch entities based on a list of primary keys (IDs).", "databaseName": "unknown", "tablesAccessed": [ "Rate" ], "operationType": [ "READ" ], "queryPatterns": "Batch retrieval by ID list", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "rateItems.addAll(rateRepository.findMultipleWithNotFoundDetection(idList));" }, { "path": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.domain", "mechanism": "SPRING-DATA", "name": "PostDatedChecksRepository", "description": "The file is a Spring Data JPA repository interface that manages database interactions for the PostDatedChecks entity.", "databaseName": "unknown", "tablesAccessed": [ "PostDatedChecks", "LoanRepaymentScheduleInstallment" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with dynamic criteria defined via annotations.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select pdc from PostDatedChecks pdc where pdc.status = 0 and pdc.loanRepaymentScheduleInstallment = :loanRepaymentScheduleInstallment\")" }, { "path": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.service", "mechanism": "SPRING-DATA", "name": "PostDatedChecksRepository, LoanRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on PostDatedChecks and read operations on Loan entities. Transaction management is handled via the @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "PostDatedChecks", "Loan", "LoanRepaymentScheduleInstallment" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, saveAndFlush, deleteById) and entity navigation.", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.postDatedChecksRepository.saveAndFlush(postDatedChecks);" }, { "path": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.service", "mechanism": "SPRING-DATA", "name": "LoanRepository, PostDatedChecksRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It retrieves `Loan` and `PostDatedChecks` entities using standard `findById` methods and object graph navigation (e.g., `loan.getPostDatedChecks()`). The class is transactional with read-only propagation.", "databaseName": "unknown", "tablesAccessed": [ "Loan", "PostDatedChecks", "LoanRepaymentScheduleInstallment" ], "operationType": [ "READ" ], "queryPatterns": "Standard CRUD find by ID and object traversal", "transactionHandling": "Spring @Transactional(readOnly = true)", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Loan loan = this.loanRepository.findById(id).orElseThrow(() -> new LoanNotFoundException(id));" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "GSIMRepositoy", "description": "The interface extends JpaRepository, which provides full database integration via Hibernate/JPA. It maps the GroupSavingsIndividualMonitoring entity to a database table.", "databaseName": "unknown", "tablesAccessed": [ "GroupSavingsIndividualMonitoring" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard Spring Data JPA derived queries (Simple CRUD)", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "JPA", "connectionInfo": "configured in application.properties", "codeExample": "GroupSavingsIndividualMonitoring findOneByAccountNumber(String accountNumber);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountChargeRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines custom JPQL queries for specific business requirements.", "databaseName": "unknown", "tablesAccessed": [ "SavingsAccountCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with custom filtering logic (WHERE clauses) and ordering.", "transactionHandling": "Spring Data default transaction management (likely read-only for query methods unless overridden).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select sac from SavingsAccountCharge sac where sac.id =:id and sac.savingsAccount.id = :savingsAccountId\")" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper, SavingsAccountChargeRepository", "description": "The class uses Spring Data repositories to retrieve 'Charge' definitions and existing 'SavingsAccountCharge' entities. It performs read operations to fetch data required for assembly and validation.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_savings_account_charge" ], "operationType": [ "READ" ], "queryPatterns": "Standard JPA repository find by ID methods.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(chargeId);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepository", "description": "The class interacts with the database primarily through Spring Data JPA repositories (SavingsAccountRepository and SavingsAccountTransactionRepository). It performs standard CRUD operations, custom finders (e.g., by client ID, status), and transaction management using @Transactional annotations. A JdbcTemplate is injected but not explicitly used in the visible public methods.", "databaseName": "unknown", "tablesAccessed": [ "SavingsAccount", "SavingsAccountTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods including findById, save, delete, and custom finders likely defined via method names or @Query annotations in the repository interfaces.", "transactionHandling": "Spring @Transactional annotations are used on methods, with readOnly=true specified for retrieval operations.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final SavingsAccount account = this.repository.findById(savingsId)\n .orElseThrow(() -> new SavingsAccountNotFoundException(savingsId));" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper, SavingsAccountChargeRepository", "description": "The class uses injected repository wrappers and repositories to interact with the database. It retrieves 'Charge' definitions to create new savings charges and retrieves existing 'SavingsAccountCharge' entities by ID to perform updates.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_savings_account_charge" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Standard repository findById calls", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(chargeId);\n// ...\nfinal SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository\n .findById(savingsAccountChargeId)\n .orElseThrow(() -> new SavingsAccountChargeNotFoundException(savingsAccountChargeId));" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "RecurringDepositAccountRepository", "description": "The code utilizes Spring Data JPA to interact with the database. It defines a repository interface that extends JpaRepository, automatically providing data access methods for the RecurringDepositAccount entity.", "databaseName": "unknown", "tablesAccessed": [ "RecurringDepositAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specifications via JpaSpecificationExecutor.", "transactionHandling": "Transactions are handled implicitly by the Spring Data JPA repository proxy (default @Transactional behavior).", "protocol": "JPA", "connectionInfo": "unknown", "codeExample": "public interface RecurringDepositAccountRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "DepositAccountOnHoldTransactionRepository", "description": "The interface uses Spring Data JPA to abstract database interactions. It maps the DepositAccountOnHoldTransaction entity to a database table and provides methods to query and manipulate this data without writing raw SQL.", "databaseName": "unknown", "tablesAccessed": [ "DepositAccountOnHoldTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data JPA derived query methods (ORM)", "transactionHandling": "Spring Data JPA repositories are transactional by default (Spring @Transactional)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface DepositAccountOnHoldTransactionRepository extends JpaRepository ..." }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and by defining custom JPQL queries via the @Query annotation for more complex retrieval logic.", "databaseName": "unknown", "tablesAccessed": [ "SavingsAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code uses JPQL queries with named parameters. It includes simple selects, filtering by multiple columns, checking for existence (count > 0), and pessimistic locking.", "transactionHandling": "Spring Data repositories typically participate in existing transactions. The 'findOneLocked' method explicitly defines a PESSIMISTIC_WRITE lock mode.", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select s_acc from SavingsAccount s_acc where s_acc.client.id = :clientId\")\nList findSavingAccountByClientId(@Param(\"clientId\") Long clientId);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "RepositoryWrappers", "description": "The class uses several RepositoryWrapper classes (ClientRepositoryWrapper, GroupRepositoryWrapper, SavingsAccountRepositoryWrapper, etc.) which likely wrap Spring Data JPA repositories. It uses these to fetch entities by ID to assemble the domain objects.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_client", "m_group", "m_staff", "m_product_loan" ], "operationType": [ "READ" ], "queryPatterns": "Standard CRUD find operations by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "client = this.clientRepository.findOneWithNotFoundDetection(clientId, isCalendarInherited);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountChargeRepository", "description": "The class wraps a Spring Data repository interface (SavingsAccountChargeRepository) to perform CRUD operations and custom finders on the underlying database.", "databaseName": "unknown", "tablesAccessed": [ "SavingsAccountCharge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and specific finders by ID or pending status.", "transactionHandling": "Implicitly handled by the underlying Spring Data repository or the calling service context.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public SavingsAccountCharge findOneWithNotFoundDetection(final Long id) {\n return this.repository.findById(id).orElseThrow(() -> new SavingsAccountChargeNotFoundException(id));\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrappers) to persist SavingsAccount and SavingsAccountTransaction entities. It uses standard JPA save/saveAndFlush methods.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction", "m_deposit_account_on_hold_transaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and finding transactions by account.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.savingsAccountRepository.save(account);" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses wrapper classes around Spring Data JPA repositories to interact with the database. It retrieves entities like SavingsProduct, Client, Group, and Staff, and loads SavingsAccount transactions.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_product", "m_client", "m_group", "m_staff", "m_savings_account_transaction" ], "operationType": [ "READ" ], "queryPatterns": "The code primarily performs lookups by ID (findById) and fetches related transaction data. It includes logic for fetching transactions after a specific pivot date.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "final SavingsProduct product = this.savingProductRepository.findById(productId)\n .orElseThrow(() -> new SavingsProductNotFoundException(productId));" }, { "path": "org.apache.fineract.portfolio.savings.domain", "mechanism": "SPRING-DATA", "name": "SavingsAccountTransactionRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending `JpaRepository`, which provides standard CRUD capabilities. It defines custom JPQL queries using `@Query` annotations and utilizes `@Lock` for database-level row locking (Pessimistic Write) to handle concurrency for financial transactions.", "databaseName": "unknown", "tablesAccessed": [ "SavingsAccountTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with filtering by ID, date ranges, and boolean flags; Pessimistic locking; Pagination.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository) and explicit Pessimistic Locking.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Lock(LockModeType.PESSIMISTIC_WRITE)\n@Query(\"select st from SavingsAccountTransaction st where st.savingsAccount = :savingsAccount...\")\nList findTransactionsAfterPivotDate(...);" }, { "path": "org.apache.fineract.portfolio.savings.domain.DepositProductAssembler", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper, TaxGroupRepositoryWrapper", "description": "The class uses injected repository wrappers to retrieve existing Charge and TaxGroup entities from the database based on IDs provided in the JSON command. It performs read-only operations to link these existing entities to the new product being assembled.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_tax_group" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookup by primary key (ID).", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Long id = jsonObject.get(idParamName).getAsLong();\nfinal Charge charge = this.chargeRepository.findOneWithNotFoundDetection(id);" }, { "path": "org.apache.fineract.portfolio.savings.domain.FixedDepositAccountRepository", "mechanism": "SPRING-DATA", "name": "FixedDepositAccountRepository", "description": "Database integration is achieved through Spring Data JPA. The interface extends JpaRepository, which provides standard CRUD operations, and JpaSpecificationExecutor, which allows for dynamic querying based on JPA Specifications. The actual SQL generation and execution are handled by the Spring framework and the underlying Hibernate provider.", "databaseName": "unknown", "tablesAccessed": [ "FixedDepositAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data infrastructure.", "transactionHandling": "Spring @Transactional (default behavior for Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "configured in application properties (unknown from this file)", "codeExample": "public interface FixedDepositAccountRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.FixedDepositProductRepository", "mechanism": "SPRING-DATA", "name": "FixedDepositProductRepository", "description": "The file uses Spring Data JPA to manage database interactions. By extending JpaRepository, it automatically gains methods for saving, deleting, and finding entities. By extending JpaSpecificationExecutor, it gains the ability to query the database using dynamic criteria (Specifications).", "databaseName": "unknown", "tablesAccessed": [ "FixedDepositProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicit in Spring Data Repositories)", "protocol": "JPA", "connectionInfo": "configured in application properties", "codeExample": "public interface FixedDepositProductRepository\n extends JpaRepository, JpaSpecificationExecutor {\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.RecurringDepositProductRepository", "mechanism": "SPRING-DATA", "name": "RecurringDepositProductRepository", "description": "The interface uses Spring Data JPA to abstract database interactions, automatically providing implementations for standard CRUD operations and specification-based queries.", "databaseName": "unknown", "tablesAccessed": [ "RecurringDepositProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (default behavior for Spring Data Repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface RecurringDepositProductRepository\n extends JpaRepository, JpaSpecificationExecutor {\n //\n}" }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsProductAssembler", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper, TaxGroupRepositoryWrapper", "description": "The class uses injected repository wrappers (likely wrapping Spring Data JPA repositories) to look up existing 'Charge' and 'TaxGroup' entities by their primary keys during the assembly process.", "databaseName": "unknown", "tablesAccessed": [ "Charge", "TaxGroup" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Charge charge = this.chargeRepository.findOneWithNotFoundDetection(id);" }, { "path": "org.apache.fineract.portfolio.savings.domain.SavingsProductRepository", "mechanism": "SPRING-DATA", "name": "SavingsProductRepository", "description": "The code uses Spring Data JPA to interact with the database. By extending JpaRepository, it automatically gains methods for standard CRUD operations on the 'SavingsProduct' entity. By extending JpaSpecificationExecutor, it gains the ability to run dynamic queries based on the JPA Criteria API.", "databaseName": "unknown", "tablesAccessed": [ "SavingsProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by Spring Data infrastructure.", "transactionHandling": "Spring Data repositories are transactional by default (read-only for read methods, read-write for others).", "protocol": "JDBC (via Hibernate/JPA)", "connectionInfo": "unknown", "codeExample": "public interface SavingsProductRepository extends JpaRepository, JpaSpecificationExecutor {\n //\n}" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "SPRING-DATA", "name": "DepositAccountWritePlatformService", "description": "The class uses Spring's @Transactional annotation to manage database transactions for the activation process. While it does not execute SQL directly, it orchestrates the write operation via the injected DepositAccountWritePlatformService, ensuring the state change is committed atomically.", "databaseName": "unknown", "tablesAccessed": [ "RECURRINGDEPOSITACCOUNT" ], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer for update/write operations.", "transactionHandling": "Spring @Transactional annotation on the processCommand method.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(final JsonCommand command) {\n return this.depositAccountWritePlatformService.activateRDAccount(command.entityId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.handler", "mechanism": "SPRING-DATA", "name": "SavingsAccountWritePlatformService", "description": "The class uses Spring's `@Transactional` annotation to define transaction boundaries for the database operation. The actual data access logic is delegated to the `SavingsAccountWritePlatformService`.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "WRITE" ], "queryPatterns": "Delegates to service layer", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "@Transactional\n @Override\n public CommandProcessingResult processCommand(JsonCommand command) {\n return this.writePlatformService.holdAmount(command.getSavingsId(), command);\n }" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "SPRING-DATA", "name": "FixedDepositProductRepository", "description": "The class uses a Spring Data JPA repository (`FixedDepositProductRepository`) to interact with the database. It performs standard CRUD operations (save, findById, delete) on the `FixedDepositProduct` entity. Transactions are managed via the `@Transactional` annotation.", "databaseName": "unknown", "tablesAccessed": [ "FixedDepositProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations using JPA Repository methods.", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.fixedDepositProductRepository.saveAndFlush(product);" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "SPRING-DATA", "name": "SavingsProductRepository", "description": "The class uses a Spring Data JPA repository (`SavingsProductRepository`) to interact with the database. It performs CRUD operations on the `SavingsProduct` entity. Transaction management is handled via the `@Transactional` annotation on the class and methods.", "databaseName": "unknown", "tablesAccessed": [ "SavingsProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById, delete) without explicit JPQL in this service.", "transactionHandling": "Spring @Transactional annotations on the class and methods.", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.savingProductRepository.saveAndFlush(product);" }, { "path": "org.apache.fineract.portfolio.savings.service", "mechanism": "SPRING-DATA", "name": "GSIMRepositoy", "description": "The class uses a Spring Data repository (GSIMRepositoy) to perform CRUD operations on the GroupSavingsIndividualMonitoring entity. The class is also annotated with @Transactional, ensuring that database operations within its methods are executed within a transaction context.", "databaseName": "unknown", "tablesAccessed": [ "GroupSavingsIndividualMonitoring" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save/update) via repository methods.", "transactionHandling": "Spring @Transactional annotation on the class level.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "return this.gsimAccountRepository.save(glimAccountInfo);" }, { "path": "org.apache.fineract.portfolio.savings.service.RecurringDepositProductWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "RecurringDepositProductRepository", "description": "The class uses a Spring Data JPA repository (RecurringDepositProductRepository) to interact with the database. It performs standard CRUD operations (saveAndFlush, findById, delete) on the RecurringDepositProduct entity. Transaction management is handled via the @Transactional annotation.", "databaseName": "unknown", "tablesAccessed": [ "RecurringDepositProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository CRUD operations.", "transactionHandling": "Spring @Transactional annotations", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.recurringDepositProductRepository.saveAndFlush(product);" }, { "path": "org.apache.fineract.portfolio.savings.service.SavingsAccountWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrappers like `SavingsAccountRepositoryWrapper`) to interact with the database. It performs CRUD operations on `SavingsAccount`, `SavingsAccountTransaction`, `SavingsAccountCharge`, and other related entities. It uses `@Transactional` to ensure data consistency across multiple repository calls.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_savings_account_transaction", "m_savings_account_charge", "m_note", "gsim_accounts", "m_payment_detail", "m_account_transfer_standing_instruction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findById, saveAndFlush) with some custom finders (e.g., findByGsimId, findBySavingsAccountIdAndLessThanDateOfAndReversedIsFalse).", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.savingAccountRepositoryWrapper.saveAndFlush(account);" }, { "path": "org.apache.fineract.portfolio.savings.service.SavingsApplicationProcessWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "SavingsAccountRepositoryWrapper", "description": "The class uses Spring Data JPA repositories (wrapped in custom wrappers) to interact with the database. It performs CRUD operations on SavingsAccount, Client, Group, and Note entities. It also handles transaction management using @Transactional annotations.", "databaseName": "unknown", "tablesAccessed": [ "m_savings_account", "m_client", "m_group", "m_product_savings", "m_note", "gsim_accounts", "m_staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findOne, delete) with some custom finders for GSIM accounts.", "transactionHandling": "Spring @Transactional annotations on service methods", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "this.savingAccountRepository.save(account);\nString accountNumber = \"\";\n// ...\naccountNumber = this.accountNumberGenerator.generate(account, accountNumberFormat);\naccount.updateAccountNo(accountNumber + \"1\");\n// ...\nthis.savingAccountRepository.saveAndFlush(account);" }, { "path": "org.apache.fineract.portfolio.savings.service.search.SavingsAccountTransactionSearchService", "mechanism": "SPRING-DATA", "name": "SavingsAccountTransactionSearchService", "description": "While this is an interface, the return type `org.springframework.data.domain.Page` strongly indicates that the implementation interacts with a database using Spring Data or a similar pagination-aware data access layer. The methods are designed to retrieve paginated subsets of data (Transactions) based on IDs and criteria.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ" ], "queryPatterns": "Paginated search queries with filtering criteria", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "Page searchTransactions(@NotNull Long savingsId, @NotNull TransactionSearchRequest searchParameters);" }, { "path": "org.apache.fineract.portfolio.self.account.domain", "mechanism": "SPRING-DATA", "name": "SelfBeneficiariesTPTRepository", "description": "The interface uses Spring Data JPA to interact with the database for the SelfBeneficiariesTPT entity. It inherits standard data access methods automatically.", "databaseName": "unknown", "tablesAccessed": [ "SelfBeneficiariesTPT" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic queries via JpaSpecificationExecutor.", "transactionHandling": "Spring Data repositories typically apply @Transactional to inherited methods by default.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface SelfBeneficiariesTPTRepository\n extends JpaRepository, JpaSpecificationExecutor {" }, { "path": "org.apache.fineract.portfolio.self.account.service", "mechanism": "SPRING-DATA", "name": "SelfBeneficiariesTPTRepository", "description": "The class uses Spring Data JPA repositories to interact with the database. It performs CRUD operations on the `SelfBeneficiariesTPT` entity and read-only lookups on `Loan` and `SavingsAccount` entities via their respective wrapper services.", "databaseName": "unknown", "tablesAccessed": [ "SelfBeneficiariesTPT", "Loan", "SavingsAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (saveAndFlush, findById) and wrapper lookups (findNonClosedLoanByAccountNumber).", "transactionHandling": "Spring @Transactional annotations on methods.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.saveAndFlush(beneficiary);" }, { "path": "org.apache.fineract.portfolio.self.pockets.domain", "mechanism": "SPRING-DATA", "name": "PocketRepository", "description": "The class interacts with the database via a Spring Data repository interface (PocketRepository). It performs CRUD operations such as saving entities and finding records by foreign key (appUserId).", "databaseName": "unknown", "tablesAccessed": [ "Pocket" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and finder methods based on entity attributes.", "transactionHandling": "Relies on Spring Data's default transaction management for repositories.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.pocketRepository.saveAndFlush(pocket);" }, { "path": "org.apache.fineract.portfolio.self.pockets.domain", "mechanism": "SPRING-DATA", "name": "PocketAccountMappingRepository", "description": "The class wraps a Spring Data repository (PocketAccountMappingRepository) to perform CRUD operations on the PocketAccountMapping entity.", "databaseName": "unknown", "tablesAccessed": [ "PocketAccountMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and finder methods by ID.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.pocketAccountMappingRepository.save(pocketAccountMapping);" }, { "path": "org.apache.fineract.portfolio.self.pockets.domain.PocketAccountMappingRepository", "mechanism": "SPRING-DATA", "name": "PocketAccountMappingRepository", "description": "The interface extends JpaRepository to provide database access for PocketAccountMapping entities using Spring Data JPA.", "databaseName": "unknown", "tablesAccessed": [ "PocketAccountMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with named parameters for filtering by IDs.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "@Query(\"select pam from PocketAccountMapping pam where pam.pocketId =:pocketId\")" }, { "path": "org.apache.fineract.portfolio.self.pockets.domain.PocketRepository", "mechanism": "SPRING-DATA", "name": "PocketRepository", "description": "The interface extends JpaRepository to provide database interaction for the Pocket entity using Spring Data JPA.", "databaseName": "unknown", "tablesAccessed": [ "Pocket" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via annotations and standard CRUD operations inherited from JpaRepository.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select pocket.id from Pocket pocket where pocket.appUserId= :appUserId\")" }, { "path": "org.apache.fineract.portfolio.self.pockets.service.PocketWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "PocketRepositoryWrapper, PocketAccountMappingRepositoryWrapper", "description": "The class uses repository wrappers (likely wrapping Spring Data JPA repositories) to perform CRUD operations on 'Pocket' and 'PocketAccountMapping' entities. It uses 'saveAndFlush' for creating pockets, 'save' for batch inserting mappings, and 'delete' for removing mappings.", "databaseName": "unknown", "tablesAccessed": [ "Pocket", "PocketAccountMapping" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findByAppUserId, save, delete, findByIdAndPocketId)", "transactionHandling": "Spring @Transactional annotations on the class level", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.pocketRepositoryWrapper.saveAndFlush(pocket);" }, { "path": "org.apache.fineract.portfolio.self.registration.domain.SelfServiceRegistrationRepository", "mechanism": "SPRING-DATA", "name": "SelfServiceRegistrationRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending `JpaRepository`, which provides standard CRUD operations, and defines custom JPQL queries via annotations.", "databaseName": "unknown", "tablesAccessed": [ "SelfServiceRegistration" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries defined via @Query annotation and standard Spring Data CRUD operations.", "transactionHandling": "Spring Data JPA repositories typically participate in Spring managed transactions (@Transactional).", "protocol": "JPA/JDBC", "connectionInfo": "unknown", "codeExample": "@Query(FIND_BY_REQUEST_AND_AUTHENTICATION_TOKEN)\nSelfServiceRegistration getRequestByIdAndAuthenticationToken(@Param(\"id\") Long id, ...)" }, { "path": "org.apache.fineract.portfolio.self.registration.service.SelfServiceRegistrationWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "SelfServiceRegistrationRepository", "description": "The class uses Spring Data JPA repositories (SelfServiceRegistrationRepository, ClientRepositoryWrapper, SmsMessageRepository, RoleRepository, PasswordValidationPolicyRepository) to perform CRUD operations on entities. It also delegates user creation to UserDomainService.", "databaseName": "unknown", "tablesAccessed": [ "m_selfservice_user_registration", "m_client", "m_appuser", "m_role", "sms_messages", "m_password_validation_policy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (save, findById, etc.) and some custom finders.", "transactionHandling": "Likely managed by Spring @Transactional at the class or interface level (not visible in this file but implied by service layer conventions).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.selfServiceRegistrationRepository.saveAndFlush(selfServiceRegistration);" }, { "path": "org.apache.fineract.portfolio.self.registration.starter.SelfRegistrationConfiguration", "mechanism": "SPRING-DATA", "name": "SelfServiceRegistrationRepository", "description": "The configuration class wires up database access components. It injects a JdbcTemplate for the read platform service (indicating direct JDBC usage) and multiple Spring Data repositories (e.g., SelfServiceRegistrationRepository, ClientRepositoryWrapper, RoleRepository) for the write platform service.", "databaseName": "unknown", "tablesAccessed": [ "unknown" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The read service likely uses SQL queries via JdbcTemplate, while the write service uses Spring Data JPA repository methods.", "transactionHandling": "Transaction handling is likely managed within the service implementations (SelfServiceRegistrationWritePlatformServiceImpl) rather than this configuration class.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return new SelfServiceRegistrationReadPlatformServiceImpl(jdbcTemplate);" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountDividendRepository", "mechanism": "SPRING-DATA", "name": "ShareAccountDividendRepository", "description": "The interface extends JpaRepository, indicating it uses Spring Data JPA to manage persistence for the ShareAccountDividendDetails entity without writing explicit SQL or JPQL.", "databaseName": "unknown", "tablesAccessed": [ "ShareAccountDividendDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations provided by JpaRepository.", "transactionHandling": "Managed implicitly by Spring Data JPA (usually @Transactional on the proxy).", "protocol": "JPA", "connectionInfo": "configured externally", "codeExample": "public interface ShareAccountDividendRepository\n extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountRepository", "mechanism": "SPRING-DATA", "name": "ShareAccountRepository", "description": "The interface extends JpaRepository and JpaSpecificationExecutor, leveraging Spring Data JPA to manage database interactions for the ShareAccount entity automatically.", "databaseName": "unknown", "tablesAccessed": [ "ShareAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specifications provided by Spring Data JPA.", "transactionHandling": "Spring @Transactional (implicitly handled by the Spring Data JPA implementation proxy)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ShareAccountRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.shareaccounts.domain.ShareAccountRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ShareAccountRepository", "description": "The class wraps a Spring Data repository (ShareAccountRepository) to perform CRUD operations. It relies on the underlying JPA implementation provided by Spring Data to generate SQL queries.", "databaseName": "unknown", "tablesAccessed": [ "ShareAccount" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (findById, save, saveAndFlush)", "transactionHandling": "Delegated to underlying repository or caller (no explicit @Transactional on this class)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.shareAccountRepository.findById(accountId).orElseThrow(() -> new ShareAccountNotFoundException(accountId));" }, { "path": "org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer", "mechanism": "SPRING-DATA", "name": "RepositoryWrappers", "description": "The class uses several repository wrappers (ChargeRepositoryWrapper, SavingsAccountRepositoryWrapper, ClientRepositoryWrapper, ShareProductRepositoryWrapper) to interact with the database. These wrappers likely encapsulate Spring Data JPA repositories. The class fetches entities to validate existence and business rules, and modifies the state of the ShareAccount entity which is then persisted by the calling transaction context.", "databaseName": "unknown", "tablesAccessed": [ "m_charge", "m_client", "m_share_product", "m_savings_account", "m_share_account", "m_share_account_transaction", "m_share_account_charge" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository methods (findOne, etc.)", "transactionHandling": "Implicitly relies on the transaction context of the caller (likely a Service class annotated with @Transactional), as this class is a helper/validator service.", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "ShareProduct shareProduct = this.shareProductRepository.findOneWithNotFoundDetection(productId);" }, { "path": "org.apache.fineract.portfolio.shareaccounts.service", "mechanism": "SPRING-DATA", "name": "ShareAccountDividendRepository", "description": "The class uses a Spring Data repository (ShareAccountDividendRepository) to fetch and save dividend details. It also interacts with the database implicitly through the SavingsAccountAssembler and SavingsAccountDomainService which manage SavingsAccount entities.", "databaseName": "unknown", "tablesAccessed": [ "ShareAccountDividendDetails", "SavingsAccount", "SavingsAccountTransaction" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "CRUD operations via Repository methods (findById, saveAndFlush)", "transactionHandling": "Spring @Transactional annotation on the postDividend method", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "ShareAccountDividendDetails shareAccountDividendDetails = this.shareAccountDividendRepository.findById(dividendDetailId).orElseThrow();\n...\nthis.shareAccountDividendRepository.saveAndFlush(shareAccountDividendDetails);" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain", "mechanism": "SPRING-DATA", "name": "ShareProductDividentPayOutDetailsRepository", "description": "Database integration is achieved through Spring Data JPA. The interface extends JpaRepository, which provides standard CRUD operations, and JpaSpecificationExecutor, which allows for dynamic query construction. The framework automatically maps these methods to database operations for the ShareProductDividendPayOutDetails entity.", "databaseName": "unknown", "tablesAccessed": [ "ShareProductDividendPayOutDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic queries via Specifications", "transactionHandling": "Spring @Transactional (implicit in JpaRepository methods)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ShareProductDividentPayOutDetailsRepository\n extends JpaRepository, JpaSpecificationExecutor {\n}" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain.ShareProductDividentPayOutDetailsRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ShareProductDividentPayOutDetailsRepository", "description": "The class wraps a Spring Data repository interface to perform database operations on the ShareProductDividendPayOutDetails entity.", "databaseName": "unknown", "tablesAccessed": [ "ShareProductDividendPayOutDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.shareProductDividentPayOutDetailsRepository.findById(dividendId)" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain.ShareProductRepository", "mechanism": "SPRING-DATA", "name": "ShareProductRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically implements the repository interface to interact with the database tables mapped to the ShareProduct entity.", "databaseName": "unknown", "tablesAccessed": [ "ShareProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification-based queries provided by JpaRepository and JpaSpecificationExecutor.", "transactionHandling": "Spring @Transactional (implicitly handled by Spring Data JPA implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface ShareProductRepository extends JpaRepository, JpaSpecificationExecutor {}" }, { "path": "org.apache.fineract.portfolio.shareproducts.domain.ShareProductRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "ShareProductRepository", "description": "The class interacts with the database through a Spring Data repository interface (ShareProductRepository). It performs standard CRUD operations such as finding by ID and saving entities. The actual SQL generation and execution are handled by the Spring Data JPA implementation backing the repository interface.", "databaseName": "unknown", "tablesAccessed": [ "ShareProduct" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations via Repository abstraction", "transactionHandling": "Likely handled by Spring @Transactional at the repository or service level (implicit)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.shareProductRepository.findById(productId).orElseThrow(...)" }, { "path": "org.apache.fineract.portfolio.shareproducts.serialization.ShareProductDataSerializer", "mechanism": "SPRING-DATA", "name": "ChargeRepositoryWrapper", "description": "The class uses a repository wrapper to access Charge entities from the database during validation. This is used to verify that charges associated with a share product exist and share the same currency.", "databaseName": "unknown", "tablesAccessed": [ "Charge" ], "operationType": [ "READ" ], "queryPatterns": "Simple lookup by ID", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Charge charge = this.chargeRepository.findOneWithNotFoundDetection(id);" }, { "path": "org.apache.fineract.portfolio.shareproducts.service", "mechanism": "SPRING-DATA", "name": "ShareProductRepositoryWrapper", "description": "The class uses repository wrappers (likely wrapping Spring Data JpaRepository interfaces) to interact with the database. It performs CRUD operations and explicit flushing.", "databaseName": "unknown", "tablesAccessed": [ "ShareProduct", "ShareProductDividendPayOutDetails" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via repository abstraction (save, saveAndFlush, findOne, delete).", "transactionHandling": "Implicitly handled by Spring Data repositories or service layer AOP (though @Transactional is not explicitly on this class, saveAndFlush implies transaction participation).", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.saveAndFlush(product);" }, { "path": "org.apache.fineract.portfolio.tax.domain", "mechanism": "SPRING-DATA", "name": "TaxComponentRepository", "description": "The class interacts with the database via the TaxComponentRepository, which is a Spring Data repository interface. It performs read operations to locate TaxComponent entities by ID.", "databaseName": "unknown", "tablesAccessed": [ "TaxComponent" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD (findById)", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "this.repository.findById(id).orElseThrow(() -> new TaxComponentNotFoundException(id))" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxComponentRepository", "mechanism": "SPRING-DATA", "name": "TaxComponentRepository", "description": "Database integration is achieved through Spring Data JPA, which automatically generates the implementation for standard CRUD operations and specification-based queries for the TaxComponent entity.", "databaseName": "unknown", "tablesAccessed": [ "TaxComponent" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specification queries provided by Spring Data.", "transactionHandling": "Spring @Transactional (implicit in JpaRepository implementation)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface TaxComponentRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxGroupRepository", "mechanism": "SPRING-DATA", "name": "TaxGroupRepository", "description": "The interface uses Spring Data JPA to manage persistence for the TaxGroup entity, providing automatic implementation of data access patterns.", "databaseName": "unknown", "tablesAccessed": [ "TaxGroup" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations and dynamic specifications via Criteria API", "transactionHandling": "Spring @Transactional (default for Spring Data Repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface TaxGroupRepository extends JpaRepository, JpaSpecificationExecutor {\n\n}" }, { "path": "org.apache.fineract.portfolio.tax.domain.TaxGroupRepositoryWrapper", "mechanism": "SPRING-DATA", "name": "TaxGroupRepository", "description": "The class wraps a Spring Data repository interface to perform database read operations.", "databaseName": "unknown", "tablesAccessed": [ "TaxGroup" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD lookup by Primary Key", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.repository.findById(id).orElseThrow(() -> new TaxGroupNotFoundException(id))" }, { "path": "org.apache.fineract.portfolio.tax.service.TaxAssembler", "mechanism": "SPRING-DATA", "name": "GLAccountRepositoryWrapper, TaxComponentRepositoryWrapper", "description": "The class uses repository wrappers to perform read-only operations against the database. It fetches 'GLAccount' entities to validate account IDs provided in the JSON payload and 'TaxComponent' entities when assembling tax groups.", "databaseName": "unknown", "tablesAccessed": [ "GLAccount (implied)", "TaxComponent (implied)" ], "operationType": [ "READ" ], "queryPatterns": "Simple entity lookups by ID using repository wrappers.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "debitGlAccount = this.glAccountRepositoryWrapper.findOneWithNotFoundDetection(debitAccountId);" }, { "path": "org.apache.fineract.portfolio.tax.service.TaxWritePlatformServiceImpl", "mechanism": "SPRING-DATA", "name": "TaxComponentRepository and TaxGroupRepository", "description": "The class uses Spring Data JPA repositories (injected via constructor) to perform CRUD operations. It uses 'saveAndFlush' for immediate persistence and 'findOneWithNotFoundDetection' (via a wrapper) for retrieval.", "databaseName": "unknown", "tablesAccessed": [ "TaxComponent", "TaxGroup", "TaxGroupMappings" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Simple CRUD operations via Repository interface methods.", "transactionHandling": "Implicitly handled by Spring Data Repository methods or higher-level AOP (not explicit in this class).", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.taxComponentRepository.saveAndFlush(taxComponent);" }, { "path": "org.apache.fineract.portfolio.transfer.service.TransferWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "Fineract Portfolio Repositories", "description": "The class uses multiple Repository Wrappers (which likely wrap Spring Data JpaRepositories) to perform CRUD operations on entities like Client, Group, Office, Loan, and SavingsAccount. It uses @Transactional to ensure atomicity.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_group", "m_office", "m_loan", "m_savings_account", "m_calendar_instance", "m_client_transfer_details", "m_staff" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository finders (findOne, findBy...) and save/flush operations.", "transactionHandling": "Spring @Transactional annotations on service methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.clientRepositoryWrapper.saveAndFlush(client);" }, { "path": "org.apache.fineract.spm.api.ScorecardApiResource", "mechanism": "SPRING-DATA", "name": "ClientRepositoryWrapper / ScorecardService", "description": "The class interacts with the database through service layers and repository wrappers. It uses `ClientRepositoryWrapper` (likely wrapping a Spring Data JPA repository) to fetch Client entities and `ScorecardService`/`ScorecardReadPlatformService` to perform CRUD operations on Scorecards. The `@Transactional` annotation on methods indicates that these operations participate in Spring-managed database transactions.", "databaseName": "unknown", "tablesAccessed": [ "m_client", "m_survey_scorecards", "m_surveys" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The code performs entity lookups by ID (Client, Survey) and creates new entities (Scorecard). Read operations likely involve simple SELECTs with WHERE clauses on foreign keys (survey_id, client_id).", "transactionHandling": "Spring @Transactional annotations on public methods", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final Client client = this.clientRepositoryWrapper.findOneWithNotFoundDetection(scorecardData.getClientId());\nthis.scorecardService.createScorecard(ScorecardMapper.map(scorecardData, survey, appUser, client));" }, { "path": "org.apache.fineract.spm.domain", "mechanism": "SPRING-DATA", "name": "SurveyRepository", "description": "The code utilizes Spring Data JPA to interact with the database. It extends `JpaRepository` to inherit standard database operations and uses `@Query` annotations to define custom JPQL queries for temporal filtering.", "databaseName": "unknown", "tablesAccessed": [ "Survey" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries involving temporal 'between' comparisons and exact matches on keys.", "transactionHandling": "Transactions are handled by the Spring container; read operations are typically read-only, while inherited write operations are transactional.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"select s from Survey s where :pointInTime between s.validFrom and s.validTo\")" }, { "path": "org.apache.fineract.spm.domain.LookupTableRepository", "mechanism": "SPRING-DATA", "name": "LookupTableRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and defines custom finder methods that are translated into SQL/JPQL by the Spring framework.", "databaseName": "unknown", "tablesAccessed": [ "LookupTable" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "simple CRUD", "transactionHandling": "Spring @Transactional", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "public interface LookupTableRepository extends JpaRepository {\n List findBySurvey(Survey survey);\n}" }, { "path": "org.apache.fineract.spm.domain.ScorecardRepository", "mechanism": "SPRING-DATA", "name": "ScorecardRepository", "description": "The file uses Spring Data JPA to interact with the database. By extending JpaRepository, it gains automatic implementations for standard CRUD operations and supports dynamic query generation based on method names.", "databaseName": "unknown", "tablesAccessed": [ "Scorecard" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM queries, simple CRUD", "transactionHandling": "Spring @Transactional", "protocol": "JDBC", "connectionInfo": "unknown", "codeExample": "public interface ScorecardRepository extends JpaRepository { ... }" }, { "path": "org.apache.fineract.spm.service.LookupTableService", "mechanism": "SPRING-DATA", "name": "LookupTableRepository", "description": "The service uses a Spring Data repository interface (`LookupTableRepository`) to interact with the underlying database. This abstracts the SQL/JPQL logic.", "databaseName": "unknown", "tablesAccessed": [ "LookupTable" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (find by key, find by survey, save all) delegated to Spring Data.", "transactionHandling": "Implicitly handled by Spring Data repository methods or higher-level transaction boundaries (not explicit in this file).", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.lookupTableRepository.findByKey(key);" }, { "path": "org.apache.fineract.spm.service.ScorecardService", "mechanism": "SPRING-DATA", "name": "ScorecardRepository", "description": "The service uses a Spring Data repository (`ScorecardRepository`) to perform CRUD operations on `Scorecard` entities.", "databaseName": "unknown", "tablesAccessed": [ "Scorecard" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD and finder methods provided by Spring Data JPA.", "transactionHandling": "Implicitly handled by Spring Data repository methods (default transactional behavior), though no explicit @Transactional annotation is present on the service methods.", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "return this.scorecardRepository.saveAll(scorecards);" }, { "path": "org.apache.fineract.spm.service.SpmService", "mechanism": "SPRING-DATA", "name": "SurveyRepository", "description": "The class interacts with the database via the `SurveyRepository` interface, which is injected by Spring. It performs CRUD operations (save, findById) and custom queries (fetchActiveSurveys, findByKey). It explicitly handles JPA and Data Integrity exceptions to manage database constraints.", "databaseName": "unknown", "tablesAccessed": [ "Survey", "m_survey_scorecards" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via Repository pattern, plus custom fetch methods for active surveys and finding by key.", "transactionHandling": "Implicitly handled by Spring Data Repository methods (saveAndFlush), though no explicit @Transactional annotation is present on the service class itself.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "this.surveyRepository.saveAndFlush(survey);" }, { "path": "org.apache.fineract.template.domain", "mechanism": "SPRING-DATA", "name": "TemplateRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and defines custom query methods for specific lookups.", "databaseName": "unknown", "tablesAccessed": [ "Template", "Template.mappers" ], "operationType": [ "READ", "READ_WRITE" ], "queryPatterns": "JPQL queries with joins and derived query methods", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select t from Template as t left join t.mappers as m where m.mapperkey = :mapperkey and m.mappervalue = :mappervalue\")" }, { "path": "org.apache.fineract.template.service.JpaTemplateDomainService", "mechanism": "SPRING-DATA", "name": "TemplateRepository", "description": "The class uses a Spring Data repository interface (`TemplateRepository`) to perform CRUD operations on the database. It relies on Spring's `@Transactional` annotation to manage transaction boundaries for data modification methods.", "databaseName": "unknown", "tablesAccessed": [ "Template" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations and finder methods (findAll, findById, findByEntityAndType).", "transactionHandling": "Spring @Transactional annotations on state-changing methods (create, update, remove).", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.templateRepository.saveAndFlush(template);" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "SPRING-DATA", "name": "AppUserPreviousPasswordRepository", "description": "The code uses Spring Data JPA to interact with the database. By extending `JpaRepository`, it abstracts the underlying JDBC and SQL interactions, allowing object-oriented manipulation of the `AppUserPreviousPassword` entity.", "databaseName": "unknown", "tablesAccessed": [ "AppUserPreviousPassword" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Spring Data derived query methods and standard CRUD operations.", "transactionHandling": "Spring Data JPA default transaction management (typically read-only for find methods, transactional for writes).", "protocol": "JDBC (via Hibernate/JPA)", "connectionInfo": "unknown", "codeExample": "List history = repository.findByUserId(123L, PageRequest.of(0, 5));" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "SPRING-DATA", "name": "AppUserRepository", "description": "The class interacts with the database via the injected `AppUserRepository`, which is likely a Spring Data repository interface.", "databaseName": "unknown", "tablesAccessed": [ "AppUser" ], "operationType": [ "READ" ], "queryPatterns": "Simple CRUD find by name", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "AppUser user = this.appUserRepository.findAppUserByName(AppUserConstants.SYSTEM_USER_NAME);" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "SPRING-DATA", "name": "AppUserRepository", "description": "The class uses a Spring Data JPA repository (AppUserRepository) to persist AppUser entities. It performs save and flush operations within a transactional context.", "databaseName": "unknown", "tablesAccessed": [ "AppUser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations (save, saveAndFlush)", "transactionHandling": "Spring @Transactional annotation on the class and method", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.userRepository.saveAndFlush(appUser);" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "SPRING-DATA", "name": "PermissionRepository", "description": "The file uses Spring Data JPA to interact with the database. It extends JpaRepository to provide standard data access methods and defines a custom JPQL query for specific lookup logic.", "databaseName": "unknown", "tablesAccessed": [ "Permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries with string manipulation functions (LOWER, TRIM) to handle case-insensitivity and whitespace.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT p FROM Permission p WHERE LOWER(TRIM(BOTH FROM p.code)) = LOWER(TRIM(BOTH FROM ?1))\")\nPermission findOneByCode(@Param(\"code\") String code);" }, { "path": "org.apache.fineract.useradministration.domain", "mechanism": "SPRING-DATA", "name": "PasswordValidationPolicyRepository", "description": "The file uses Spring Data JPA repositories to interact with the database. It inherits standard CRUD methods and defines a custom JPQL query to filter entities based on their active status.", "databaseName": "unknown", "tablesAccessed": [ "PasswordValidationPolicy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "ORM QUERIES", "transactionHandling": "Spring @Transactional (implicit in JpaRepository)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"select PVP from PasswordValidationPolicy PVP WHERE PVP.active = true\")" }, { "path": "org.apache.fineract.useradministration.domain.AppUserRepository", "mechanism": "SPRING-DATA", "name": "AppUserRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database by extending JpaRepository, which provides standard CRUD operations, and defines custom query methods for specific data retrieval needs.", "databaseName": "unknown", "tablesAccessed": [ "AppUser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Uses JPQL via @Query annotation and Spring Data derived query methods.", "transactionHandling": "Spring @Transactional (implicit in Spring Data repositories)", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "@Query(\"Select appUser from AppUser appUser where appUser.username = :username\")\nAppUser findAppUserByName(@Param(\"username\") String username);" }, { "path": "org.apache.fineract.useradministration.domain.RoleRepository", "mechanism": "SPRING-DATA", "name": "RoleRepository", "description": "The file is a Spring Data JPA repository interface. It interacts with the database using the Java Persistence API (JPA) through Spring's abstraction layer. It defines custom queries using JPQL to access Role and AppUser tables.", "databaseName": "unknown", "tablesAccessed": [ "Role", "AppUser" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "JPQL queries involving joins and case-insensitive filtering.", "transactionHandling": "Spring @Transactional annotations (implicit in JpaRepository)", "protocol": "JDBC", "connectionInfo": "not identifiable from code", "codeExample": "@Query(\"SELECT COUNT(a) FROM AppUser a JOIN a.roles r WHERE r.id = :roleId AND a.deleted = false\")" }, { "path": "org.apache.fineract.useradministration.service", "mechanism": "SPRING-DATA", "name": "PermissionRepository", "description": "The class uses a Spring Data JPA repository (PermissionRepository) to interact with the database. It retrieves all permission entities and saves updates to specific permission entities.", "databaseName": "unknown", "tablesAccessed": [ "Permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findAll, saveAndFlush).", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "this.permissionRepository.saveAndFlush(permission);" }, { "path": "org.apache.fineract.useradministration.service", "mechanism": "SPRING-DATA", "name": "PasswordValidationPolicyRepository", "description": "The class uses a Spring Data JPA repository (`PasswordValidationPolicyRepository`) to interact with the database. It performs bulk reads and writes to manage the state of password validation policies.", "databaseName": "unknown", "tablesAccessed": [ "PasswordValidationPolicy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Simple CRUD operations involving finding all records and saving a collection of records.", "transactionHandling": "Spring @Transactional annotations", "protocol": "JPA/JDBC", "connectionInfo": "not identifiable from code", "codeExample": "final List validationPolicies = this.validationRepository.findAll();\n// ... logic ...\nthis.validationRepository.saveAll(validationPolicies);" }, { "path": "org.apache.fineract.useradministration.service.AppUserWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "AppUserRepository", "description": "The class uses Spring Data JPA repositories (AppUserRepository, OfficeRepositoryWrapper, RoleRepository, etc.) to interact with the database. It performs CRUD operations on AppUser entities and retrieves related entities like Office, Staff, and Role.", "databaseName": "unknown", "tablesAccessed": [ "AppUser", "Office", "Role", "Staff", "Client", "AppUserPreviousPassword" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard JPA repository methods (findById, save, saveAndFlush) and some custom finders (findByUserId).", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "not identifiable from code", "codeExample": "this.appUserRepository.saveAndFlush(userToUpdate);" }, { "path": "org.apache.fineract.useradministration.service.RoleWritePlatformServiceJpaRepositoryImpl", "mechanism": "SPRING-DATA", "name": "RoleRepository, PermissionRepository", "description": "The class uses Spring Data JPA repositories (RoleRepository, PermissionRepository) to persist and retrieve Role and Permission entities. It utilizes @Transactional for transaction management and handles DataIntegrityViolationException for constraint enforcement.", "databaseName": "unknown", "tablesAccessed": [ "Role", "Permission" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "Standard CRUD operations via JpaRepository methods (saveAndFlush, findById, delete, findAll) and a custom count query (getCountOfRolesAssociatedWithUsers).", "transactionHandling": "Spring @Transactional annotations on service methods.", "protocol": "JPA", "connectionInfo": "n/a", "codeExample": "final Role entity = Role.fromJson(command);\nthis.roleRepository.saveAndFlush(entity);" }, { "path": "org.apache.fineract.useradministration.service.UserDataValidator", "mechanism": "SPRING-DATA", "name": "PasswordValidationPolicyRepository", "description": "The class uses a Spring Data repository to fetch the active password validation policy from the database. This policy contains the regex pattern used to validate user passwords.", "databaseName": "unknown", "tablesAccessed": [ "PasswordValidationPolicy" ], "operationType": [ "READ" ], "queryPatterns": "Simple repository lookup to find the active policy.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "final PasswordValidationPolicy validationPolicy = this.passwordValidationPolicy.findActivePasswordValidationPolicy();\nfinal String regex = validationPolicy.getRegex();" }, { "path": "org.apache.fineract.useradministration.starter", "mechanism": "SPRING-DATA", "name": "UserAdministrationRepositories", "description": "The configuration class wires up database interactions by injecting Spring Data JPA repositories (e.g., AppUserRepository, RoleRepository) and the Spring JDBC Template into service implementations. The 'Read' services typically use JdbcTemplate for direct SQL queries, while 'Write' services use JPA Repositories for domain entity management.", "databaseName": "unknown", "tablesAccessed": [ "m_appuser", "m_role", "m_permission", "m_password_validation_policy" ], "operationType": [ "READ_WRITE" ], "queryPatterns": "The configuration enables both ORM-based CRUD operations (via JPA Repositories) and direct SQL read operations (via JdbcTemplate).", "transactionHandling": "Transaction handling is likely managed by the service implementations (e.g., @Transactional) which are instantiated here, rather than in this configuration class itself.", "protocol": "JDBC", "connectionInfo": "Configured via Spring Boot DataSource (not visible in this file)", "codeExample": "@Bean\npublic AppUserReadPlatformService appUserReadPlatformService(..., JdbcTemplate jdbcTemplate, ...) {\n return new AppUserReadPlatformServiceImpl(..., jdbcTemplate, ...);\n}" }, { "path": "fineract-db/multi-tenant-demo-backups/ceda/bk_ceda_trial.sql", "mechanism": "SQL", "name": "Mifos Tenant Database", "description": "The file is a MySQL database dump that utilizes standard SQL DDL to create the schema and DML to populate it. It defines a comprehensive relational model for a microfinance application (Mifos), including tables for clients, loans, savings, and system configuration. It uses InnoDB for transaction support and foreign key constraints.", "databaseName": "mifostenant-ceda", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "client additional data", "impact measurement", "loan additional data", "m_appuser", "m_appuser_role", "m_calendar", "m_calendar_instance", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_document", "m_fund", "m_group", "m_group_client", "m_group_level", "m_guarantor", "m_loan", "m_loan_arrears_aging", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_transaction", "m_savings_product", "m_staff", "r_enum_value", "rpt_sequence", "schema_version", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT operations, complex reporting queries stored in text fields", "transactionHandling": "LOCK TABLES/UNLOCK TABLES for bulk inserts", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(45) NOT NULL,\n `parent_id` BIGINT DEFAULT NULL,\n ...\n) ENGINE=InnoDB AUTO_INCREMENT=98 DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/mifospltaform-tenants-first-time-install.sql", "mechanism": "SQL", "name": "fineract_tenants initialization", "description": "The file is a raw SQL dump that performs direct database initialization using DDL to create schema structures and DML to populate initial data. It interacts directly with the MySQL server to set up the `fineract_tenants` database.", "databaseName": "fineract_tenants", "tablesAccessed": [ "schema_version", "tenants", "timezones" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT statements with bulk values, LOCK/UNLOCK TABLES", "transactionHandling": "Implicit transactions via LOCK TABLES and atomic INSERT statements", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `tenants` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `identifier` varchar(100) NOT NULL,\n `name` varchar(100) NOT NULL,\n ...\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/0001-mifos-platform-shared-tenants.sql", "mechanism": "SQL", "name": "fineract_tenants", "description": "The file is a raw MySQL dump script that integrates directly with the database server to initialize the schema and data. It combines Data Definition Language (DDL) to create the `tenants` and `timezones` tables and Data Manipulation Language (DML) to populate them with initial records. The script manages the database state by dropping existing objects and locking tables during write operations to ensure atomicity of the bulk inserts.", "databaseName": "fineract_tenants", "tablesAccessed": [ "tenants", "timezones" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT operations with bulk values, LOCK/UNLOCK TABLES for integrity", "transactionHandling": "Explicit LOCK TABLES and UNLOCK TABLES statements surround the INSERT operations", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `tenants` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `identifier` varchar(100) NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=UTF8MB4;\nINSERT INTO `tenants` VALUES (1,'default',...);" }, { "path": "fineract-db/multi-tenant-demo-backups/ceda/ceda-user-office-product-setup.sql", "mechanism": "SQL", "name": "Seed Data Script", "description": "The file integrates with the database by executing raw SQL statements directly against the schema. It functions as a data migration or seed script, utilizing DML operations to populate tables with initial configuration data. There is no application layer code; the integration is purely at the database command level. It handles relationships between entities manually through foreign key values in INSERT statements.", "databaseName": "mifos/fineract", "tablesAccessed": [ "m_organisation_currency", "m_appuser", "m_appuser_role", "m_office", "m_staff", "m_charge", "m_product_loan", "acc_product_mapping" ], "operationType": [ "WRITE" ], "queryPatterns": "Direct INSERT, UPDATE, and DELETE statements using hardcoded values.", "transactionHandling": "Implicit auto-commit or script-level transaction depending on the runner.", "protocol": "MySQL", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO `m_organisation_currency`\n(\n`code`,\n`decimal_places`,\n`name`,\n`display_symbol`,\n`internationalized_name_code`)\nVALUES\n('UGX', 2, 'Uganda Shilling', 'USh', 'currency.UGX');" }, { "path": "kubernetes/fineractmysql-configmap.yml", "mechanism": "SQL", "name": "MySQL Initialization Script", "description": "Database integration is achieved through a raw SQL script embedded in a Kubernetes ConfigMap, designed to be executed directly by the MySQL engine to bootstrap the database environment.", "databaseName": "fineract_tenants, fineract_default", "tablesAccessed": [], "operationType": [ "DDL", "ADMIN" ], "queryPatterns": "Database creation commands and user privilege granting statements.", "transactionHandling": "Implicit auto-commit typically used for initialization scripts.", "protocol": "MySQL", "connectionInfo": "n/a", "codeExample": "CREATE DATABASE IF NOT EXISTS `fineract_tenants`;\nCREATE DATABASE IF NOT EXISTS `fineract_default`;\nGRANT ALL ON *.* TO 'root'@'%';" }, { "path": "fineract-db/multi-tenant-demo-backups/bare-bones-demo/bk_bare_bones_demo.sql", "mechanism": "SQL", "name": "MySQL Database Dump", "description": "The file is a raw SQL dump that integrates with a MySQL database by executing DDL (Data Definition Language) to create the schema and DML (Data Manipulation Language) to populate it. It defines the entire database structure including tables, primary keys, and foreign key constraints. Additionally, it contains embedded SQL queries stored as strings within the `stretchy_report` and `stretchy_parameter` tables, which are used by the application's reporting engine to execute dynamic queries at runtime.", "databaseName": "fineract_default", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "client additional data", "extra_client_details", "extra_family_details", "extra_loan_details", "impact measurement", "loan additional data", "m_appuser", "m_appuser_role", "m_calendar", "m_calendar_instance", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_document", "m_fund", "m_group", "m_group_client", "m_group_level", "m_guarantor", "m_loan", "m_loan_arrears_aging", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_transaction", "m_savings_product", "m_staff", "r_enum_value", "rpt_sequence", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT INTO statements, and embedded SELECT queries stored in the stretchy_report table.", "transactionHandling": "Explicit LOCK TABLES and UNLOCK TABLES for bulk insert consistency.", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "DROP TABLE IF EXISTS `acc_gl_account`;\nCREATE TABLE `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(45) NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-provider/src/main/resources/sql/migrations/sample_data/load_sample_data.sql", "mechanism": "SQL", "name": "Mifos X / Apache Fineract Database Schema", "description": "The file is a raw SQL dump containing both Data Definition Language (DDL) for creating the database schema and Data Manipulation Language (DML) for seeding initial reference data. It is designed to be executed by a database migration tool (likely Flyway, given the 'schema_version' table) or manually imported into a MySQL database to initialize the persistence layer for the application.", "databaseName": "mifostenant-reference", "tablesAccessed": [ "acc_accounting_rule", "acc_gl_account", "acc_gl_closure", "acc_gl_financial_activity_account", "acc_gl_journal_entry", "acc_product_mapping", "acc_rule_tags", "c_account_number_format", "c_cache", "c_configuration", "c_external_service", "c_external_service_properties", "job", "job_run_history", "mix_taxonomy", "mix_taxonomy_mapping", "mix_xbrl_namespace", "m_account_transfer_details", "m_account_transfer_standing_instructions", "m_account_transfer_standing_instructions_history", "m_account_transfer_transaction", "m_address", "m_appuser", "m_appuser_previous_password", "m_appuser_role", "m_calendar", "m_calendar_history", "m_calendar_instance", "m_cashiers", "m_cashier_transactions", "m_charge", "m_client", "m_client_address", "m_client_attendance", "m_client_charge", "m_client_charge_paid_by", "m_client_identifier", "m_client_non_person", "m_client_transaction", "m_code", "m_code_value", "m_currency", "m_deposit_account_on_hold_transaction", "m_deposit_account_recurring_detail", "m_deposit_account_term_and_preclosure", "m_deposit_product_interest_rate_chart", "m_deposit_product_recurring_detail", "m_deposit_product_term_and_preclosure", "m_document", "m_entity_datatable_check", "m_entity_relation", "m_entity_to_entity_access", "m_entity_to_entity_mapping", "m_field_configuration", "m_floating_rates", "m_floating_rates_periods", "m_fund", "m_group", "m_group_client", "m_group_level", "m_group_roles", "m_guarantor", "m_guarantor_funding_details", "m_guarantor_transaction", "m_holiday", "m_holiday_office", "m_hook", "m_hook_configuration", "m_hook_registered_events", "m_hook_schema", "m_hook_templates", "m_image", "m_interest_incentives", "m_interest_rate_chart", "m_interest_rate_slab", "m_loan", "m_loanproduct_provisioning_entry", "m_loanproduct_provisioning_mapping", "m_loan_arrears_aging", "m_loan_charge", "m_loan_charge_paid_by", "m_loan_collateral", "m_loan_disbursement_detail", "m_loan_installment_charge", "m_loan_interest_recalculation_additional_details", "m_loan_officer_assignment_history", "m_loan_overdue_installment_charge", "m_loan_paid_in_advance", "m_loan_recalculation_details", "m_loan_repayment_schedule", "m_loan_repayment_schedule_history", "m_loan_reschedule_request", "m_loan_reschedule_request_term_variations_mapping", "m_loan_term_variations", "m_loan_topup", "m_loan_tranche_charges", "m_loan_tranche_disbursement_charge", "m_loan_transaction", "m_loan_transaction_repayment_schedule_mapping", "m_mandatory_savings_schedule", "m_meeting", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_password_validation_policy", "m_payment_detail", "m_payment_type", "m_permission", "m_portfolio_account_associations", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_product_loan_configurable_attributes", "m_product_loan_floating_rates", "m_product_loan_guarantee_details", "m_product_loan_recalculation_details", "m_product_loan_variable_installment_config", "m_product_loan_variations_borrower_cycle", "m_product_mix", "m_provisioning_criteria", "m_provisioning_criteria_definition", "m_provisioning_history", "m_provision_category", "m_report_mailing_job", "m_report_mailing_job_configuration", "m_report_mailing_job_run_history", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_charge", "m_savings_account_charge_paid_by", "m_savings_account_interest_rate_chart", "m_savings_account_interest_rate_slab", "m_savings_account_transaction", "m_savings_account_transaction_tax_details", "m_savings_interest_incentives", "m_savings_officer_assignment_history", "m_savings_product", "m_savings_product_charge", "m_selfservice_beneficiaries_tpt", "m_selfservice_user_client_mapping", "m_share_account", "m_share_account_charge", "m_share_account_charge_paid_by", "m_share_account_dividend_details", "m_share_account_transactions", "m_share_product", "m_share_product_charge", "m_share_product_dividend_pay_out", "m_share_product_market_price", "m_staff", "m_staff_assignment_history", "m_surveys", "m_survey_components", "m_survey_lookup_tables", "m_survey_questions", "m_survey_responses", "m_survey_scorecards", "m_tax_component", "m_tax_component_history", "m_tax_group", "m_tax_group_mappings", "m_tellers", "m_template", "m_templatemappers", "m_template_m_templatemappers", "m_working_days", "oauth_access_token", "oauth_client_details", "oauth_refresh_token", "ppi_likelihoods", "ppi_likelihoods_ppi", "ppi_scores", "rpt_sequence", "r_enum_value", "scheduler_detail", "schema_version", "sms_campaign", "sms_messages_outbound", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table", "x_table_column_code_mappings" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT statements for reference data", "transactionHandling": "Not explicitly defined in script, likely handled by the execution tool", "protocol": "MySQL 5.6+", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE IF NOT EXISTS `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(200) NOT NULL,\n `gl_code` varchar(45) NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/ceda/bk_core_with_custom_and_coa.sql", "mechanism": "SQL", "name": "Mifos Tenant Database (CEDA)", "description": "The file is a raw SQL dump containing both Data Definition Language (DDL) to create the schema and Data Manipulation Language (DML) to insert initial data. It defines a relational structure for a microfinance application. A unique integration feature is the 'stretchy_report' table, which stores full SQL SELECT statements as text data; the application reads these strings at runtime to execute dynamic reports against the database, effectively treating the database as a repository for its own reporting logic. The schema also includes a 'schema_version' table, indicating integration with a migration tool like Flyway.", "databaseName": "mifostenant-ceda", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "client additional data", "impact measurement", "loan additional data", "m_appuser", "m_appuser_role", "m_calendar", "m_calendar_instance", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_document", "m_fund", "m_group", "m_group_client", "m_group_level", "m_guarantor", "m_loan", "m_loan_arrears_aging", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_transaction", "m_savings_product", "m_staff", "r_enum_value", "rpt_sequence", "schema_version", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT INTO statements, and embedded SELECT queries stored within the 'stretchy_report' table for dynamic reporting.", "transactionHandling": "Uses explicit LOCK TABLES and UNLOCK TABLES commands to ensure data consistency during the dump restoration process.", "protocol": "MySQL 5.1.60", "codeExample": "CREATE TABLE `m_client` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `account_no` varchar(20) NOT NULL,\n `office_id` BIGINT NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-provider/src/main/resources/sql/migrations/sample_data/barebones_db.sql", "mechanism": "SQL", "description": "The file is a comprehensive SQL script that performs both Data Definition (DDL) and Data Manipulation (DML). It creates the entire database schema for the Fineract application, including tables for accounting, clients, loans, savings, and system configurations. It establishes relationships between these entities using foreign keys. Furthermore, it populates the database with initial reference data, such as permissions, roles, default configurations, and report definitions, using INSERT statements.", "databaseName": "fineract_default", "tablesAccessed": [ "acc_accounting_rule", "acc_gl_account", "acc_gl_journal_entry", "c_configuration", "job", "m_appuser", "m_client", "m_group", "m_loan", "m_loan_transaction", "m_office", "m_permission", "m_product_loan", "m_role", "m_savings_account", "m_staff", "stretchy_report", "schema_version" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT INTO statements, ALTER TABLE statements", "transactionHandling": "none", "protocol": "MySQL 5.6+", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE IF NOT EXISTS `m_client` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `account_no` varchar(20) NOT NULL,\n `office_id` BIGINT NOT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/bk_mifostenant_default.sql", "mechanism": "SQL", "name": "Fineract Database Schema", "description": "The file interacts with the database using raw SQL commands. It primarily uses Data Definition Language (DDL) to define the schema structure (tables, keys, constraints) and Data Manipulation Language (DML) to insert initial configuration data. The script is designed to be executed directly against a MySQL server to initialize the 'fineract_default' database.", "databaseName": "fineract_default", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "client additional data", "extra_client_details", "extra_family_details", "extra_loan_details", "impact measurement", "loan additional data", "m_appuser", "m_appuser_role", "m_calendar", "m_calendar_instance", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_document", "m_fund", "m_group", "m_group_client", "m_group_level", "m_guarantor", "m_loan", "m_loan_arrears_aging", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_transaction", "m_savings_product", "m_staff", "r_enum_value", "rpt_sequence", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT statements for seed data, ALTER TABLE for constraints", "transactionHandling": "Implicit transactions via LOCK TABLES / UNLOCK TABLES during data insertion", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(45) NOT NULL,\n `parent_id` BIGINT DEFAULT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB AUTO_INCREMENT=98 DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-db/multi-tenant-demo-backups/default-demo/bk_mifostenant-default.sql", "mechanism": "SQL", "name": "Fineract Database Schema", "description": "The file interacts with the database using raw SQL commands. It primarily uses Data Definition Language (DDL) to define the schema structure (tables, keys, constraints) and Data Manipulation Language (DML) to insert initial configuration data. The script is designed to be executed directly against a MySQL server to initialize the 'fineract_default' database.", "databaseName": "fineract_default", "tablesAccessed": [ "acc_gl_account", "acc_gl_closure", "acc_gl_journal_entry", "acc_product_mapping", "c_configuration", "client additional data", "extra_client_details", "extra_family_details", "extra_loan_details", "impact measurement", "loan additional data", "m_appuser", "m_appuser_role", "m_calendar", "m_calendar_instance", "m_charge", "m_client", "m_client_identifier", "m_code", "m_code_value", "m_currency", "m_document", "m_fund", "m_group", "m_group_client", "m_group_level", "m_guarantor", "m_loan", "m_loan_arrears_aging", "m_loan_charge", "m_loan_collateral", "m_loan_officer_assignment_history", "m_loan_repayment_schedule", "m_loan_transaction", "m_note", "m_office", "m_office_transaction", "m_organisation_currency", "m_permission", "m_portfolio_command_source", "m_product_loan", "m_product_loan_charge", "m_role", "m_role_permission", "m_savings_account", "m_savings_account_transaction", "m_savings_product", "m_staff", "r_enum_value", "rpt_sequence", "stretchy_parameter", "stretchy_report", "stretchy_report_parameter", "x_registered_table" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "CREATE TABLE statements, INSERT statements for seed data, ALTER TABLE for constraints", "transactionHandling": "Implicit transactions via LOCK TABLES / UNLOCK TABLES during data insertion", "protocol": "MySQL 5.1.60", "connectionInfo": "not applicable for SQL files", "codeExample": "CREATE TABLE `acc_gl_account` (\n `id` BIGINT NOT NULL AUTO_INCREMENT,\n `name` varchar(45) NOT NULL,\n `parent_id` BIGINT DEFAULT NULL,\n PRIMARY KEY (`id`)\n) ENGINE=InnoDB AUTO_INCREMENT=98 DEFAULT CHARSET=UTF8MB4;" }, { "path": "fineract-provider/src/main/resources/sql/migrations/sample_data/interop_sample_data.sql", "mechanism": "SQL", "name": "Financial System Configuration Script", "description": "The file interacts with the database purely through raw SQL scripts containing DML (Data Manipulation Language) operations. It uses SQL variables (e.g., @last_saving_prod_id) to maintain referential integrity across multiple INSERT statements without needing hardcoded IDs. It performs reads to determine current max IDs and writes to create new configuration entities.", "databaseName": "mifos_platform_tenants (inferred from table naming conventions)", "tablesAccessed": [ "m_savings_product", "m_payment_type", "acc_gl_account", "acc_product_mapping", "m_charge" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "The script uses SELECT statements to fetch current maximum IDs or specific reference IDs into variables, followed by INSERT statements that utilize these variables.", "transactionHandling": "Implicit transaction handling (script execution flow).", "protocol": "MySQL / MariaDB (inferred from syntax like @variable and concat)", "connectionInfo": "not applicable for SQL files", "codeExample": "SET @saving_prod_name = concat('Saving Product', @last_saving_prod_id);\nINSERT INTO `m_savings_product`\n(`name`, `short_name`, `description`, ...)\nVALUES (@saving_prod_name, concat('SP', @last_saving_prod_id), ...);" }, { "path": "fineract-db/multi-tenant-demo-backups/default-demo/README.md", "mechanism": "SQL", "name": "Demo Database Initialization", "description": "The documentation describes a database initialization process that involves running DDL for the latest schema and inserting mandatory reference data (DML). It specifies the creation of core entities required for the application to function.", "databaseName": "unknown", "tablesAccessed": [ "Currency", "Office", "Permission", "Role", "User" ], "operationType": [ "DDL", "WRITE" ], "queryPatterns": "Database schema creation and initial data seeding for deployment.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "n/a" }, { "path": "fineract-db/multi-tenant-demo-backups/ceda/ceda-schema-customisations.sql", "mechanism": "SQL", "name": "Database Initialization Script", "description": "The file interacts with the database via direct SQL execution, combining DDL for schema extensions and DML for data seeding. It creates new tables to store additional business data and populates configuration tables to integrate these extensions into the application framework.", "databaseName": "Mifos/Fineract Schema (implied)", "tablesAccessed": [ "m_code", "m_code_value", "client additional data", "m_client", "impact measurement", "m_loan", "loan additional data", "x_registered_table", "m_permission", "acc_gl_account" ], "operationType": [ "DDL", "WRITE", "READ" ], "queryPatterns": "CREATE TABLE with Foreign Keys, INSERT INTO ... VALUES, INSERT INTO ... SELECT, TRUNCATE TABLE", "transactionHandling": "Implicit (Auto-commit assumed for script execution)", "protocol": "MySQL / MariaDB (inferred from syntax like backticks and engine definition)", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO `m_code` (`code_name`, `is_system_defined`)\nVALUES\n('FieldOfEmployment', '0'),\n('EducationLevel', '0');\nCREATE TABLE `client additional data` (...);" }, { "path": "fineract-db/multi-tenant-demo-backups/default-demo/extra-datatables-and-code-values.sql", "mechanism": "SQL", "name": "Database Initialization Script", "description": "The file integrates with the database by directly executing raw SQL commands to modify both the schema and the data. It utilizes DDL to create new extension tables and DML to insert configuration data, register application metadata, and populate the general ledger.", "databaseName": "Mifos/Fineract (implied by table prefixes)", "tablesAccessed": [ "m_code", "m_code_value", "extra_client_details", "m_client", "extra_family_details", "extra_loan_details", "m_loan", "x_registered_table", "m_permission", "acc_gl_account" ], "operationType": [ "READ", "WRITE", "DDL", "ADMIN" ], "queryPatterns": "The script uses INSERT INTO ... SELECT patterns for dynamic data population, standard CREATE TABLE statements for schema definition, and bulk INSERT statements for static data loading.", "transactionHandling": "Implicit transaction handling per statement (auto-commit) is typical for such scripts, though not explicitly defined.", "protocol": "MySQL / MariaDB (inferred from syntax like `ifnull`, backticks, and ENGINE=InnoDB)", "connectionInfo": "not applicable for SQL files", "codeExample": "INSERT INTO `m_code_value`(`code_id`,`code_value`,`order_position`)\nselect mc.id, 'option.Male', ifnull(max(mv.id), 1)\nfrom m_code mc\njoin m_code_value mv on mv.code_id = mc.id\nwhere mc.`code_name` = \"Gender\";" }, { "path": "fineract-provider/src/main/resources/sql/migrations/sample_data/tn04_interop_sample_data.sql", "mechanism": "SQL", "name": "Data Initialization Script", "description": "The code is a direct SQL script used for data manipulation and initialization. It interacts directly with the database engine to insert records and query existing data to resolve foreign keys. It uses MySQL-specific variable syntax to pass data between statements within the script execution session.", "databaseName": "tn04", "tablesAccessed": [ "m_client", "m_savings_product", "m_savings_account", "interop_identifier", "m_charge", "m_savings_account_charge" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "The script uses a pattern of setting variables, performing INSERTs, and using SELECT ... INTO @variable to resolve foreign keys for subsequent INSERTs.", "transactionHandling": "Implicit transaction handling (relies on the session's auto-commit settings or external transaction wrapping).", "protocol": "MySQL / MariaDB", "connectionInfo": "not applicable for SQL files", "codeExample": "SET @client_name = 'InteropMerchant';\nINSERT INTO `m_client` (`account_no`, ... ) VALUES (@saving_account_no, ...);\nSET @saving_prod_id = -1;\nSELECT id FROM m_savings_product WHERE name = @saving_prod_name INTO @saving_prod_id;\nINSERT INTO `m_savings_account` ... VALUES ...;" }, { "path": "org.apache.fineract.commands.api.AuditsApiResource", "mechanism": "SQL", "name": "AuditReadPlatformService", "description": "The class constructs SQL fragments using a `SQLBuilder` utility class. While it does not execute the query directly (delegating that to the service layer), it explicitly defines the SQL WHERE clauses and column aliases (e.g., 'aud.action_name', 'aud.entity_name') used to query the database.", "databaseName": "unknown", "tablesAccessed": [ "aud" ], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation based on optional filter parameters.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "not identifiable from code", "codeExample": "extraCriteria.addNonNullCriteria(\"aud.action_name = \", actionName);\nif (entityName != null) {\n extraCriteria.addCriteria(\"aud.entity_name like\", entityName + \"%\");\n}\nextraCriteria.addNonNullCriteria(\"aud.resource_id = \", resourceId);" }, { "path": "org.apache.fineract.commands.api.MakercheckersApiResource", "mechanism": "SQL", "name": "AuditReadPlatformService / SQLBuilder", "description": "The class constructs dynamic SQL WHERE clauses using a `SQLBuilder` utility. It references specific database columns (aliased with 'aud.') corresponding to the audit/command source table. These criteria are passed to the service layer for execution.", "databaseName": "unknown", "tablesAccessed": [ "aud (alias for audit table)" ], "operationType": [ "READ", "WRITE" ], "queryPatterns": "Dynamic SQL generation for filtering audit entries based on multiple optional criteria.", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "unknown", "codeExample": "SQLBuilder extraCriteria = new SQLBuilder();\nextraCriteria.addNonNullCriteria(\"aud.action_name = \", actionName);\nif (entityName != null) {\n extraCriteria.addCriteria(\"aud.entity_name like \", entityName + \"%\");\n}\nextraCriteria.addNonNullCriteria(\"aud.resource_id = \", resourceId);" }, { "path": "org.apache.fineract.infrastructure.core.data.PaginationParameters", "mechanism": "SQL", "name": "PaginationParameters", "description": "This class is responsible for dynamically generating SQL fragments for 'ORDER BY', 'LIMIT', and 'OFFSET' clauses. It does not execute queries directly but prepares safe, validated SQL strings to be appended to database queries in other components. It explicitly validates input using 'SQLInjectionValidator' to prevent SQL injection.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation for pagination and sorting", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "sql.append(\" limit \").append(this.getLimit());" }, { "path": "org.apache.fineract.infrastructure.core.service.database", "mechanism": "SQL", "name": "DatabaseSpecificSQLGenerator", "description": "This class is a helper for generating raw SQL strings compatible with either MySQL or PostgreSQL. It does not execute queries itself but constructs valid SQL syntax for other components to execute via JDBC.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ", "WRITE", "READ_WRITE" ], "queryPatterns": "Dynamic SQL generation including SELECT, INSERT, UPDATE, JOINs, and dialect-specific function calls.", "transactionHandling": "none", "protocol": "MySQL or PostgreSQL", "connectionInfo": "n/a", "codeExample": "if (databaseTypeResolver.isMySQL()) {\n return format(\"LIMIT %s,%s\", offset, count);\n} else if (databaseTypeResolver.isPostgreSQL()) {\n return format(\"LIMIT %s OFFSET %s\", count, offset);\n}" }, { "path": "org.apache.fineract.infrastructure.core.service.database.SqlOperator", "mechanism": "SQL", "name": "SqlOperator", "description": "This class is a utility for generating SQL WHERE clause fragments. It does not execute queries itself but constructs SQL strings representing comparisons (e.g., 'col = val', 'col LIKE %val%') used by other data access components.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "OTHER" ], "queryPatterns": "Dynamic SQL generation for filtering criteria", "transactionHandling": "none", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "return format(\"%s %s %s\", definition, getSymbol(), sqlGenerator.formatValue(columnType, \"%\" + values[0] + \"%\"));" }, { "path": "org.apache.fineract.infrastructure.dataqueries.service", "mechanism": "SQL", "name": "GenericDataService", "description": "The interface explicitly defines methods for executing raw SQL strings passed as arguments. It acts as a direct gateway for dynamic SQL execution against the database.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL queries passed as strings", "transactionHandling": "unknown", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "GenericResultsetData fillGenericResultSet(String sql);" }, { "path": "org.apache.fineract.infrastructure.security.utils", "mechanism": "SQL", "name": "SQLBuilder", "description": "This class is a utility for dynamically constructing SQL WHERE clauses. While it does not execute queries directly, it generates SQL strings and manages parameters for use with JDBC PreparedStatements or Spring JdbcTemplate.", "databaseName": "unknown", "tablesAccessed": [], "operationType": [ "READ" ], "queryPatterns": "Dynamic SQL generation for filtering criteria", "transactionHandling": "none", "protocol": "JDBC", "connectionInfo": "n/a", "codeExample": "sb.append(trimmedCriteria);\nsb.append(\" ?\");\ncrts.add(trimmedCriteria);\nargs.add(argument);" }, { "path": "org.apache.fineract.infrastructure.survey.service", "mechanism": "SQL", "name": "ReadWriteNonCoreDataService", "description": "The class interacts with the database primarily by constructing raw SQL strings for permission management and delegating execution to 'ReadWriteNonCoreDataService'. It manually builds INSERT statements for the 'm_permission' table.", "databaseName": "unknown", "tablesAccessed": [ "m_permission" ], "operationType": [ "WRITE" ], "queryPatterns": "Inline SQL string construction for INSERT statements.", "transactionHandling": "Spring @Transactional annotations", "protocol": "unknown", "connectionInfo": "n/a", "codeExample": "return \"insert into m_permission (\" + columns + \") values \" + \"('datatable', \" + createPermission + \", 'CREATE', '\" + dataTableName\n + \"', false),\" + \"('datatable', \" + createPermissionChecker + \", 'CREATE', '\" + dataTableName + \"', false),\"" } ], "procsAndTriggers": { "procs": { "total": 0, "low": 0, "medium": 0, "high": 0, "list": [] }, "trigs": { "total": 0, "low": 0, "medium": 0, "high": 0, "list": [] } }, "integrationPoints": [ { "namespace": "com.acme.fineract.loan.job", "filepath": "custom/acme/loan/job/src/main/java/com/acme/fineract/loan/job/AcmeNoopJobConfiguration.java", "mechanism": "OTHER", "name": "ACME_NOOP_JOB", "description": "Defines a Spring Batch Job that can be triggered by a scheduler or API.", "direction": "BOTH" }, { "namespace": "org.apache.fineract", "filepath": "fineract-provider/src/main/java/org/apache/fineract/ServerApplication.java", "mechanism": "REST", "name": "Embedded Tomcat Server", "description": "Bootstraps the embedded HTTP server (Tomcat) to host the Fineract REST APIs.", "path": "/", "method": "N/A", "direction": "BOTH", "protocol": "HTTP", "connectionInfo": "Embedded Container" }, { "namespace": "org.apache.fineract.accounting.accrual.api.AccrualAccountingApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/accrual/api/AccrualAccountingApiResource.java", "mechanism": "REST", "name": "executePeriodicAccrualAccounting", "description": "Endpoint to execute Periodic Accrual Accounting", "path": "/v1/runaccruals", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload (AccrualAccountingApiResourceSwagger.PostRunaccrualsRequest)", "responseBody": "JSON (CommandProcessingResult)" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResource.java", "mechanism": "REST", "name": "List Accounting Closures", "description": "Endpoint to retrieve a list of accounting closures.", "path": "/v1/glclosures", "method": "GET", "responseBody": "List" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResource.java", "mechanism": "REST", "name": "Retrieve Accounting Closure", "description": "Endpoint to retrieve a specific accounting closure by ID.", "path": "/v1/glclosures/{glClosureId}", "method": "GET", "responseBody": "GLClosureData" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResource.java", "mechanism": "REST", "name": "Create Accounting Closure", "description": "Endpoint to create a new accounting closure.", "path": "/v1/glclosures", "method": "POST", "requestBody": "JSON payload with officeId and closingDate", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResource.java", "mechanism": "REST", "name": "Update Accounting Closure", "description": "Endpoint to update an existing accounting closure.", "path": "/v1/glclosures/{glClosureId}", "method": "PUT", "requestBody": "JSON payload with updates (e.g., comments)", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResource.java", "mechanism": "REST", "name": "Delete Accounting Closure", "description": "Endpoint to delete an accounting closure.", "path": "/v1/glclosures/{glClosureId}", "method": "DELETE", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.accounting.closure.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/closure/api/GLClosuresApiResourceSwagger.java", "mechanism": "REST", "name": "GL Closures API Schemas", "description": "Defines the Swagger/OpenAPI schemas (Request and Response bodies) for the General Ledger Closures REST API endpoints.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.accounting.financialactivityaccount.api.FinancialActivityAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/financialactivityaccount/api/FinancialActivityAccountsApiResource.java", "mechanism": "REST", "name": "Financial Activity Accounts API", "description": "API for managing mappings between Financial Activities and GL Accounts.", "path": "/v1/financialactivityaccounts", "method": "GET, POST, PUT, DELETE", "authentication": "PlatformSecurityContext (Internal Fineract Auth)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve GL Accounts Template", "description": "Endpoint to retrieve a template for creating new GL accounts.", "path": "/v1/glaccounts/template", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing default values and dropdown options" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "List General Ledger Accounts", "description": "Endpoint to list all GL accounts with optional filtering.", "path": "/v1/glaccounts", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of GLAccountData" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve a General Ledger Account", "description": "Endpoint to retrieve a single GL account by ID.", "path": "/v1/glaccounts/{glAccountId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object of GLAccountData" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Create a General Ledger Account", "description": "Endpoint to create a new GL account.", "path": "/v1/glaccounts", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object defining the new account", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Update a GL Account", "description": "Endpoint to update an existing GL account.", "path": "/v1/glaccounts/{glAccountId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with updates", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Delete a GL Account", "description": "Endpoint to delete a GL account.", "path": "/v1/glaccounts/{glAccountId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Download GL Accounts Template", "description": "Endpoint to download an Excel template for bulk import.", "path": "/v1/glaccounts/downloadtemplate", "method": "GET", "direction": "PRODUCER", "responseBody": "application/vnd.ms-excel file stream" }, { "namespace": "org.apache.fineract.accounting.glaccount.api.GLAccountsApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/api/GLAccountsApiResource.java", "mechanism": "REST", "name": "Upload GL Accounts Template", "description": "Endpoint to upload an Excel file for bulk import.", "path": "/v1/glaccounts/uploadtemplate", "method": "POST", "direction": "PRODUCER", "requestBody": "Multipart form data containing the file", "responseBody": "JSON object with import document ID" }, { "namespace": "org.apache.fineract.accounting.glaccount.handler", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/handler/CreateGLAccountCommandHandler.java", "mechanism": "OTHER", "name": "GLACCOUNT CREATE Command Handler", "description": "Registers a handler for the CREATE action on the GLACCOUNT entity within the application's command processing framework.", "path": "GLACCOUNT (Entity), CREATE (Action)", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.accounting.glaccount.serialization.GLAccountCommandFromApiJsonDeserializer", "filepath": "fineract-core/src/main/java/org/apache/fineract/accounting/glaccount/serialization/GLAccountCommandFromApiJsonDeserializer.java", "mechanism": "REST", "name": "GL Account Command Deserialization", "description": "Deserializes JSON payloads for GL Account management APIs.", "direction": "CONSUMER", "requestBody": "JSON object containing GL Account details (name, glCode, type, usage, etc.)" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "List Journal Entries", "path": "/v1/journalentries", "method": "GET", "responseBody": "JSON array of JournalEntryData" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "retrieveJournalEntryById", "description": "Retrieve a single Entry", "path": "/v1/journalentries/{journalEntryId}", "method": "GET", "responseBody": "JournalEntryData JSON" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "createGLJournalEntry", "description": "Create Balanced Journal Entries", "path": "/v1/journalentries", "method": "POST", "requestBody": "JournalEntryCommand JSON", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "createReversalJournalEntry", "description": "Update Running balances or Reverse Journal Entries", "path": "/v1/journalentries/{transactionId}", "method": "POST", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "retrieveJournalEntries", "description": "Retrieve Provisioning Journal Entries", "path": "/v1/journalentries/provisioning", "method": "GET", "responseBody": "JSON array of JournalEntryData" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "retrieveOpeningBalance", "description": "Retrieve Opening Balance", "path": "/v1/journalentries/openingbalance", "method": "GET", "responseBody": "OfficeOpeningBalancesData JSON" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "getJournalEntriesTemplate", "description": "Download Template", "path": "/v1/journalentries/downloadtemplate", "method": "GET", "responseBody": "Excel File (application/vnd.ms-excel)" }, { "namespace": "org.apache.fineract.accounting.journalentry.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/api/JournalEntriesApiResource.java", "mechanism": "REST", "name": "postJournalEntriesTemplate", "description": "Upload Template", "path": "/v1/journalentries/uploadtemplate", "method": "POST", "requestBody": "Multipart Form Data (File)", "responseBody": "Import Document ID JSON" }, { "namespace": "org.apache.fineract.accounting.journalentry.service.AccountingProcessorHelper", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/service/AccountingProcessorHelper.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Internal event notification system used to publish business events when specific actions occur.", "direction": "PRODUCER", "protocol": "Java Method Call / Observer Pattern" }, { "namespace": "org.apache.fineract.accounting.provisioning.api.ProvisioningEntriesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/provisioning/api/ProvisioningEntriesApiResource.java", "mechanism": "REST", "name": "Create Provisioning Entries", "description": "Endpoint to create new provisioning entries.", "path": "/v1/provisioningentries", "method": "POST", "requestBody": "JSON payload defined by ProvisioningEntriesApiResourceSwagger.PostProvisioningEntriesRequest", "responseBody": "JSON result of the command processing", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.provisioning.api.ProvisioningEntriesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/provisioning/api/ProvisioningEntriesApiResource.java", "mechanism": "REST", "name": "Modify Provisioning Entry", "description": "Endpoint to recreate a provisioning entry or create journal entries for it.", "path": "/v1/provisioningentries/{entryId}", "method": "POST", "requestBody": "JSON payload defined by ProvisioningEntriesApiResourceSwagger.PutProvisioningEntriesRequest", "responseBody": "JSON result of the command processing", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.provisioning.api.ProvisioningEntriesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/provisioning/api/ProvisioningEntriesApiResource.java", "mechanism": "REST", "name": "Retrieve Provisioning Entry", "description": "Endpoint to retrieve a specific provisioning entry by ID.", "path": "/v1/provisioningentries/{entryId}", "method": "GET", "responseBody": "ProvisioningEntryData JSON", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.provisioning.api.ProvisioningEntriesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/provisioning/api/ProvisioningEntriesApiResource.java", "mechanism": "REST", "name": "Retrieve Provisioning Entries (Search)", "description": "Endpoint to search for loan product provisioning entries with filters.", "path": "/v1/provisioningentries/entries", "method": "GET", "responseBody": "Page JSON", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.provisioning.api.ProvisioningEntriesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/provisioning/api/ProvisioningEntriesApiResource.java", "mechanism": "REST", "name": "List All Provisioning Entries", "description": "Endpoint to list all provisioning entries with pagination.", "path": "/v1/provisioningentries", "method": "GET", "responseBody": "Page JSON", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.accounting.rule.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResourceSwagger.java", "mechanism": "REST", "name": "Accounting Rules API Schemas", "description": "Defines the Swagger/OpenAPI schemas for the Accounting Rules REST API requests and responses.", "path": "n/a", "method": "n/a", "direction": "BOTH" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "retrieveTemplate", "description": "Retrieve Accounting Rule Details Template", "path": "/v1/accountingrules/template", "method": "GET", "responseBody": "JSON object containing default values and allowed options (offices, accounts, tags)" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "retrieveAllAccountingRules", "description": "Retrieve all Accounting Rules", "path": "/v1/accountingrules", "method": "GET", "responseBody": "JSON array of accounting rules" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "retreiveAccountingRule", "description": "Retrieve a specific Accounting Rule", "path": "/v1/accountingrules/{accountingRuleId}", "method": "GET", "responseBody": "JSON object representing the accounting rule" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "createAccountingRule", "description": "Create a new Accounting Rule", "path": "/v1/accountingrules", "method": "POST", "requestBody": "JSON object with rule details (name, officeId, accounts/tags)", "responseBody": "JSON object with command processing result (resourceId)" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "updateAccountingRule", "description": "Update an existing Accounting Rule", "path": "/v1/accountingrules/{accountingRuleId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.accounting.rule.api.AccountingRuleApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/api/AccountingRuleApiResource.java", "mechanism": "REST", "name": "deleteAccountingRule", "description": "Delete an Accounting Rule", "path": "/v1/accountingrules/{accountingRuleId}", "method": "DELETE", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.accounting.rule.handler.UpdateAccountingRuleCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/accounting/rule/handler/UpdateAccountingRuleCommandHandler.java", "mechanism": "OTHER", "name": "ACCOUNTINGRULE UPDATE Command Handler", "description": "Registers a handler for the internal command processing bus to handle UPDATE actions on ACCOUNTINGRULE entities.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Retrieves all adhoc queries", "path": "/v1/adhocquery", "method": "GET", "responseBody": "JSON array of AdHocData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "template", "description": "Retrieves adhoc query template", "path": "/v1/adhocquery/template", "method": "GET", "responseBody": "JSON object of AdHocData template", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "createAdHocQuery", "description": "Creates a new adhoc query", "path": "/v1/adhocquery", "method": "POST", "requestBody": "JSON object defining the adhoc query", "responseBody": "JSON object of CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "retrieveAdHocQuery", "description": "Retrieves a specific adhoc query by ID", "path": "/v1/adhocquery/{adHocId}", "method": "GET", "responseBody": "JSON object of AdHocData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "update", "description": "Updates a specific adhoc query", "path": "/v1/adhocquery/{adHocId}", "method": "PUT", "requestBody": "JSON object with updates", "responseBody": "JSON object of CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/api/AdHocApiResource.java", "mechanism": "REST", "name": "deleteAdHocQuery", "description": "Deletes a specific adhoc query", "path": "/v1/adhocquery/{adHocId}", "method": "DELETE", "responseBody": "JSON object of CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.adhocquery.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/adhocquery/handler/UpdateAdHocCommandHandler.java", "mechanism": "OTHER", "name": "ADHOC UPDATE Command Handler", "description": "Registers this class as the handler for ADHOC entity UPDATE actions within the Fineract command processing framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.api.BatchApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/api/BatchApiResource.java", "mechanism": "REST", "name": "handleBatchRequests", "description": "Batch API endpoint allowing multiple API requests to be sent in a single payload.", "path": "/v1/batches", "method": "POST", "requestBody": "Array of BatchRequest objects (JSON)", "responseBody": "Array of BatchResponse objects (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "createClient", "description": "Maps POST requests for clients to the createClientCommandStrategy.", "path": "v1/clients", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "updateClient", "description": "Maps PUT requests for specific clients to the updateClientCommandStrategy.", "path": "v1/clients/{id}", "method": "PUT", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "applyLoan", "description": "Maps POST requests for loans to the applyLoanCommandStrategy.", "path": "v1/loans", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "getLoanById", "description": "Maps GET requests for loans by ID to the getLoanByIdCommandStrategy.", "path": "v1/loans/{id}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "applySavings", "description": "Maps POST requests for savings accounts to the applySavingsCommandStrategy.", "path": "v1/savingsaccounts", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "approveLoan", "description": "Maps POST requests with command=approve to the approveLoanCommandStrategy.", "path": "v1/loans/{id}?command=approve", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "disburseLoan", "description": "Maps POST requests with command=disburse to the disburseLoanCommandStrategy.", "path": "v1/loans/{id}?command=disburse", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "activateClient", "description": "Maps POST requests with command=activate to the activateClientCommandStrategy.", "path": "v1/clients/{id}?command=activate", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.CommandStrategyProvider", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/command/CommandStrategyProvider.java", "mechanism": "REST", "name": "createDatatableEntry", "description": "Maps POST requests for datatables to the createDatatableEntryCommandStrategy.", "path": "v1/datatables/{table}/{appTableId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/test/java/org/apache/fineract/batch/command/internal/GetLoanTransactionByIdCommandStrategyTest.java", "mechanism": "REST", "name": "Get Loan Transaction", "description": "The code tests a strategy that wraps a RESTful resource call to retrieve loan transaction details.", "path": "loans/{loanId}/transactions/{transactionId}", "method": "GET", "direction": "CONSUMER", "requestBody": "None (GET request)", "responseBody": "JSON object containing loan transaction details (id, office, type, date, currency, amount, etc.)" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/test/java/org/apache/fineract/batch/command/internal/CollectChargesByLoanExternalIdCommandStrategyTest.java", "mechanism": "REST", "name": "retrieveAllLoanCharges", "description": "The test simulates a REST call to retrieve loan charges via the LoanChargesApiResource.", "path": "loans/external-id/{loanExternalId}/charges", "method": "GET", "direction": "CONSUMER", "requestBody": "{}", "responseBody": "JSON string representing loan charges" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/test/java/org/apache/fineract/batch/command/internal/CreateChargeByLoanExternalIdCommandStrategyTest.java", "mechanism": "REST", "name": "Create Loan Charge via External ID", "description": "The test simulates a REST API call to create a charge for a loan identified by an external ID.", "path": "loans/external-id/{loanExternalId}/charges", "method": "POST", "direction": "CONSUMER", "requestBody": "{}", "responseBody": "myResponseBody" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/test/java/org/apache/fineract/batch/command/internal/CreateTransactionByLoanExternalIdCommandStrategyTest.java", "mechanism": "REST", "name": "Loan Transactions API", "description": "The test simulates a RESTful batch request to create a loan transaction via an external ID.", "path": "loans/external-id/{loanExternalId}/transactions", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (empty object in test)", "responseBody": "String (mocked response body)" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/main/java/org/apache/fineract/batch/command/internal/AdjustChargeByChargeExternalIdCommandStrategy.java", "mechanism": "REST", "name": "Loan Charge Adjustment (Batch)", "description": "Handles batch requests for adjusting loan charges via a REST-like URL pattern.", "path": "loans/external-id/{loanExternalId}/charges/external-id/{chargeExternalId}?command={command}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/main/java/org/apache/fineract/batch/command/internal/AdjustLoanTransactionByExternalIdCommandStrategy.java", "mechanism": "REST", "name": "Adjust Loan Transaction (Batch)", "description": "Handles the batch processing logic for adjusting a loan transaction identified by an external ID.", "path": "loans/external-id/{loanExternalId}/transactions/external-id/{transactionExternalId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON body containing transaction adjustment details", "responseBody": "JSON response from the adjustment operation" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/main/java/org/apache/fineract/batch/command/internal/ModifyLoanApplicationByExternalIdCommandStrategy.java", "mechanism": "REST", "name": "modifyLoanApplication", "description": "Delegates a batch command to the internal LoansApiResource to modify a loan application.", "path": "loans/external-id/{externalId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON body containing loan modification details", "responseBody": "JSON response from the LoansApiResource" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/main/java/org/apache/fineract/batch/command/internal/AdjustLoanTransactionCommandStrategy.java", "mechanism": "REST", "name": "adjustLoanTransaction", "description": "Delegates to the internal LoanTransactionsApiResource to adjust a transaction, effectively acting as a wrapper for the REST API logic within a batch context.", "path": "/loans/{loanId}/transactions/{transactionId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.command.internal", "filepath": "fineract-provider/src/main/java/org/apache/fineract/batch/command/internal/CollectChargesCommandStrategy.java", "mechanism": "REST", "name": "retrieveAllLoanCharges", "description": "Delegates to an internal REST API resource to retrieve charges for a loan.", "path": "/loans/{loanId}/charges", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.batch.exception.ErrorHandler", "filepath": "fineract-core/src/main/java/org/apache/fineract/batch/exception/ErrorHandler.java", "mechanism": "REST", "name": "JAX-RS Exception Mapping", "description": "Uses JAX-RS standard interfaces to map Java exceptions to HTTP responses.", "path": "n/a", "method": "n/a", "direction": "OTHER", "requestBody": "n/a", "responseBody": "JSON ErrorInfo", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "createDocument", "description": "Uploads a document via Multipart POST", "path": "v1/{entityType}/{entityId}/documents", "method": "POST", "requestBody": "Multipart (File, Name, Description)", "responseBody": "PostEntityTypeEntityIdDocumentsResponse" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "deleteDocument", "description": "Deletes a document", "path": "v1/{entityType}/{entityId}/documents/{documentId}", "method": "DELETE", "responseBody": "DeleteEntityTypeEntityIdDocumentsResponse" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "downloadFile", "description": "Downloads a document attachment", "path": "v1/{entityType}/{entityId}/documents/{documentId}/attachment", "method": "GET", "responseBody": "Binary File (ResponseBody)" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "getDocument", "description": "Retrieves document metadata", "path": "v1/{entityType}/{entityId}/documents/{documentId}", "method": "GET", "responseBody": "GetEntityTypeEntityIdDocumentsResponse" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "retrieveAllDocuments", "description": "Lists all documents for an entity", "path": "v1/{entityType}/{entityId}/documents", "method": "GET", "responseBody": "List" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/DocumentsApiFixed.java", "mechanism": "REST", "name": "updateDocument", "description": "Updates a document via Multipart PUT", "path": "v1/{entityType}/{entityId}/documents/{documentId}", "method": "PUT", "requestBody": "Multipart (File, Name, Description)", "responseBody": "PutEntityTypeEntityIdDocumentsResponse" }, { "namespace": "org.apache.fineract.client.services", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/RunReportsApi.java", "mechanism": "REST", "name": "Run Reports Endpoint", "description": "Client-side definition for consuming the Fineract Run Reports REST API.", "path": "v1/runreports/{reportName}", "method": "GET", "direction": "CONSUMER", "requestBody": "None (GET request)", "responseBody": "JSON (RunReportsResponse) or Binary Stream (ResponseBody)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.client.services.ImagesApi", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/ImagesApi.java", "mechanism": "REST", "name": "Create Image", "description": "Uploads a new image for an entity via Retrofit client.", "path": "v1/{entityType}/{entityId}/images", "method": "POST", "direction": "PRODUCER", "requestBody": "Multipart file" }, { "namespace": "org.apache.fineract.client.services.ImagesApi", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/ImagesApi.java", "mechanism": "REST", "name": "Get Image", "description": "Retrieves an image for an entity via Retrofit client.", "path": "v1/{entityType}/{entityId}/images", "method": "GET", "direction": "CONSUMER", "responseBody": "Binary image data (ResponseBody)" }, { "namespace": "org.apache.fineract.client.services.ImagesApi", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/ImagesApi.java", "mechanism": "REST", "name": "Update Image", "description": "Updates an existing image for an entity via Retrofit client.", "path": "v1/{entityType}/{entityId}/images", "method": "PUT", "direction": "PRODUCER", "requestBody": "Multipart file" }, { "namespace": "org.apache.fineract.client.services.ImagesApi", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/services/ImagesApi.java", "mechanism": "REST", "name": "Delete Image", "description": "Deletes an image for an entity via Retrofit client.", "path": "v1/{entityType}/{entityId}/images", "method": "DELETE", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.client.test.FineractClientDemo", "filepath": "fineract-client/src/test/java/org/apache/fineract/client/test/FineractClientDemo.java", "mechanism": "REST", "name": "Fineract API Client", "description": "Consumes the Fineract REST API to retrieve staff data using the generated FineractClient.", "path": "/fineract-provider/api/v1/", "method": "GET", "direction": "CONSUMER", "authentication": "Basic Auth", "connectionInfo": "https://demo.fineract.dev/fineract-provider/api/v1/" }, { "namespace": "org.apache.fineract.client.test.FineractClientTechnicalTest", "filepath": "fineract-client/src/test/java/org/apache/fineract/client/test/FineractClientTechnicalTest.java", "mechanism": "REST", "name": "FineractClient", "description": "The code configures a REST client SDK for the Fineract platform.", "path": "http://test/", "method": "UNKNOWN", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "http://test/" }, { "namespace": "org.apache.fineract.client.util", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/util/Parts.java", "mechanism": "REST", "name": "Multipart Body Factory", "description": "Helper utility to create OkHttp MultipartBody.Part objects for file uploads in REST clients.", "direction": "PRODUCER", "requestBody": "Multipart/form-data", "protocol": "HTTP/Multipart" }, { "namespace": "org.apache.fineract.client.util", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/util/Calls.java", "mechanism": "REST", "name": "Retrofit Client Execution", "description": "Executes HTTP REST calls using the Retrofit library.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined by the Retrofit Call object passed to the methods" }, { "namespace": "org.apache.fineract.client.util.CallFailedRuntimeException", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/util/CallFailedRuntimeException.java", "mechanism": "REST", "name": "Retrofit Client Error Handling", "description": "This class acts as a wrapper for errors occurring during HTTP interactions performed by the Retrofit client library.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.client.util.FineractClient", "filepath": "fineract-client/src/main/java/org/apache/fineract/client/util/FineractClient.java", "mechanism": "REST", "name": "Fineract Platform API", "description": "Consumes the Fineract Platform REST APIs via Retrofit interfaces.", "direction": "CONSUMER", "authentication": "Basic Auth, API Key (Tenant ID)", "protocol": "HTTP/1.1", "connectionInfo": "Configurable via Builder.baseURL()" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/ConfigureBusinessStepApiResource.java", "mechanism": "REST", "name": "retrieveAllConfiguredBusinessJobs", "description": "Endpoint to retrieve all configured business job names.", "path": "/v1/jobs/names", "method": "GET", "responseBody": "JSON array of job names (ConfiguredJobNamesDTO)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/ConfigureBusinessStepApiResource.java", "mechanism": "REST", "name": "retrieveAllConfiguredBusinessStep", "description": "Endpoint to retrieve business steps for a specific job.", "path": "/v1/jobs/{jobName}/steps", "method": "GET", "responseBody": "JSON object containing job name and business steps (JobBusinessStepConfigData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/ConfigureBusinessStepApiResource.java", "mechanism": "REST", "name": "updateJobBusinessStepConfig", "description": "Endpoint to update business step configuration for a job.", "path": "/v1/jobs/{jobName}/steps", "method": "PUT", "requestBody": "JSON object defining the new business step configuration", "responseBody": "204 No Content", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/ConfigureBusinessStepApiResource.java", "mechanism": "REST", "name": "retrieveAllAvailableBusinessStep", "description": "Endpoint to retrieve available business steps for a specific job.", "path": "/v1/jobs/{jobName}/available-steps", "method": "GET", "responseBody": "JSON object containing job name and available business steps (JobBusinessStepDetail)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/LoanCOBCatchUpApiResource.java", "mechanism": "REST", "name": "getOldestCOBProcessedLoan", "description": "Retrieves the oldest COB processed loan", "path": "/v1/loans/oldest-cob-closed", "method": "GET", "requestBody": "none", "responseBody": "OldestCOBProcessedLoanDTO (JSON)", "authentication": "unknown", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/LoanCOBCatchUpApiResource.java", "mechanism": "REST", "name": "executeLoanCOBCatchUp", "description": "Executes Loan COB Catch Up", "path": "/v1/loans/catch-up", "method": "POST", "requestBody": "none", "responseBody": "Empty (Status 200, 202, or 400)", "authentication": "unknown", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/LoanCOBCatchUpApiResource.java", "mechanism": "REST", "name": "isCatchUpRunning", "description": "Retrieves whether Loan COB catch up is running", "path": "/v1/loans/is-catch-up-running", "method": "GET", "requestBody": "none", "responseBody": "IsCatchUpRunningDTO (JSON)", "authentication": "unknown", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.api.InternalCOBApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/InternalCOBApiResource.java", "mechanism": "REST", "name": "getCobPartitions", "description": "Endpoint to retrieve loan COB partitions for testing purposes.", "path": "/v1/internal/cob/partitions/{partitionSize}", "method": "GET", "requestBody": "None", "responseBody": "JSON list of LoanCOBPartition objects" }, { "namespace": "org.apache.fineract.cob.api.InternalLoanAccountLockApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/InternalLoanAccountLockApiResource.java", "mechanism": "REST", "name": "placeLockOnLoanAccount", "description": "Internal API endpoint to place a lock on a loan account for testing.", "path": "/v1/internal/loans/{loanId}/place-lock/{lockOwner}", "method": "POST", "direction": "CONSUMER", "requestBody": "String (optional error message)", "responseBody": "Empty (HTTP 202 Accepted)" }, { "namespace": "org.apache.fineract.cob.api.LoanAccountLockApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/api/LoanAccountLockApiResource.java", "mechanism": "REST", "name": "retrieveLockedAccounts", "description": "Endpoint to list locked loan accounts", "path": "/v1/loans/locked", "method": "GET", "responseBody": "JSON representation of LoanAccountLockResponseDTO containing a list of locked loan accounts", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.cob.listener.FineractCOBAfterJobListener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/listener/FineractCOBAfterJobListener.java", "mechanism": "OTHER", "name": "Spring Batch Lifecycle", "description": "Integrates with the Spring Batch framework to listen for job completion events via the JobExecution object.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.cob.loan", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/loan/LoanCOBWorkerConfiguration.java", "mechanism": "OTHER", "name": "inboundRequests", "description": "Spring Integration input channel used by the RemotePartitioningWorkerStepBuilderFactory to receive partition requests from the manager step.", "direction": "CONSUMER", "protocol": "Spring Integration", "connectionInfo": "inboundRequests bean" }, { "namespace": "org.apache.fineract.cob.loan", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/loan/LoanCOBManagerConfiguration.java", "mechanism": "OTHER", "name": "outboundRequests", "description": "Spring Integration DirectChannel used for Spring Batch Remote Partitioning. The manager step sends partition execution requests to workers via this channel.", "queueOrTopicName": "outboundRequests", "messageType": "StepExecutionRequest", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.cob.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/cob/service/InlineLoanCOBExecutorServiceImpl.java", "mechanism": "OTHER", "name": "Spring Batch Job Execution", "description": "Launches Spring Batch jobs programmatically using JobLauncher.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.commands.api.AuditsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/AuditsApiResource.java", "mechanism": "REST", "name": "List Audits", "description": "Retrieve a list of audit entries with optional filtering and pagination.", "path": "/v1/audits", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of AuditData", "authentication": "PlatformSecurityContext (OAuth/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.commands.api.AuditsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/AuditsApiResource.java", "mechanism": "REST", "name": "Retrieve an Audit Entry", "description": "Retrieve a specific audit entry by ID.", "path": "/v1/audits/{auditId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of AuditData", "authentication": "PlatformSecurityContext (OAuth/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.commands.api.AuditsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/AuditsApiResource.java", "mechanism": "REST", "name": "Audit Search Template", "description": "Retrieve metadata/template for building audit search queries.", "path": "/v1/audits/searchtemplate", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of AuditSearchData", "authentication": "PlatformSecurityContext (OAuth/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.commands.api.MakercheckersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/MakercheckersApiResource.java", "mechanism": "REST", "name": "List Maker Checker Entries", "description": "Get a list of entries that can be checked by the requestor matching supplied criteria.", "path": "/v1/makercheckers", "method": "GET", "responseBody": "JSON array of AuditData" }, { "namespace": "org.apache.fineract.commands.api.MakercheckersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/MakercheckersApiResource.java", "mechanism": "REST", "name": "Maker Checker Search Template", "description": "Retrieve template data for building UI filters for maker-checker inbox.", "path": "/v1/makercheckers/searchtemplate", "method": "GET", "responseBody": "JSON object with lists of appUsers, actionNames, entityNames" }, { "namespace": "org.apache.fineract.commands.api.MakercheckersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/MakercheckersApiResource.java", "mechanism": "REST", "name": "Approve/Reject Entry", "description": "Approve or reject a maker-checker entry based on the command parameter.", "path": "/v1/makercheckers/{auditId}", "method": "POST", "requestBody": "JSON (consumed but not explicitly mapped in method signature)", "responseBody": "JSON result of the command" }, { "namespace": "org.apache.fineract.commands.api.MakercheckersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/commands/api/MakercheckersApiResource.java", "mechanism": "REST", "name": "Delete Entry", "description": "Delete a maker-checker entry.", "path": "/v1/makercheckers/{auditId}", "method": "DELETE", "responseBody": "JSON result of the command" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "retrieveTemplate", "description": "Retrieve Account number format Template", "path": "/accountnumberformats/template", "method": "GET", "responseBody": "JSON (AccountNumberFormatData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "List Account number formats", "path": "/accountnumberformats", "method": "GET", "responseBody": "JSON Array (AccountNumberFormatData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "retrieveOne", "description": "Retrieve an Account number format", "path": "/accountnumberformats/{accountNumberFormatId}", "method": "GET", "responseBody": "JSON (AccountNumberFormatData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "create", "description": "Create an Account number format", "path": "/accountnumberformats", "method": "POST", "requestBody": "JSON (PostAccountNumberFormatsRequest)", "responseBody": "JSON (PostAccountNumberFormatsResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "update", "description": "Update an Account number format", "path": "/accountnumberformats/{accountNumberFormatId}", "method": "PUT", "requestBody": "JSON (PutAccountNumberFormatsRequest)", "responseBody": "JSON (PutAccountNumberFormatsResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResource.java", "mechanism": "REST", "name": "delete", "description": "Delete an Account number format", "path": "/accountnumberformats/{accountNumberFormatId}", "method": "DELETE", "responseBody": "JSON (DeleteAccountNumberFormatsResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.api.AccountNumberFormatsApiResourceSwagger", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/api/AccountNumberFormatsApiResourceSwagger.java", "mechanism": "REST", "name": "Swagger Schema Definitions", "description": "Defines the request and response schemas (DTOs) for the Account Number Formats REST API documentation.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.accountnumberformat.service.AccountNumberFormatConstants", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/accountnumberformat/service/AccountNumberFormatConstants.java", "mechanism": "REST", "name": "AccountNumberFormats Resource", "description": "Defines the relative URL path for the account number formats API endpoint.", "path": "/v1/accountnumberformats", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.api.BulkImportApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/api/BulkImportApiResource.java", "mechanism": "REST", "name": "retrieveImportDocuments", "description": "Endpoint to retrieve import documents based on entity type.", "path": "/v1/imports", "method": "GET", "requestBody": "None (Query Parameters)", "responseBody": "JSON Array of ImportData", "authentication": "PlatformSecurityContext (User Permissions)" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.api.BulkImportApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/api/BulkImportApiResource.java", "mechanism": "REST", "name": "retriveOutputTemplateLocation", "description": "Endpoint to get the location of an output template.", "path": "/v1/imports/getOutputTemplateLocation", "method": "GET", "requestBody": "None (Query Parameters)", "responseBody": "JSON String (File Location)", "authentication": "PlatformSecurityContext (User Permissions)" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.api.BulkImportApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/api/BulkImportApiResource.java", "mechanism": "REST", "name": "getOutputTemplate", "description": "Endpoint to download the output template file.", "path": "/v1/imports/downloadOutputTemplate", "method": "GET", "requestBody": "None (Query Parameters)", "responseBody": "application/vnd.ms-excel (Binary File)", "authentication": "Implicit (Service Layer)" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.populator.FixedDepositProductSheetPopulator", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/populator/FixedDepositProductSheetPopulator.java", "mechanism": "OTHER", "name": "Excel Workbook Generation", "description": "Generates an Excel sheet using Apache POI for reporting or bulk import template purposes.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.service", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/bulkimport/service/BulkImportWorkbookService.java", "mechanism": "REST", "name": "JAX-RS Response / Jersey Multipart", "description": "The service interface explicitly depends on JAX-RS 'Response' and Jersey's 'FormDataContentDisposition'. This indicates that the service is tightly coupled to the REST layer, handling HTTP response generation and multipart file upload details directly within the service contract.", "path": "n/a", "method": "n/a", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.service.BulkImportEventListener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/service/BulkImportEventListener.java", "mechanism": "OTHER", "name": "BulkImportEvent Listener", "description": "Listens for internal Spring Application Events to trigger bulk import processing asynchronously.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.service.BulkImportWorkbookPopulatorService", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/bulkimport/service/BulkImportWorkbookPopulatorService.java", "mechanism": "REST", "name": "getTemplate", "description": "The method returns a JAX-RS Response object, indicating it is tightly coupled to the REST API layer for returning HTTP responses (likely file downloads).", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.bulkimport.service.BulkImportWorkbookPopulatorServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/bulkimport/service/BulkImportWorkbookPopulatorServiceImpl.java", "mechanism": "REST", "name": "Template Download Response", "description": "Constructs and returns a JAX-RS Response object containing a generated Excel file, acting as the response producer for a REST API endpoint.", "path": "n/a", "method": "GET", "direction": "PRODUCER", "responseBody": "application/vnd.ms-excel (Binary Excel File)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.businessdate.api.BusinessDateApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/businessdate/api/BusinessDateApiResource.java", "mechanism": "REST", "name": "List all business dates", "description": "Endpoint to retrieve all configured business dates.", "path": "/v1/businessdate", "method": "GET", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (User Permissions)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.businessdate.api.BusinessDateApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/businessdate/api/BusinessDateApiResource.java", "mechanism": "REST", "name": "Retrieve a specific Business date", "description": "Endpoint to retrieve a specific business date by its type.", "path": "/v1/businessdate/{type}", "method": "GET", "responseBody": "BusinessDateData (JSON)", "authentication": "PlatformSecurityContext (User Permissions)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.businessdate.api.BusinessDateApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/businessdate/api/BusinessDateApiResource.java", "mechanism": "REST", "name": "Update Business Date", "description": "Endpoint to update business date settings.", "path": "/v1/businessdate", "method": "POST", "requestBody": "BusinessDateRequest (JSON)", "responseBody": "CommandProcessingResult (JSON)", "authentication": "PlatformSecurityContext (User Permissions)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.cache.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/cache/api/CacheApiResourceSwagger.java", "mechanism": "REST", "name": "Cache API Schemas", "description": "Defines the request and response schemas (DTOs) for the Cache Management REST API documentation.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.cache.api.CacheApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/cache/api/CacheApiResource.java", "mechanism": "REST", "name": "Retrieve Cache Types", "description": "Endpoint to retrieve the list of available cache configurations.", "path": "/v1/caches", "method": "GET", "responseBody": "JSON array of CacheData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.cache.api.CacheApiResource", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/cache/api/CacheApiResource.java", "mechanism": "REST", "name": "Switch Cache", "description": "Endpoint to switch the active cache implementation.", "path": "/v1/caches", "method": "PUT", "requestBody": "JSON object defining the desired cache type", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrieveAllEmails", "description": "Endpoint to retrieve all email messages.", "path": "/v1/email", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrievePendingEmail", "description": "Endpoint to retrieve pending email messages.", "path": "/v1/email/pendingEmail", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrieveSentEmail", "description": "Endpoint to retrieve sent email messages.", "path": "/v1/email/sentEmail", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrieveAllEmailByStatus", "description": "Endpoint to retrieve email messages by status and date range.", "path": "/v1/email/messageByStatus", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON Page of EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrieveFailedEmail", "description": "Endpoint to retrieve failed email messages.", "path": "/v1/email/failedEmail", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "create", "description": "Endpoint to create a new email.", "path": "/v1/email", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object defining email", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "retrieveOne", "description": "Endpoint to retrieve a single email by ID.", "path": "/v1/email/{resourceId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON EmailData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "update", "description": "Endpoint to update an existing email.", "path": "/v1/email/{resourceId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with updates", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailApiResource.java", "mechanism": "REST", "name": "delete", "description": "Endpoint to delete an email.", "path": "/v1/email/{resourceId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailConfigurationApiResource.java", "mechanism": "REST", "name": "Email Configuration API", "description": "API endpoints for managing email configurations.", "path": "/v1/email/configuration", "method": "GET, PUT", "requestBody": "JSON (for PUT)", "responseBody": "JSON", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.api.EmailCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/api/EmailCampaignApiResource.java", "mechanism": "REST", "name": "Email Campaign API", "description": "RESTful endpoints for managing email campaigns.", "path": "/v1/email/campaign", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/handler/ActivateEmailCampaignCommandHandler.java", "mechanism": "OTHER", "name": "EMAIL_CAMPAIGN ACTIVATE Command Handler", "description": "Registers as a handler for the ACTIVATE action on EMAIL_CAMPAIGN entities within the Fineract command framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.email.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/email/service/EmailMessageJobEmailServiceImpl.java", "mechanism": "OTHER", "name": "SMTP Email Server", "description": "Sends emails via SMTP protocol using JavaMailSenderImpl.", "direction": "PRODUCER", "protocol": "SMTP", "connectionInfo": "Host and Port derived from SMTPCredentialsData (e.g., smtp.gmail.com:465)" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.helper", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/helper/SmsConfigUtils.java", "mechanism": "REST", "name": "SMS Gateway Request Preparation", "description": "Prepares the URI and HttpEntity (headers and body) for calling an external SMS Gateway REST API.", "path": "{endPoint}/{apiEndPoint}", "method": "HTTP (Method determined by caller, likely POST)", "requestBody": "JSON String (apiQueueResourceDatas)", "responseBody": "n/a (Preparation only)", "authentication": "Custom Headers (Tenant App Key)", "protocol": "HTTP", "connectionInfo": "Host and Port from MessageGatewayConfigurationData" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.jobs.executeemail.ExecuteEmailTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/jobs/executeemail/ExecuteEmailTasklet.java", "mechanism": "OTHER", "name": "EmailMessageJobEmailService", "description": "Service used to send emails with optional attachments.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.jobs.executeemail.ExecuteEmailTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/jobs/executeemail/ExecuteEmailTasklet.java", "mechanism": "OTHER", "name": "ReadReportingService", "description": "Service used to generate Pentaho reports as byte streams for email attachments.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.jobs.executereportmailingjobs.ExecuteReportMailingJobsTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/jobs/executereportmailingjobs/ExecuteReportMailingJobsTasklet.java", "mechanism": "OTHER", "name": "ReportMailingJobEmailService", "description": "Sends generated reports via email to recipients.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.jobs.getdeliveryreportsfromsmsgateway", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/jobs/getdeliveryreportsfromsmsgateway/GetDeliveryReportsFromSmsGatewayTasklet.java", "mechanism": "REST", "name": "SMS Gateway Report Service", "description": "Calls an external SMS gateway to retrieve delivery reports for a batch of message IDs.", "path": "sms/report (dynamically resolved)", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON Array of Message IDs", "responseBody": "Collection", "protocol": "HTTP/HTTPS", "connectionInfo": "Configured via SmsConfigUtils" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.jobs.sendmessagetosmsgateway.SendMessageToSmsGatewayTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/jobs/sendmessagetosmsgateway/SendMessageToSmsGatewayTasklet.java", "mechanism": "REST", "name": "SMS Gateway Intermediate Server", "description": "Sends a batch of SMS message data to an external or intermediate SMS gateway via HTTP POST.", "path": "Dynamic (determined by smsConfigUtils)", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON string of SmsMessageApiQueueResourceData collection", "responseBody": "String (checked for HttpStatus.ACCEPTED)", "protocol": "HTTP", "connectionInfo": "Configured via SmsConfigUtils" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve the template for creating a new SMS campaign.", "path": "/v1/smscampaigns/template", "method": "GET", "responseBody": "SmsCampaignData JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Create Campaign", "description": "Endpoint to create a new SMS campaign.", "path": "/v1/smscampaigns", "method": "POST", "requestBody": "SmsCampaignData JSON", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Retrieve Campaign", "description": "Endpoint to retrieve a specific SMS campaign by ID.", "path": "/v1/smscampaigns/{resourceId}", "method": "GET", "responseBody": "SmsCampaignData JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "List Campaigns", "description": "Endpoint to list SMS campaigns with pagination and search.", "path": "/v1/smscampaigns", "method": "GET", "responseBody": "Page JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Update Campaign", "description": "Endpoint to update an existing SMS campaign.", "path": "/v1/smscampaigns/{campaignId}", "method": "PUT", "requestBody": "SmsCampaignData JSON", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Handle Commands", "description": "Endpoint to perform actions (activate, close, reactivate) on a campaign.", "path": "/v1/smscampaigns/{campaignId}", "method": "POST", "requestBody": "JSON payload (optional)", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Preview Message", "description": "Endpoint to preview the SMS message.", "path": "/v1/smscampaigns/preview", "method": "POST", "requestBody": "JSON parameters", "responseBody": "CampaignPreviewData JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.api.SmsCampaignApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/api/SmsCampaignApiResource.java", "mechanism": "REST", "name": "Delete Campaign", "description": "Endpoint to delete an SMS campaign.", "path": "/v1/smscampaigns/{campaignId}", "method": "DELETE", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/handler/DeleteSmsCampaignCommandHandler.java", "mechanism": "REST", "name": "Delete SMS Campaign", "description": "This handler is mapped to a REST API endpoint via the Fineract Command infrastructure. It handles the DELETE action for the SMSCAMPAIGN entity.", "path": "/smscampaigns/{id}", "method": "DELETE", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "CommandProcessingResult (JSON)", "authentication": "OAuth/Basic (Platform default)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.handler.ActivateSmsCampaignCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/handler/ActivateSmsCampaignCommandHandler.java", "mechanism": "OTHER", "name": "Fineract Command Bus", "description": "Registers as a handler for the 'ACTIVATE' action on 'SMSCAMPAIGN' entities via the @CommandType annotation.", "direction": "CONSUMER", "protocol": "Internal Java Interface" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignDomainServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/service/SmsCampaignDomainServiceImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Internal event bus subscription for business events.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignDropdownReadPlatformServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/service/SmsCampaignDropdownReadPlatformServiceImpl.java", "mechanism": "REST", "name": "SMS Provider Service", "description": "Fetches configuration for SMS providers from an external service or bridge.", "path": "Dynamic (determined by smsConfigUtils.getMessageGateWayRequestURI)", "method": "GET", "direction": "CONSUMER", "responseBody": "Collection", "protocol": "HTTP", "connectionInfo": "Configured via SmsConfigUtils" }, { "namespace": "org.apache.fineract.infrastructure.campaigns.sms.service.SmsCampaignWritePlatformServiceJpaImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/campaigns/sms/service/SmsCampaignWritePlatformServiceJpaImpl.java", "mechanism": "OTHER", "name": "SmsMessageScheduledJobService", "description": "Internal service call to trigger scheduled message sending.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.codes.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodesApiResource.java", "mechanism": "REST", "name": "Codes API", "description": "RESTful endpoints for managing Codes and Code Values.", "path": "/v1/codes", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload for creating or updating codes (CodeData)", "responseBody": "JSON representation of CodeData or CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.codes.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResourceSwagger.java", "mechanism": "REST", "name": "CodeValuesApi Schemas", "description": "Defines the Swagger/OpenAPI schemas for REST API request and response bodies related to Code Values management.", "direction": "OTHER", "requestBody": "PostCodeValuesDataRequest, PutCodeValuesDataRequest", "responseBody": "GetCodeValuesDataResponse, PostCodeValueDataResponse, PutCodeValueDataResponse, DeleteCodeValueDataResponse" }, { "namespace": "org.apache.fineract.infrastructure.codes.api.CodeValuesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResource.java", "mechanism": "REST", "name": "retrieveAllCodeValues", "description": "List Code Values for a given Code", "path": "/v1/codes/{codeId}/codevalues", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of CodeValueData" }, { "namespace": "org.apache.fineract.infrastructure.codes.api.CodeValuesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResource.java", "mechanism": "REST", "name": "createCodeValue", "description": "Create a Code Value", "path": "/v1/codes/{codeId}/codevalues", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object (PostCodeValuesDataRequest)", "responseBody": "JSON object (PostCodeValueDataResponse)" }, { "namespace": "org.apache.fineract.infrastructure.codes.api.CodeValuesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResource.java", "mechanism": "REST", "name": "retrieveCodeValue", "description": "Retrieve a Code Value", "path": "/v1/codes/{codeId}/codevalues/{codeValueId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object (CodeValueData)" }, { "namespace": "org.apache.fineract.infrastructure.codes.api.CodeValuesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResource.java", "mechanism": "REST", "name": "updateCodeValue", "description": "Update a Code Value", "path": "/v1/codes/{codeId}/codevalues/{codeValueId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object (PutCodeValuesDataRequest)", "responseBody": "JSON object (PutCodeValueDataResponse)" }, { "namespace": "org.apache.fineract.infrastructure.codes.api.CodeValuesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/codes/api/CodeValuesApiResource.java", "mechanism": "REST", "name": "deleteCodeValue", "description": "Delete a Code Value", "path": "/v1/codes/{codeId}/codevalues/{codeValueId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object (DeleteCodeValueDataResponse)" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/ExternalServicesConfigurationApiResource.java", "mechanism": "REST", "name": "Retrieve External Services Configuration", "description": "Endpoint to retrieve configuration details for a specific external service (e.g., SMTP, S3).", "path": "/v1/externalservice/{servicename}", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of ExternalServicesPropertiesData", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/ExternalServicesConfigurationApiResource.java", "mechanism": "REST", "name": "Update External Service", "description": "Endpoint to update configuration details for a specific external service.", "path": "/v1/externalservice/{servicename}", "method": "PUT", "requestBody": "JSON payload with configuration properties", "responseBody": "JSON representation of CommandProcessingResult", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api.GlobalConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/GlobalConfigurationApiResource.java", "mechanism": "REST", "name": "Retrieve Global Configuration", "description": "Endpoint to retrieve all global configurations or survey configurations.", "path": "/v1/configurations", "method": "GET", "requestBody": "None", "responseBody": "JSON list of GlobalConfigurationData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api.GlobalConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/GlobalConfigurationApiResource.java", "mechanism": "REST", "name": "Retrieve One Configuration", "description": "Endpoint to retrieve a specific configuration by ID.", "path": "/v1/configurations/{configId}", "method": "GET", "requestBody": "None", "responseBody": "JSON object of GlobalConfigurationPropertyData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api.GlobalConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/GlobalConfigurationApiResource.java", "mechanism": "REST", "name": "Retrieve One Configuration By Name", "description": "Endpoint to retrieve a specific configuration by Name.", "path": "/v1/configurations/name/{name}", "method": "GET", "requestBody": "None", "responseBody": "JSON object of GlobalConfigurationPropertyData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.configuration.api.GlobalConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/configuration/api/GlobalConfigurationApiResource.java", "mechanism": "REST", "name": "Update Configuration", "description": "Endpoint to update a specific configuration item.", "path": "/v1/configurations/{configId}", "method": "PUT", "requestBody": "JSON payload with update details", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/api/ApiParameterHelper.java", "mechanism": "REST", "name": "JAX-RS Parameter Parsing", "description": "This class is a utility for parsing JAX-RS query parameters, acting as a helper for REST API controllers.", "path": "n/a", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.core.config", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/ContentS3Config.java", "mechanism": "OTHER", "name": "AWS S3 Client", "description": "Configures the AWS SDK S3 Client for interacting with Amazon S3 storage.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.config.FineractProperties", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/config/FineractProperties.java", "mechanism": "JMS-QUEUE", "name": "requestQueueName", "description": "JMS Queue for handling remote jobs.", "queueOrTopicName": "${fineract.remoteJobMessageHandler.jms.requestQueueName}", "direction": "CONSUMER", "connectionInfo": "Broker URL defined in fineract.remoteJobMessageHandler.jms.brokerUrl" }, { "namespace": "org.apache.fineract.infrastructure.core.config.FineractProperties", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/config/FineractProperties.java", "mechanism": "KAFKA-TOPIC", "name": "Remote Job Kafka Topic", "description": "Kafka topic for handling remote jobs.", "queueOrTopicName": "${fineract.remoteJobMessageHandler.kafka.topic.name}", "direction": "CONSUMER", "connectionInfo": "Bootstrap servers defined in fineract.remoteJobMessageHandler.kafka.bootstrapServers" }, { "namespace": "org.apache.fineract.infrastructure.core.config.FineractProperties", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/config/FineractProperties.java", "mechanism": "JMS-QUEUE", "name": "eventQueueName", "description": "JMS Queue for producing external events.", "queueOrTopicName": "${fineract.events.external.producer.jms.eventQueueName}", "direction": "PRODUCER", "connectionInfo": "Broker URL defined in fineract.events.external.producer.jms.brokerUrl" }, { "namespace": "org.apache.fineract.infrastructure.core.config.FineractProperties", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/config/FineractProperties.java", "mechanism": "JMS-TOPIC", "name": "eventTopicName", "description": "JMS Topic for producing external events.", "queueOrTopicName": "${fineract.events.external.producer.jms.eventTopicName}", "direction": "PRODUCER", "connectionInfo": "Broker URL defined in fineract.events.external.producer.jms.brokerUrl" }, { "namespace": "org.apache.fineract.infrastructure.core.config.FineractProperties", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/config/FineractProperties.java", "mechanism": "KAFKA-TOPIC", "name": "External Events Kafka Topic", "description": "Kafka topic for producing external events.", "queueOrTopicName": "${fineract.events.external.producer.kafka.topic.name}", "direction": "PRODUCER", "connectionInfo": "Bootstrap servers defined in fineract.events.external.producer.kafka.bootstrapServers" }, { "namespace": "org.apache.fineract.infrastructure.core.config.OAuth2SecurityConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/OAuth2SecurityConfig.java", "mechanism": "REST", "name": "API Security Configuration", "description": "Configures security rules and filters for all REST API endpoints under /api/**. It defines public endpoints (e.g., /api/*/authentication) and protected endpoints requiring OAuth2 authentication.", "path": "/api/**", "method": "ALL", "authentication": "OAuth2 (JWT)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.config.SecurityConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/SecurityConfig.java", "mechanism": "REST", "name": "Fineract API Security", "description": "Configures security rules, authentication, and authorization for the Fineract REST API endpoints.", "path": "/api/**", "method": "GET, POST, PUT, DELETE, OPTIONS", "direction": "BOTH", "authentication": "Basic Auth, Two-Factor", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.config.cache", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/cache/SpecifiedCacheSupportingCacheManager.java", "mechanism": "OTHER", "name": "JCache Integration", "description": "Integrates with a JSR-107 (JCache) provider via Spring's JCacheCacheManager to handle actual caching operations for supported cache names.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.config.cache", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/cache/TransactionBoundCacheManager.java", "mechanism": "OTHER", "name": "Spring Cache Abstraction", "description": "Integrates with the Spring Caching abstraction to manage cache lifecycles.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.data.UploadRequest", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/data/UploadRequest.java", "mechanism": "REST", "name": "Multipart Upload Request Binding", "description": "This class is used as a binding target for JAX-RS multipart/form-data requests. The @FormDataParam annotations map form fields to class properties.", "path": "n/a", "method": "n/a", "direction": "CONSUMER", "requestBody": "multipart/form-data" }, { "namespace": "org.apache.fineract.infrastructure.core.debug", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/debug/EchoHeadersApiResource.java", "mechanism": "REST", "name": "Echo Headers Endpoint", "description": "A debugging endpoint that returns the HTTP headers sent in the request.", "path": "/v1/echo", "method": "GET", "direction": "BIDIRECTIONAL", "responseBody": "text/plain string containing header keys and values" }, { "namespace": "org.apache.fineract.infrastructure.core.exception", "filepath": "fineract-loan/src/main/java/org/apache/fineract/infrastructure/core/exception/MultiDisbursementDataRequiredExceptionMapper.java", "mechanism": "REST", "name": "MultiDisbursementDataRequiredExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts MultiDisbursementDataRequiredException and returns an HTTP 403 Forbidden response.", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exception", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exception/HttpMessageNotReadableErrorController.java", "mechanism": "REST", "name": "HttpMessageNotReadableException Mapper", "description": "JAX-RS ExceptionMapper that intercepts JSON parsing errors in REST API requests and returns formatted error responses.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.core.exception", "filepath": "fineract-loan/src/main/java/org/apache/fineract/infrastructure/core/exception/LinkedAccountRequiredExceptionMapper.java", "mechanism": "REST", "name": "LinkedAccountRequiredExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts LinkedAccountRequiredException and returns an HTTP 403 response.", "responseBody": "ApiGlobalErrorResponse (JSON)" }, { "namespace": "org.apache.fineract.infrastructure.core.exception", "filepath": "fineract-loan/src/main/java/org/apache/fineract/infrastructure/core/exception/LoanIdsHardLockedExceptionMapper.java", "mechanism": "REST", "name": "LoanIdsHardLockedExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts LoanIdsHardLockedException and returns an HTTP 409 Conflict response.", "path": "n/a", "method": "n/a", "responseBody": "JSON object containing global error details and the locked loan ID" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/UnrecognizedQueryParamExceptionMapper.java", "mechanism": "REST", "name": "UnrecognizedQueryParamExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts UnrecognizedQueryParamException and returns a standardized JSON error response.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "requestBody": "n/a", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/IdempotentCommandExceptionMapper.java", "mechanism": "REST", "name": "IdempotentCommandExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts idempotent command exceptions and formats the HTTP response.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "responseBody": "JSON entity from the exception", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/UnsupportedParameterExceptionMapper.java", "mechanism": "REST", "name": "UnsupportedParameterExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts UnsupportedParameterException and returns HTTP 400 responses.", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/UnsupportedCommandExceptionMapper.java", "mechanism": "REST", "name": "UnsupportedCommandExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts UnsupportedCommandException and returns a standardized HTTP 400 Bad Request JSON response.", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformDomainRuleExceptionMapper.java", "mechanism": "REST", "name": "PlatformDomainRuleExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts AbstractPlatformDomainRuleException and returns HTTP 403 responses.", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/ConcurrencyFailureExceptionMapper.java", "mechanism": "REST", "name": "ConcurrencyFailureExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts ConcurrencyFailureException and returns HTTP 409 Conflict responses.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformResourceNotFoundExceptionMapper.java", "mechanism": "REST", "name": "PlatformResourceNotFoundExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts AbstractPlatformResourceNotFoundException and converts it into an HTTP 404 REST response.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformApiDataValidationExceptionMapper.java", "mechanism": "REST", "name": "PlatformApiDataValidationExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts PlatformApiDataValidationException and returns an HTTP 400 Bad Request response.", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformServiceUnavailableExceptionMapper.java", "mechanism": "REST", "name": "ExceptionMapper", "description": "JAX-RS ExceptionMapper implementation that intercepts AbstractPlatformServiceUnavailableException and returns HTTP 503 responses.", "direction": "PRODUCER", "responseBody": "JSON object (ApiGlobalErrorResponse) containing error code and user message", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/NoAuthorizationExceptionMapper.java", "mechanism": "REST", "name": "NoAuthorizationException Handler", "description": "Global exception handler for NoAuthorizationException that maps the error to an HTTP 403 Forbidden response.", "responseBody": "JSON (ApiGlobalErrorResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/AccessDeniedExceptionMapper.java", "mechanism": "REST", "name": "AccessDeniedExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts AccessDeniedException and maps it to an HTTP 403 Forbidden response.", "direction": "PRODUCER", "responseBody": "JSON (ApiGlobalErrorResponse structure)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/InvalidJsonExceptionMapper.java", "mechanism": "REST", "name": "InvalidJsonExceptionMapper", "description": "JAX-RS Exception Mapper for handling invalid JSON requests", "direction": "BIDIRECTIONAL", "responseBody": "JSON (ApiParameterError structure)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/InvalidTenantIdentifierExceptionMapper.java", "mechanism": "REST", "name": "InvalidTenantIdentifierExceptionMapper", "description": "JAX-RS Exception Mapper for handling invalid tenant identifiers.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "responseBody": "JSON error response with HTTP 401 status", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/MalformedJsonExceptionMapper.java", "mechanism": "REST", "name": "MalformedJsonExceptionMapper", "description": "JAX-RS Exception Mapper for handling invalid JSON request bodies", "path": "Global (Exception Handler)", "method": "N/A", "direction": "BOTH", "responseBody": "ApiParameterError (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/BadCredentialsExceptionMapper.java", "mechanism": "REST", "name": "BadCredentialsException Handler", "description": "Global exception handler for REST API authentication failures.", "path": "n/a", "method": "n/a", "direction": "PRODUCER", "responseBody": "JSON error response (ApiGlobalErrorResponse)", "protocol": "HTTP/1.1", "connectionInfo": "n/a" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/OAuth2ExceptionEntryPoint.java", "mechanism": "REST", "name": "Authentication Error Response", "description": "Returns a standard JSON error response when API authentication fails.", "path": "Global (intercepts all unauthenticated requests)", "method": "ANY", "direction": "PRODUCER", "responseBody": "JSON serialized ApiGlobalErrorResponse", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/UnAuthenticatedUserExceptionMapper.java", "mechanism": "REST", "name": "UnAuthenticatedUserExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts UnAuthenticatedUserException and returns an HTTP 401 response.", "path": "n/a", "method": "n/a", "responseBody": "JSON object representing the unauthenticated error state (via ApiGlobalErrorResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/JsonPathExceptionMapper.java", "mechanism": "REST", "name": "JsonPathExceptionMapper", "description": "JAX-RS ExceptionMapper provider that intercepts JsonPathException and returns HTTP 400 responses.", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/InvalidInstanceTypeMethodExceptionMapper.java", "mechanism": "REST", "name": "InvalidInstanceTypeMethodExceptionMapper", "description": "JAX-RS Exception Mapper that converts InvalidInstanceTypeMethodException to HTTP 405 responses.", "direction": "PRODUCER", "responseBody": "JSON structure defined by ApiGlobalErrorResponse", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-loan/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/LoanAccountLockCannotBeOverruledExceptionMapper.java", "mechanism": "REST", "name": "LoanAccountLockCannotBeOverruledExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts LoanAccountLockCannotBeOverruledException and maps it to an HTTP 409 Conflict response.", "responseBody": "JSON structure of ApiParameterError", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/BusinessStepExceptionMapper.java", "mechanism": "REST", "name": "BusinessStepExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts BusinessStepException and returns a 400 Bad Request JSON response.", "direction": "PRODUCER", "responseBody": "JSON serialized ApiParameterError object", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/JobIsNotFoundOrNotEnabledExceptionMapper.java", "mechanism": "REST", "name": "JobIsNotFoundOrNotEnabledExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts JobIsNotFoundOrNotEnabledException and returns an HTTP 403 Forbidden response.", "direction": "PRODUCER", "responseBody": "JSON error object (ApiGlobalErrorResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/DefaultExceptionMapper.java", "mechanism": "REST", "name": "Global RuntimeException Handler", "description": "JAX-RS ExceptionMapper that intercepts RuntimeExceptions and converts them to HTTP 500 responses.", "direction": "PRODUCER", "responseBody": "JSON object with an 'Exception' field containing the error message." }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.BusinessStepNotBelongsToJobExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/BusinessStepNotBelongsToJobExceptionMapper.java", "mechanism": "REST", "name": "BusinessStepNotBelongsToJobExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts BusinessStepNotBelongsToJobException and returns an HTTP 400 response.", "direction": "PRODUCER", "responseBody": "ApiParameterError (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.JsonSyntaxExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/JsonSyntaxExceptionMapper.java", "mechanism": "REST", "name": "JsonSyntaxExceptionMapper", "description": "JAX-RS Exception Mapper for handling malformed JSON requests globally.", "direction": "BIDIRECTIONAL", "responseBody": "ApiParameterError (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.OptimisticLockExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/OptimisticLockExceptionMapper.java", "mechanism": "REST", "name": "OptimisticLockExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts OptimisticLockException and returns HTTP 409 responses.", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.PlatformDataIntegrityExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformDataIntegrityExceptionMapper.java", "mechanism": "REST", "name": "PlatformDataIntegrityExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts PlatformDataIntegrityException and returns a standardized JSON error response.", "direction": "PRODUCER", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.PlatformInternalServerExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformInternalServerExceptionMapper.java", "mechanism": "REST", "name": "PlatformInternalServerExceptionMapper", "description": "JAX-RS ExceptionMapper that intercepts PlatformInternalServerException and converts it to an HTTP 500 REST response.", "path": "Global Exception Handler", "method": "n/a", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.exceptionmapper.PlatformRequestBodyItemLimitValidationExceptionMapper", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/exceptionmapper/PlatformRequestBodyItemLimitValidationExceptionMapper.java", "mechanism": "REST", "name": "ExceptionMapper", "description": "JAX-RS Exception Mapper that intercepts PlatformRequestBodyItemLimitValidationException and returns an HTTP 400 response.", "path": "Global (Exception Handler)", "method": "n/a", "direction": "BOTH", "responseBody": "ApiGlobalErrorResponse (JSON)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.core.filters", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/filters/IdempotencyStoreFilter.java", "mechanism": "REST", "name": "Idempotency Filter", "description": "Intercepts HTTP requests to extract idempotency keys and cache response bodies for storage.", "path": "/*", "method": "ALL", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.filters", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/filters/CorrelationHeaderFilter.java", "mechanism": "REST", "name": "Correlation Header Interceptor", "description": "Intercepts all incoming HTTP requests to extract a correlation ID header for logging context.", "path": "/*", "method": "ALL", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via FineractProperties" }, { "namespace": "org.apache.fineract.infrastructure.core.filters", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/filters/BatchCallHandler.java", "mechanism": "REST", "name": "Batch Request Filter Chain", "description": "This class processes JAX-RS `UriInfo` objects as part of a batch request handling pipeline, indicating it operates within the context of a RESTful service architecture.", "path": "n/a", "method": "n/a", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.core.filters", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/filters/RequestResponseFilter.java", "mechanism": "REST", "name": "HTTP Request/Response Logging", "description": "Intercepts all HTTP requests handled by the servlet container to log request and response metadata.", "path": "/*", "method": "ALL", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.filters.ResponseCorsFilter", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/core/filters/ResponseCorsFilter.java", "mechanism": "REST", "name": "CORS Filter", "description": "Intercepts HTTP requests to inject Cross-Origin Resource Sharing (CORS) headers into the response, enabling browser-based clients to access the API.", "method": "GET, POST, PUT, DELETE, OPTIONS", "direction": "BOTH", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.core.jersey", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/jersey/JerseyJacksonObjectArgumentHandler.java", "mechanism": "REST", "name": "JerseyJacksonObjectArgumentHandler", "description": "JAX-RS Provider for JSON serialization/deserialization", "path": "n/a", "method": "n/a", "direction": "BIDIRECTIONAL", "protocol": "HTTP/JSON" }, { "namespace": "org.apache.fineract.infrastructure.core.jersey.JerseyConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/jersey/JerseyConfig.java", "mechanism": "REST", "name": "Base API Path", "description": "Configures the root path for all JAX-RS REST resources in the application.", "path": "/api", "method": "N/A", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.core.messaging.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/messaging/jms/ActiveMQMessageFactory.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "ActiveMQ Message Factory", "description": "Creates ActiveMQ-specific BytesMessage objects for messaging operations.", "messageType": "BytesMessage", "direction": "PRODUCER", "protocol": "ActiveMQ OpenWire/JMS" }, { "namespace": "org.apache.fineract.infrastructure.core.messaging.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/messaging/jms/MessageFactory.java", "mechanism": "JMS-QUEUE", "name": "createByteMessage", "description": "Factory method for creating JMS BytesMessage objects, facilitating the production of JMS messages.", "messageType": "BytesMessage", "direction": "PRODUCER", "protocol": "JMS (Jakarta Messaging)" }, { "namespace": "org.apache.fineract.infrastructure.core.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/service/GmailBackedPlatformEmailService.java", "mechanism": "OTHER", "name": "SMTP Mail Server", "description": "Sends emails via SMTP protocol using Spring's JavaMailSenderImpl.", "direction": "PRODUCER", "protocol": "SMTP", "connectionInfo": "Host and port retrieved dynamically from ExternalServicesPropertiesReadPlatformService (e.g., smtp.gmail.com:587)" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauIntegrationApiResource.java", "mechanism": "REST", "name": "fetchCreditReport", "description": "Endpoint to fetch a credit report.", "path": "/v1/creditBureauIntegration/creditReport", "method": "POST", "requestBody": "JSON object (Map)", "responseBody": "JSON (CreditReportData)", "authentication": "PlatformSecurityContext (implied by context usage in other methods)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauIntegrationApiResource.java", "mechanism": "REST", "name": "addCreditReport", "description": "Endpoint to upload a credit report file.", "path": "/v1/creditBureauIntegration/addCreditReport", "method": "POST", "requestBody": "multipart/form-data (file)", "responseBody": "JSON string message", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauIntegrationApiResource.java", "mechanism": "REST", "name": "saveCreditReport", "description": "Endpoint to save a fetched credit report to the database.", "path": "/v1/creditBureauIntegration/saveCreditReport", "method": "POST", "requestBody": "JSON (Credit Report details)", "responseBody": "JSON (CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauIntegrationApiResource.java", "mechanism": "REST", "name": "getSavedCreditReport", "description": "Endpoint to retrieve saved credit reports by credit bureau ID.", "path": "/v1/creditBureauIntegration/creditReport/{creditBureauId}", "method": "GET", "responseBody": "JSON Array (CreditReportData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauIntegrationApiResource.java", "mechanism": "REST", "name": "deleteCreditReport", "description": "Endpoint to delete a saved credit report.", "path": "/v1/creditBureauIntegration/deleteCreditReport/{creditBureauId}", "method": "DELETE", "requestBody": "JSON (optional body)", "responseBody": "JSON (CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "getCreditBureau", "description": "Retrieves credit bureau data", "path": "/v1/CreditBureauConfiguration", "method": "GET", "responseBody": "JSON array of CreditBureauData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "getCreditBureauLoanProductMapping", "description": "Retrieves credit bureau loan product mappings", "path": "/v1/CreditBureauConfiguration/mappings", "method": "GET", "responseBody": "JSON array of CreditBureauLoanProductMappingData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "getOrganisationCreditBureau", "description": "Retrieves organisation credit bureau data", "path": "/v1/CreditBureauConfiguration/organisationCreditBureau", "method": "GET", "responseBody": "JSON array of OrganisationCreditBureauData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "getConfiguration", "description": "Retrieves configuration for a specific organisation credit bureau", "path": "/v1/CreditBureauConfiguration/config/{organisationCreditBureauId}", "method": "GET", "responseBody": "JSON array of CreditBureauConfigurationData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "fetchLoanProducts", "description": "Fetches loan products associated with credit bureaus", "path": "/v1/CreditBureauConfiguration/loanProduct", "method": "GET", "responseBody": "JSON array of CreditBureauLoanProductMappingData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "fetchMappingByLoanProductId", "description": "Fetches mapping for a specific loan product", "path": "/v1/CreditBureauConfiguration/loanProduct/{loanProductId}", "method": "GET", "responseBody": "JSON object of CreditBureauLoanProductMappingData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "updateCreditBureau", "description": "Updates credit bureau information", "path": "/v1/CreditBureauConfiguration/organisationCreditBureau", "method": "PUT", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "updateCreditBureauLoanProductMapping", "description": "Updates credit bureau loan product mapping", "path": "/v1/CreditBureauConfiguration/mappings", "method": "PUT", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "addOrganisationCreditBureau", "description": "Adds an organisation credit bureau", "path": "/v1/CreditBureauConfiguration/organisationCreditBureau/{organisationCreditBureauId}", "method": "POST", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "createCreditBureauLoanProductMapping", "description": "Creates a credit bureau loan product mapping", "path": "/v1/CreditBureauConfiguration/mappings/{organisationCreditBureauId}", "method": "POST", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "createCreditBureauConfiguration", "description": "Creates a credit bureau configuration", "path": "/v1/CreditBureauConfiguration/configuration/{creditBureauId}", "method": "POST", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.api.CreditBureauConfigurationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/api/CreditBureauConfigurationApiResource.java", "mechanism": "REST", "name": "updateCreditBureauConfiguration", "description": "Updates a credit bureau configuration", "path": "/v1/CreditBureauConfiguration/configuration/{configurationId}", "method": "PUT", "requestBody": "JSON object", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/service/ThitsaWorksCreditBureauIntegrationWritePlatformService.java", "mechanism": "REST", "name": "ThitsaWorks API Connection", "description": "The interface defines a method 'okHttpConnectionMethod' which explicitly suggests the use of an HTTP client to connect to an external URL. The parameters include authentication details (userName, password, subscriptionKey) and a target URL, characteristic of a RESTful integration.", "path": "Dynamic (passed as parameter 'url')", "method": "Unknown (likely POST or PUT based on file upload parameters)", "direction": "BIDIRECTIONAL", "protocol": "HTTP/HTTPS", "connectionInfo": "URL passed as parameter" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.service.CreditReportWritePlatformService", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/service/CreditReportWritePlatformService.java", "mechanism": "REST", "name": "Credit Report File Upload", "description": "The method `addCreditReport` accepts `FormDataContentDisposition`, which is a Jersey specific class used for handling Multipart file uploads in REST APIs. This indicates the service is designed to process files received via a REST endpoint.", "path": "n/a", "method": "POST", "direction": "CONSUMER", "requestBody": "multipart/form-data", "responseBody": "String" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.service.ThitsaWorksCreditBureauIntegrationWritePlatformServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/creditbureau/service/ThitsaWorksCreditBureauIntegrationWritePlatformServiceImpl.java", "mechanism": "REST", "name": "ThitsaWorks Credit Bureau API", "description": "External integration to ThitsaWorks Credit Bureau for credit reporting services.", "path": "Dynamic (configured in DB)", "method": "GET, POST", "direction": "CONSUMER", "requestBody": "Multipart form data (file upload), Form URL Encoded (token, search)", "responseBody": "JSON", "authentication": "Bearer Token (OAuth2 style password grant)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via database (CreditBureauConfiguration)" }, { "namespace": "org.apache.fineract.infrastructure.creditbureau.service.ThitsaWorksCreditBureauIntegrationWritePlatformServiceImplTest", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/creditbureau/service/ThitsaWorksCreditBureauIntegrationWritePlatformServiceImplTest.java", "mechanism": "REST", "name": "ThitsaWorks Credit Bureau API", "description": "The test mocks interactions with the ThitsaWorks Credit Bureau API for operations like getting tokens, searching NRC, and retrieving credit reports.", "path": "Various (mocked): /api/...", "method": "GET", "direction": "CONSUMER", "requestBody": "Form-encoded or Multipart", "responseBody": "JSON", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/ReportsApiResource.java", "mechanism": "REST", "name": "Reports API", "description": "RESTful endpoints for managing reports.", "path": "/v1/reports", "method": "GET, POST, PUT, DELETE", "authentication": "PlatformSecurityContext (OAuth2/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.DatatablesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/DatatablesApiResource.java", "mechanism": "REST", "name": "Datatables API", "description": "RESTful API for managing custom data tables and their contents.", "path": "/v1/datatables", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.EntityDatatableChecksApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/EntityDatatableChecksApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "List Entity-Datatable Checks", "path": "/v1/entityDatatableChecks", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of EntityDataTableChecksData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.EntityDatatableChecksApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/EntityDatatableChecksApiResource.java", "mechanism": "REST", "name": "getTemplate", "description": "Retrieve Entity-Datatable Checks Template", "path": "/v1/entityDatatableChecks/template", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object of EntityDataTableChecksTemplateData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.EntityDatatableChecksApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/EntityDatatableChecksApiResource.java", "mechanism": "REST", "name": "createEntityDatatableCheck", "description": "Create Entity-Datatable Checks", "path": "/v1/entityDatatableChecks", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object (PostEntityDatatableChecksTemplateRequest)", "responseBody": "JSON object (CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.EntityDatatableChecksApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/EntityDatatableChecksApiResource.java", "mechanism": "REST", "name": "deleteDatatable", "description": "Delete Entity-Datatable Checks", "path": "/v1/entityDatatableChecks/{entityDatatableCheckId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object (CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.RunreportsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/RunreportsApiResource.java", "mechanism": "REST", "name": "Run Reports API", "description": "API for running reports and retrieving export options.", "path": "/v1/runreports", "method": "GET", "direction": "BIDIRECTIONAL", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.RunreportsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/RunreportsApiResource.java", "mechanism": "REST", "name": "Available Exports Endpoint", "description": "Endpoint to get available export types for a report.", "path": "/v1/runreports/availableExports/{reportName}", "method": "GET", "direction": "BIDIRECTIONAL", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.api.RunreportsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/api/RunreportsApiResource.java", "mechanism": "REST", "name": "Run Report Endpoint", "description": "Endpoint to execute a report.", "path": "/v1/runreports/{reportName}", "method": "GET", "direction": "BIDIRECTIONAL", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/service/ReadReportingService.java", "mechanism": "REST", "name": "retrieveReportCSV", "description": "The method 'retrieveReportCSV' returns 'jakarta.ws.rs.core.StreamingOutput', which is a specific JAX-RS type used for streaming data in RESTful web services. This indicates that the service is tightly coupled to a REST API implementation.", "path": "n/a", "method": "n/a", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.dataqueries.service.export", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/dataqueries/service/export/S3DatatableReportExportServiceImpl.java", "mechanism": "OTHER", "name": "AWS S3 Bucket", "description": "Uploads generated CSV report files to an Amazon S3 bucket.", "method": "putObject", "direction": "PRODUCER", "protocol": "AWS SDK / HTTPS" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "addNewClientImage (Multipart)", "description": "Uploads a new image via Multipart Form Data", "path": "/v1/{entity}/{entityId}/images", "method": "POST", "requestBody": "multipart/form-data", "responseBody": "application/json" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "addNewClientImage (Base64)", "description": "Uploads a new image via Base64 Data URL", "path": "/v1/{entity}/{entityId}/images", "method": "POST", "requestBody": "text/plain, text/html, or application/json", "responseBody": "application/json" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "retrieveImage", "description": "Retrieves an image", "path": "/v1/{entity}/{entityId}/images", "method": "GET", "requestBody": "n/a", "responseBody": "application/json (Base64) or application/octet-stream" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "updateClientImage (Multipart)", "description": "Updates an image via Multipart Form Data", "path": "/v1/{entity}/{entityId}/images", "method": "PUT", "requestBody": "multipart/form-data", "responseBody": "application/json" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "updateClientImage (Base64)", "description": "Updates an image via Base64 Data URL", "path": "/v1/{entity}/{entityId}/images", "method": "PUT", "requestBody": "text/plain, text/html, or application/json", "responseBody": "application/json" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ImagesApiResource.java", "mechanism": "REST", "name": "deleteClientImage", "description": "Deletes an image", "path": "/v1/{entity}/{entityId}/images", "method": "DELETE", "requestBody": "application/json", "responseBody": "application/json" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResourceSwagger.java", "mechanism": "REST", "name": "Document Upload Schema", "description": "Defines the schema for multipart/form-data requests used in document uploads via the DocumentUploadRequest inner class.", "direction": "CONSUMER", "requestBody": "multipart/form-data with 'name' and 'description' fields" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/ContentResources.java", "mechanism": "REST", "name": "JAX-RS Response Builder", "description": "Constructs standard JAX-RS Response objects for file downloads, setting headers for Content-Disposition and Content-Type.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "retrieveAllDocuments", "description": "List documents for an entity", "path": "/v1/{entityType}/{entityId}/documents", "method": "GET", "responseBody": "JSON array of DocumentData" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "createDocument", "description": "Create/Upload a document", "path": "/v1/{entityType}/{entityId}/documents", "method": "POST", "requestBody": "Multipart Form Data (file, name, description)", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "updateDocument", "description": "Update a document", "path": "/v1/{entityType}/{entityId}/documents/{documentId}", "method": "PUT", "requestBody": "Multipart Form Data (file, name, description)", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "getDocument", "description": "Retrieve a single document metadata", "path": "/v1/{entityType}/{entityId}/documents/{documentId}", "method": "GET", "responseBody": "JSON DocumentData" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "downloadFile", "description": "Download document binary", "path": "/v1/{entityType}/{entityId}/documents/{documentId}/attachment", "method": "GET", "responseBody": "application/octet-stream" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.api.DocumentManagementApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/api/DocumentManagementApiResource.java", "mechanism": "REST", "name": "deleteDocument", "description": "Delete a document", "path": "/v1/{entityType}/{entityId}/documents/{documentId}", "method": "DELETE", "responseBody": "JSON CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.documentmanagement.contentrepository.S3ContentRepository", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/documentmanagement/contentrepository/S3ContentRepository.java", "mechanism": "OTHER", "name": "Amazon S3", "description": "Integration with Amazon Simple Storage Service (S3) for storing and retrieving documents and images.", "direction": "BIDIRECTIONAL", "protocol": "AWS SDK v2 (HTTP/REST)", "connectionInfo": "Bucket name configured via 'fineractProperties.getContent().getS3().getBucketName()'" }, { "namespace": "org.apache.fineract.infrastructure.entityaccess.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/entityaccess/api/FineractEntityApiResource.java", "mechanism": "REST", "name": "Fineract Entity API", "description": "REST API endpoints for managing entity-to-entity mappings.", "path": "/v1/entitytoentitymapping", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "requestBody": "JSON", "responseBody": "JSON", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.event.external.api", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/event/external/api/ExternalEventConfigurationApiResource.java", "mechanism": "REST", "name": "External Event Configuration API", "description": "API endpoints for configuring external events.", "path": "/v1/externalevents/configuration", "method": "GET, PUT", "requestBody": "JSON (for PUT)", "responseBody": "JSON", "authentication": "PlatformSecurityContext (Internal Fineract Auth)" }, { "namespace": "org.apache.fineract.infrastructure.event.external.config", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/config/ExternalEventKafkaConfiguration.java", "mechanism": "KAFKA-TOPIC", "name": "externalEventsKafkaTemplate", "description": "Configures the Kafka Producer infrastructure to allow the application to send messages to Kafka brokers.", "messageType": "byte[]", "direction": "PRODUCER", "connectionInfo": "Bootstrap servers configured via 'fineract.events.external.producer.kafka.bootstrapServers' property" }, { "namespace": "org.apache.fineract.infrastructure.event.external.config", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/config/KafkaExternalEventTopicConfig.java", "mechanism": "KAFKA-TOPIC", "name": "External Events Topic", "description": "Configures the creation of a Kafka topic for external events using Spring Kafka Admin.", "queueOrTopicName": "Configured via fineractProperties.getEvents().getExternal().getProducer().getKafka().getTopic().getName()", "direction": "PRODUCER", "connectionInfo": "Configured via fineractProperties.getRemoteJobMessageHandler().getKafka().getBootstrapServers()" }, { "namespace": "org.apache.fineract.infrastructure.event.external.config.ExternalEventJMSConfiguration", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/config/ExternalEventJMSConfiguration.java", "mechanism": "ACTIVEMQ-TOPIC", "name": "externalEventDestination", "description": "ActiveMQ Topic for publishing external events", "queueOrTopicName": "Configured via property: fineract.events.external.producer.jms.eventTopicName", "direction": "PRODUCER", "connectionInfo": "Broker URL configured via property: fineract.events.external.producer.jms.brokerUrl" }, { "namespace": "org.apache.fineract.infrastructure.event.external.config.ExternalEventJMSConfiguration", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/config/ExternalEventJMSConfiguration.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "externalEventDestination", "description": "ActiveMQ Queue for publishing external events", "queueOrTopicName": "Configured via property: fineract.events.external.producer.jms.eventQueueName", "direction": "PRODUCER", "connectionInfo": "Broker URL configured via property: fineract.events.external.producer.jms.brokerUrl" }, { "namespace": "org.apache.fineract.infrastructure.event.external.jobs.PurgeExternalEventsConfig", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/event/external/jobs/PurgeExternalEventsConfig.java", "mechanism": "OTHER", "name": "PURGE_EXTERNAL_EVENTS", "description": "Spring Batch Job definition for purging external events", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.event.external.jobs.SendAsynchronousEventsTasklet", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/event/external/jobs/SendAsynchronousEventsTasklet.java", "mechanism": "JMS-TOPIC", "name": "External Event Producer (JMS)", "description": "Sends external events to a JMS provider if enabled in configuration.", "messageType": "Avro (MessageV1)", "direction": "PRODUCER", "protocol": "JMS" }, { "namespace": "org.apache.fineract.infrastructure.event.external.jobs.SendAsynchronousEventsTasklet", "filepath": "fineract-core/src/main/java/org/apache/fineract/infrastructure/event/external/jobs/SendAsynchronousEventsTasklet.java", "mechanism": "KAFKA-TOPIC", "name": "External Event Producer (Kafka)", "description": "Sends external events to a Kafka topic if enabled in configuration.", "messageType": "Avro (MessageV1)", "direction": "PRODUCER", "protocol": "Kafka" }, { "namespace": "org.apache.fineract.infrastructure.event.external.jobs.SendAsynchronousEventsTaskletTest", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/event/external/jobs/SendAsynchronousEventsTaskletTest.java", "mechanism": "JMS-QUEUE", "name": "ExternalEventProducer", "description": "The code configures and uses an ExternalEventProducer to send asynchronous events. The configuration explicitly enables JMS properties.", "path": "n/a", "method": "n/a", "queueOrTopicName": "unknown", "messageType": "MessageV1", "direction": "PRODUCER", "requestBody": "byte[] (Serialized Avro Message)", "responseBody": "n/a", "authentication": "unknown", "protocol": "JMS", "connectionInfo": "n/a" }, { "namespace": "org.apache.fineract.infrastructure.event.external.producer.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/producer/jms/JMSMultiExternalEventProducer.java", "mechanism": "JMS-TOPIC", "name": "externalEventDestination", "description": "Sends external events to a JMS destination (inferred as a Topic due to 'Event' naming, though implemented as a generic Destination).", "messageType": "byte[]", "direction": "PRODUCER", "connectionInfo": "Injected ConnectionFactory bean 'externalEventConnectionFactory'" }, { "namespace": "org.apache.fineract.infrastructure.event.external.producer.jms", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/event/external/producer/jms/JMSMultiExternalEventProducerTest.java", "mechanism": "JMS-TOPIC", "name": "External Events Producer", "description": "Produces external events to a JMS destination (Topic or Queue) using Jakarta JMS API.", "queueOrTopicName": "destination (mocked)", "messageType": "BytesMessage", "direction": "PRODUCER", "protocol": "JMS" }, { "namespace": "org.apache.fineract.infrastructure.event.external.producer.kafka", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/event/external/producer/kafka/KafkaExternalEventProducerTest.java", "mechanism": "KAFKA-TOPIC", "name": "unit-test", "description": "The test verifies a producer that sends binary messages to a Kafka topic.", "queueOrTopicName": "unit-test", "messageType": "byte[]", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.event.external.producer.kafka", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/event/external/producer/kafka/KafkaExternalEventProducer.java", "mechanism": "KAFKA-TOPIC", "name": "Configured via fineractProperties", "description": "Produces binary event messages to a Kafka topic defined in the application properties.", "queueOrTopicName": "kafkaProperties.getTopic().getName()", "messageType": "byte[]", "direction": "PRODUCER", "connectionInfo": "Managed by Spring KafkaTemplate" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Register Device", "description": "Endpoint to register a new device.", "path": "/v1/self/device/registration", "method": "POST", "requestBody": "JSON object containing clientId and registrationId", "responseBody": "JSON containing the ID of the created registration" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Retrieve All Device Registrations", "description": "Endpoint to retrieve all device registrations.", "path": "/v1/self/device/registration", "method": "GET", "responseBody": "JSON array of device registration data" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Retrieve Device Registration by Client ID", "description": "Endpoint to retrieve device registration for a specific client.", "path": "/v1/self/device/registration/client/{clientId}", "method": "GET", "responseBody": "JSON object of device registration data" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Retrieve Device Registration by ID", "description": "Endpoint to retrieve a specific device registration.", "path": "/v1/self/device/registration/{id}", "method": "GET", "responseBody": "JSON object of device registration data" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Update Device Registration", "description": "Endpoint to update an existing device registration.", "path": "/v1/self/device/registration/{id}", "method": "PUT", "requestBody": "JSON object containing clientId and registrationId", "responseBody": "JSON containing the ID of the updated registration" }, { "namespace": "org.apache.fineract.infrastructure.gcm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/api/DeviceRegistrationApiResource.java", "mechanism": "REST", "name": "Delete Device Registration", "description": "Endpoint to delete a device registration.", "path": "/v1/self/device/registration/{id}", "method": "DELETE", "responseBody": "JSON object containing the ID of the deleted resource" }, { "namespace": "org.apache.fineract.infrastructure.gcm.domain", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/domain/Sender.java", "mechanism": "REST", "name": "GCM/FCM Send Endpoint", "description": "Sends downstream messages to the Google Cloud Messaging (or Firebase Cloud Messaging) server.", "path": "Configured via 'endpoint' field (typically https://fcm.googleapis.com/fcm/send)", "method": "POST", "requestBody": "JSON payload containing 'to' or 'registration_ids', and message data/notification fields.", "responseBody": "JSON object containing multicast_id, success, failure, canonical_ids, and results array.", "authentication": "Authorization Header with API Key", "protocol": "HTTP/1.1", "connectionInfo": "Managed via HttpURLConnection" }, { "namespace": "org.apache.fineract.infrastructure.gcm.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/gcm/service/NotificationSenderService.java", "mechanism": "REST", "name": "GCM/FCM Notification Service", "description": "Sends push notifications to mobile devices via Google Cloud Messaging or Firebase Cloud Messaging.", "path": "Defined in notificationConfigurationData.getFcmEndPoint()", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON payload containing notification title, body, and priority", "responseBody": "JSON result containing success/failure counts", "authentication": "Server Key (API Key)", "protocol": "HTTP/1.1", "connectionInfo": "Endpoint URL provided by ExternalServicesPropertiesReadPlatformService" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Retrieve Hooks", "description": "Returns the list of hooks.", "path": "/v1/hooks", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of HookData" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Retrieve a Hook", "description": "Returns the details of a Hook.", "path": "/v1/hooks/{hookId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object of HookData" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Retrieve Hooks Template", "description": "Returns the template data for creating hooks.", "path": "/v1/hooks/template", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object of HookData template" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Create a Hook", "description": "Creates a new hook.", "path": "/v1/hooks", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with name, isActive, events, config, etc.", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Update a Hook", "description": "Updates the details of a hook.", "path": "/v1/hooks/{hookId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with updated fields", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResource.java", "mechanism": "REST", "name": "Delete a Hook", "description": "Deletes a hook.", "path": "/v1/hooks/{hookId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.hooks.api.HookApiResourceSwagger", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/api/HookApiResourceSwagger.java", "mechanism": "REST", "name": "Hook API Schemas", "description": "Defines the request and response schemas (DTOs) for the Hooks REST API documentation using Swagger annotations. These classes describe the JSON payloads for POST, GET, PUT, and DELETE operations on hooks.", "path": "n/a", "method": "n/a", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.hooks.listener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/listener/FineractHookListener.java", "mechanism": "OTHER", "name": "onApplicationEvent", "description": "Spring Application Event Listener for HookEvent", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookProcessor.java", "mechanism": "REST", "name": "WebHook Notification", "description": "Sends HTTP requests (WebHooks) to external URLs configured in the Hook entity.", "path": "Dynamic (determined by Hook configuration)", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON or Form-UrlEncoded map depending on configuration", "protocol": "HTTP/HTTPS", "connectionInfo": "URL defined in HookConfiguration" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookService.java", "mechanism": "REST", "name": "sendEmptyRequest", "description": "Ping/Health check call to the webhook endpoint.", "path": ".", "method": "GET", "direction": "PRODUCER", "protocol": "HTTP", "connectionInfo": "Configured via Retrofit base URL" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookService.java", "mechanism": "REST", "name": "sendJsonRequest", "description": "Sends a JSON webhook payload with context headers.", "path": ".", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON Object", "protocol": "HTTP", "connectionInfo": "Configured via Retrofit base URL" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookService.java", "mechanism": "REST", "name": "sendFormRequest", "description": "Sends a Form-URL-Encoded webhook payload with context headers.", "path": ".", "method": "POST", "direction": "PRODUCER", "requestBody": "Form Data (Map)", "protocol": "HTTP", "connectionInfo": "Configured via Retrofit base URL" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookService.java", "mechanism": "REST", "name": "sendSmsBridgeRequest", "description": "Sends a JSON payload to an SMS bridge with an API key.", "path": ".", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON Object", "authentication": "API Key (X-Fineract-API-Key)", "protocol": "HTTP", "connectionInfo": "Configured via Retrofit base URL" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/WebHookService.java", "mechanism": "REST", "name": "sendSmsBridgeConfigRequest", "description": "Sends SMS provider configuration data.", "path": "/configuration", "method": "POST", "direction": "PRODUCER", "requestBody": "SmsProviderData JSON", "protocol": "HTTP", "connectionInfo": "Configured via Retrofit base URL" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor.ElasticSearchHookProcessor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/ElasticSearchHookProcessor.java", "mechanism": "REST", "name": "WebHookService", "description": "Sends an HTTP request (JSON or Form URL Encoded) to an external URL defined in the hook configuration.", "path": "Dynamic (determined by hook configuration)", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object or Form Map containing the event payload", "protocol": "HTTP", "connectionInfo": "URL defined in HookConfiguration" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor.MessageGatewayHookProcessor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/MessageGatewayHookProcessor.java", "mechanism": "OTHER", "name": "SMS Service Integration", "description": "Integrates with an internal SMS scheduling service to trigger message delivery.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor.ProcessorHelper", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/ProcessorHelper.java", "mechanism": "REST", "name": "WebHookService Client", "description": "Dynamically creates a REST client to send webhook notifications to external URLs.", "direction": "PRODUCER", "protocol": "HTTP/HTTPS", "connectionInfo": "Dynamic URL passed to createWebHookService" }, { "namespace": "org.apache.fineract.infrastructure.hooks.processor.TwilioHookProcessor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/processor/TwilioHookProcessor.java", "mechanism": "REST", "name": "SMS Bridge Service", "description": "Communicates with an external SMS bridge or Twilio service to send SMS messages and retrieve configuration.", "path": "Dynamic (based on smsProviderData.getUrl())", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON payload containing SMS details or configuration request", "responseBody": "API Key string or Void", "protocol": "HTTP", "connectionInfo": "Configured via smsProviderData.getUrl()" }, { "namespace": "org.apache.fineract.infrastructure.hooks.service.HookWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/hooks/service/HookWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "REST", "name": "WebHook Validation", "description": "Validates the payload URL provided in the hook configuration by sending a test request.", "path": "Dynamic (based on payloadURL configuration)", "method": "GET/POST (implied by sendEmptyRequest)", "direction": "PRODUCER", "requestBody": "Empty", "responseBody": "Ignored (checks for connectivity/success)", "authentication": "None visible", "protocol": "HTTP/HTTPS" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/instancemode/api/InstanceModeApiResource.java", "mechanism": "REST", "name": "changeMode", "description": "Endpoint to update the instance mode configuration.", "path": "/v1/instance-mode", "method": "PUT", "requestBody": "JSON object (ChangeInstanceModeRequest) containing boolean flags for read, write, and batch modes.", "responseBody": "Empty HTTP 200 OK response.", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.api.InstanceModeApiResourceSwagger", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/instancemode/api/InstanceModeApiResourceSwagger.java", "mechanism": "REST", "name": "ChangeInstanceModeRequest", "description": "Defines the request body schema for the REST API endpoint responsible for updating instance modes.", "direction": "CONSUMER", "requestBody": "JSON object with boolean fields: readEnabled, writeEnabled, batchWorkerEnabled, batchManagerEnabled" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Loans API", "description": "The test simulates requests to the Loans API to verify access control.", "path": "/v1/loans", "method": "GET, POST, PUT" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Actuator Health", "description": "The test simulates requests to the Actuator Health endpoint to verify it is always accessible.", "path": "/actuator/health", "method": "GET" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Jobs API", "description": "The test simulates requests to the Jobs API to verify batch mode restrictions.", "path": "/v1/jobs", "method": "GET, POST" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Batches API", "description": "The test simulates requests to the Batches API.", "path": "/v1/batches", "method": "POST" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Loan Catch-Up API", "description": "The test simulates requests to the Loan Catch-Up API to verify batch manager restrictions.", "path": "/v1/loans/catch-up", "method": "POST" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilterTest.java", "mechanism": "REST", "name": "Scheduler API", "description": "The test simulates requests to the Scheduler API to verify batch manager restrictions.", "path": "/v1/scheduler", "method": "POST" }, { "namespace": "org.apache.fineract.infrastructure.instancemode.filter", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/instancemode/filter/FineractInstanceModeApiFilter.java", "mechanism": "REST", "name": "Instance Mode Filter", "description": "Intercepts and filters all incoming REST API requests to enforce application instance mode restrictions (Read-Only vs Write).", "path": "/*", "method": "ALL", "direction": "BOTH", "responseBody": "ApiGlobalErrorResponse (JSON) on rejection" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerApiResource.java", "mechanism": "REST", "name": "Retrieve Scheduler Status", "description": "Endpoint to check if the scheduler is currently running.", "path": "/v1/scheduler", "method": "GET", "responseBody": "JSON object containing active status (SchedulerDetailData)", "authentication": "PlatformSecurityContext (User Permissions)" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerApiResource.java", "mechanism": "REST", "name": "Change Scheduler Status", "description": "Endpoint to start or stop the scheduler.", "path": "/v1/scheduler", "method": "POST", "requestBody": "None (uses query parameter 'command')", "responseBody": "HTTP 202 Accepted on success", "authentication": "PlatformSecurityContext (User Permissions)" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/InlineJobApiResource.java", "mechanism": "REST", "name": "executeInlineJob", "description": "Endpoint to start an inline Job", "path": "/v1/jobs/{jobName}/inline", "method": "POST", "requestBody": "application/json (InlineJobRequest)", "responseBody": "application/json (InlineJobResponse)" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api.SchedulerJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerJobApiResource.java", "mechanism": "REST", "name": "Retrieve Scheduler Jobs", "description": "Endpoint to retrieve all scheduler jobs.", "path": "/v1/jobs", "method": "GET", "responseBody": "JSON array of JobDetailData" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api.SchedulerJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerJobApiResource.java", "mechanism": "REST", "name": "Retrieve a Job", "description": "Endpoint to retrieve details of a specific job.", "path": "/v1/jobs/{jobId}", "method": "GET", "responseBody": "JSON object of JobDetailData" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api.SchedulerJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerJobApiResource.java", "mechanism": "REST", "name": "Retrieve Job Run History", "description": "Endpoint to retrieve the execution history of a job.", "path": "/v1/jobs/{jobId}/runhistory", "method": "GET", "responseBody": "JSON page of JobDetailHistoryData" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api.SchedulerJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerJobApiResource.java", "mechanism": "REST", "name": "Run a Job", "description": "Endpoint to manually execute a specific job.", "path": "/v1/jobs/{jobId}", "method": "POST", "requestBody": "JSON payload (optional parameters)", "responseBody": "Empty 202 Accepted or Error" }, { "namespace": "org.apache.fineract.infrastructure.jobs.api.SchedulerJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/api/SchedulerJobApiResource.java", "mechanism": "REST", "name": "Update a Job", "description": "Endpoint to update job details.", "path": "/v1/jobs/{jobId}", "method": "PUT", "requestBody": "JSON payload with update details", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.jobs.filter.LoanCOBApiFilter", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/filter/LoanCOBApiFilter.java", "mechanism": "REST", "name": "LoanCOBApiFilter", "description": "A Servlet Filter that intercepts HTTP requests to enforce Loan COB logic.", "path": "Dynamic (determined by helper.isOnApiList)", "method": "ALL", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.jobs.filter.LoanCOBApiFilterTest", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/jobs/filter/LoanCOBApiFilterTest.java", "mechanism": "REST", "name": "Loan API", "description": "The test simulates interception of REST API calls to the Loan resource.", "path": "/v1/loans/{loanId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.jobs.filter.LoanCOBApiFilterTest", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/jobs/filter/LoanCOBApiFilterTest.java", "mechanism": "REST", "name": "Reschedule Loan API", "description": "The test simulates interception of REST API calls to the Reschedule Loan resource.", "path": "/v1/rescheduleloans/{requestId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/JobRegisterServiceImpl.java", "mechanism": "OTHER", "name": "Quartz Scheduler", "description": "In-memory job scheduling using the Quartz framework to manage job execution and timing.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/SchedulerVetoer.java", "mechanism": "OTHER", "name": "Quartz Scheduler Veto", "description": "Integrates with the Quartz Scheduler library to intercept and potentially veto job triggers before execution.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/SchedulerTriggerListener.java", "mechanism": "OTHER", "name": "Quartz Scheduler Listener", "description": "Implements the Quartz TriggerListener interface to intercept job scheduling events.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/SchedulerStopListener.java", "mechanism": "OTHER", "name": "Quartz Job Listener", "description": "Listens to Quartz job execution events to trigger scheduler shutdown.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service.SchedulerJobListener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/SchedulerJobListener.java", "mechanism": "OTHER", "name": "Quartz Scheduler Listener", "description": "Listens to Quartz Scheduler events to manage job context and history.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.jobs.service.updatenpa", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/jobs/service/updatenpa/UpdateNpaConfig.java", "mechanism": "OTHER", "name": "UPDATE_NPA", "description": "Spring Batch Job definition for updating Non-Performing Assets", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.report.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/report/service/ReportingProcessService.java", "mechanism": "REST", "name": "Report Processing Service", "description": "This interface uses JAX-RS types (Response, MultivaluedMap) to handle HTTP-based report requests, acting as a service layer for REST endpoints.", "path": "n/a", "method": "n/a", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResourceSwagger.java", "mechanism": "REST", "name": "Report Mailing Job API Schemas", "description": "Defines the request and response body schemas (DTOs) for the Report Mailing Job REST API. These classes are used by the Swagger framework to generate the API documentation contract.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobRunHistoryApiResource.java", "mechanism": "REST", "name": "List Report Mailing Job History", "description": "Endpoint to retrieve the history of report mailing job runs.", "path": "/v1/{REPORT_MAILING_JOB_RUN_HISTORY_RESOURCE_NAME}", "method": "GET", "requestBody": "None (Query Parameters)", "responseBody": "JSON array of ReportMailingJobRunHistoryData", "authentication": "Platform Security Context (User Permissions)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "createReportMailingJob", "description": "Create a new Report Mailing Job", "path": "/v1/reportmailingjobs", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with job details (name, startDateTime, stretchyReportId, etc.)", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "updateReportMailingJob", "description": "Update an existing Report Mailing Job", "path": "/v1/reportmailingjobs/{entityId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "deleteReportMailingJob", "description": "Delete a Report Mailing Job", "path": "/v1/reportmailingjobs/{entityId}", "method": "DELETE", "direction": "CONSUMER", "requestBody": "Optional JSON body", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "retrieveReportMailingJob", "description": "Retrieve a specific Report Mailing Job", "path": "/v1/reportmailingjobs/{entityId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing ReportMailingJobData" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "retrieveReportMailingJobTemplate", "description": "Retrieve Report Mailing Job Template", "path": "/v1/reportmailingjobs/template", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing template options" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.api.ReportMailingJobApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/api/ReportMailingJobApiResource.java", "mechanism": "REST", "name": "retrieveAllReportMailingJobs", "description": "List all Report Mailing Jobs", "path": "/v1/reportmailingjobs", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of ReportMailingJobData" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.service.ReportMailingJobEmailService", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/service/ReportMailingJobEmailService.java", "mechanism": "OTHER", "name": "sendEmailWithAttachment", "description": "Defines an integration point for sending emails via an SMTP server or email API, though the specific protocol is determined by the implementation.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.reportmailingjob.service.ReportMailingJobEmailServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/reportmailingjob/service/ReportMailingJobEmailServiceImpl.java", "mechanism": "OTHER", "name": "SMTP Email Sender", "description": "Sends emails using the Jakarta Mail API via Spring's JavaMailSenderImpl.", "direction": "PRODUCER", "protocol": "SMTP", "connectionInfo": "Dynamic (configured via database properties GMAIL_SMTP_SERVER, GMAIL_SMTP_PORT)" }, { "namespace": "org.apache.fineract.infrastructure.s3", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/s3/AmazonS3Config.java", "mechanism": "OTHER", "name": "AWS S3 Client", "description": "Configures the AWS SDK v2 S3 Client for interacting with Amazon S3 storage.", "direction": "BOTH", "protocol": "HTTPS (AWS SDK)", "connectionInfo": "Managed by DefaultAwsRegionProviderChain and DefaultCredentialsProvider" }, { "namespace": "org.apache.fineract.infrastructure.s3", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/s3/AmazonS3ConfigCondition.java", "mechanism": "OTHER", "name": "AWS SDK Credential Validation", "description": "Validates connectivity and configuration for Amazon Web Services by attempting to resolve credentials and the default region.", "direction": "CONSUMER", "protocol": "AWS SDK / HTTPS", "connectionInfo": "AWS Default Provider Chain" }, { "namespace": "org.apache.fineract.infrastructure.s3.LocalstackS3ClientCustomizer", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/s3/LocalstackS3ClientCustomizer.java", "mechanism": "OTHER", "name": "AWS S3 Client Configuration", "description": "Configures the AWS SDK S3 Client to connect to a custom endpoint (LocalStack) for testing purposes.", "path": "AWS_ENDPOINT_URL (Environment Variable)", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.s3.S3ClientCustomizer", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/s3/S3ClientCustomizer.java", "mechanism": "OTHER", "name": "AWS S3 Configuration", "description": "Configures the AWS SDK S3 Client Builder", "path": "n/a", "method": "n/a", "direction": "OTHER", "protocol": "AWS SDK v2", "connectionInfo": "Configured via S3ClientBuilder" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/AuthenticationApiResource.java", "mechanism": "REST", "name": "authenticate", "description": "Endpoint for user authentication via username/password.", "path": "/v1/authentication", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON object with 'username' and 'password'", "responseBody": "JSON object containing AuthenticatedUserData (roles, permissions, token)" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/UserDetailsApiResource.java", "mechanism": "REST", "name": "Fetch authenticated user details", "description": "Endpoint to retrieve details of the currently logged-in user.", "path": "/v1/userdetails", "method": "GET", "responseBody": "JSON representation of AuthenticatedOauthUserData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/TwoFactorApiResource.java", "mechanism": "REST", "name": "Get OTP Delivery Methods", "description": "Endpoint to retrieve available OTP delivery methods for the user.", "path": "/v1/twofactor", "method": "GET", "responseBody": "JSON array of OTPDeliveryMethod" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/TwoFactorApiResource.java", "mechanism": "REST", "name": "Request OTP Token", "description": "Endpoint to request a new OTP token.", "path": "/v1/twofactor", "method": "POST", "requestBody": "Query parameters: deliveryMethod, extendedToken", "responseBody": "JSON object of OTPMetadata" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/TwoFactorApiResource.java", "mechanism": "REST", "name": "Validate OTP Token", "description": "Endpoint to validate an OTP token.", "path": "/v1/twofactor/validate", "method": "POST", "requestBody": "Query parameter: token", "responseBody": "JSON object of AccessTokenData" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/TwoFactorApiResource.java", "mechanism": "REST", "name": "Invalidate Token", "description": "Endpoint to invalidate a 2FA access token.", "path": "/v1/twofactor/invalidate", "method": "POST", "requestBody": "JSON body containing command details", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/TwoFactorConfigurationApiResource.java", "mechanism": "REST", "name": "TwoFactor Configuration API", "description": "API endpoints for configuring Two-Factor Authentication settings.", "path": "/v1/twofactor/configure", "method": "GET, PUT", "requestBody": "JSON (for PUT)", "responseBody": "JSON", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/api/AuthenticationApiResourceSwagger.java", "mechanism": "REST", "name": "Authentication API Schemas", "description": "Defines the Swagger/OpenAPI schemas for the authentication REST API request and response bodies.", "direction": "BOTH", "requestBody": "PostAuthenticationRequest (username, password)", "responseBody": "PostAuthenticationResponse (userId, base64EncodedAuthenticationKey, roles, permissions)" }, { "namespace": "org.apache.fineract.infrastructure.security.filter", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/filter/TenantAwareTenantIdentifierFilter.java", "mechanism": "REST", "name": "Tenant Identifier Filter", "description": "Intercepts HTTP requests to the API to extract tenant headers and configure the security context.", "path": "/api/v1/", "method": "GET, POST, PUT, DELETE, OPTIONS", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.security.filter", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/filter/TwoFactorAuthenticationFilter.java", "mechanism": "REST", "name": "TwoFactorAuthenticationFilter", "description": "Intercepts HTTP requests to validate a custom Two-Factor Authentication header.", "path": "/*", "method": "ANY", "authentication": "Custom Header: Fineract-Platform-TFA-Token", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.security.filter.TenantAwareBasicAuthenticationFilter", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/filter/TenantAwareBasicAuthenticationFilter.java", "mechanism": "REST", "name": "Tenant Authentication Filter", "description": "Intercepts all HTTP requests to validate the 'Fineract-Platform-TenantId' header and Basic Auth credentials.", "path": "/*", "method": "ALL", "direction": "CONSUMER", "authentication": "Basic Auth + Tenant ID Header", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.infrastructure.security.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/service/SpringSecurityPlatformSecurityContext.java", "mechanism": "OTHER", "name": "Spring Security Context", "description": "Consumes the Spring Security Context to retrieve authentication details.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.security.service.CustomAuthenticationFailureHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/service/CustomAuthenticationFailureHandler.java", "mechanism": "REST", "name": "Authentication Failure Response", "description": "Handles HTTP responses for failed authentication attempts.", "path": "Dynamic (determined by defaultFailureUrl)", "method": "N/A (Response Handler)", "direction": "PRODUCER", "responseBody": "HTTP 401 Error or Redirect/Forward content", "protocol": "HTTP/HTTPS" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Retrieve All SMS", "description": "Endpoint to retrieve all SMS messages.", "path": "/v1/sms", "method": "GET", "responseBody": "JSON array of SmsData" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Create SMS", "description": "Endpoint to create a new SMS message.", "path": "/v1/sms", "method": "POST", "requestBody": "JSON object representing SMS details", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Retrieve One SMS", "description": "Endpoint to retrieve a single SMS message by ID.", "path": "/v1/sms/{resourceId}", "method": "GET", "responseBody": "JSON object of SmsData" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Retrieve SMS by Status", "description": "Endpoint to retrieve SMS messages for a campaign filtered by status and date range.", "path": "/v1/sms/{campaignId}/messageByStatus", "method": "GET", "responseBody": "JSON Page of SmsData" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Update SMS", "description": "Endpoint to update an existing SMS message.", "path": "/v1/sms/{resourceId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.sms.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/api/SmsApiResource.java", "mechanism": "REST", "name": "Delete SMS", "description": "Endpoint to delete an SMS message.", "path": "/v1/sms/{resourceId}", "method": "DELETE", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.sms.data.SmsMessageApiQueueResourceData", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/data/SmsMessageApiQueueResourceData.java", "mechanism": "REST", "name": "SMS Queue Resource", "description": "Defines the request body structure for the SMS queue API endpoint.", "path": "/queue", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON representation of SmsMessageApiQueueResourceData", "responseBody": "unknown" }, { "namespace": "org.apache.fineract.infrastructure.sms.data.SmsMessageApiReportResourceData", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/data/SmsMessageApiReportResourceData.java", "mechanism": "REST", "name": "SMS Report Resource", "description": "This class defines the request body structure for the SMS report endpoint.", "path": "/report", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object containing externalIds and mifosTenantIdentifier" }, { "namespace": "org.apache.fineract.infrastructure.sms.scheduler.SmsMessageScheduledJobServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/sms/scheduler/SmsMessageScheduledJobServiceImpl.java", "mechanism": "REST", "name": "SMS Gateway", "description": "Sends SMS message data to an intermediate SMS gateway server.", "path": "Dynamic (configured via SmsConfigUtils)", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON string of SmsMessageApiQueueResourceData collection", "responseBody": "String (checked for HttpStatus.ACCEPTED)", "protocol": "HTTP", "connectionInfo": "Configured via SmsConfigUtils" }, { "namespace": "org.apache.fineract.infrastructure.springbatch", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/InputChannelInterceptor.java", "mechanism": "OTHER", "name": "Spring Integration Channel Interceptor", "description": "Intercepts messages in a Spring Integration flow to propagate Fineract context (Tenant/User) to the execution thread.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.infrastructure.springbatch", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/ManagerConfig.java", "mechanism": "OTHER", "name": "outboundRequests", "description": "Spring Integration DirectChannel used for internal message routing of outbound requests within the batch manager context.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.OutputChannelInterceptor", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/OutputChannelInterceptor.java", "mechanism": "OTHER", "name": "Spring Integration Channel Interceptor", "description": "Intercepts Spring Messaging channels to inject Fineract context into StepExecutionRequests.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.WorkerConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/WorkerConfig.java", "mechanism": "OTHER", "name": "inboundRequests", "description": "Spring Integration QueueChannel for internal message passing within the batch worker context.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/StepExecutionRequestHandler.java", "mechanism": "OTHER", "name": "StepExecutionRequest Handler", "description": "Consumes StepExecutionRequests to process batch partitions. Code comments explicitly state a JMS queue is used for message delivery, though the JMS listener annotation is likely configured externally or via Spring Integration XML.", "messageType": "StepExecutionRequest", "direction": "CONSUMER", "requestBody": "StepExecutionRequest object containing jobExecutionId, stepExecutionId, and stepName" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/jms/JmsWorkerConfig.java", "mechanism": "JMS-QUEUE", "name": "Request Queue (Dynamic)", "description": "Listens for batch job requests on a JMS queue configured via application properties.", "queueOrTopicName": "fineractProperties.getRemoteJobMessageHandler().getJms().getRequestQueueName()", "direction": "CONSUMER", "protocol": "JMS", "connectionInfo": "Managed by jakarta.jms.ConnectionFactory" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/jms/JmsBatchWorkerMessageListener.java", "mechanism": "JMS-QUEUE", "name": "BatchWorkerQueue", "description": "Consumes JMS messages representing partitioned batch step execution requests.", "messageType": "ContextualMessage wrapping StepExecutionRequest", "direction": "CONSUMER", "requestBody": "Serialized ContextualMessage containing batch parameters and step context", "responseBody": "None (Void)", "protocol": "JMS", "connectionInfo": "Configured via Spring JMS container factory (not visible in this class)" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.jms", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/jms/JmsBrokerConfiguration.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "ActiveMQ Connection Factory", "description": "Configures the connection factory for the ActiveMQ message broker, enabling the application to produce and consume messages.", "direction": "BIDIRECTIONAL", "protocol": "ActiveMQ/JMS", "connectionInfo": "Configured via fineractProperties.getRemoteJobMessageHandler().getJms().getBrokerUrl()" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.jms.JmsManagerConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/jms/JmsManagerConfig.java", "mechanism": "JMS-QUEUE", "name": "Outbound Request Queue", "description": "Sends messages to a JMS queue configured in application properties.", "queueOrTopicName": "Configured via fineractProperties.getRemoteJobMessageHandler().getJms().getRequestQueueName()", "messageType": "Spring Batch Integration Message", "direction": "PRODUCER", "connectionInfo": "jakarta.jms.ConnectionFactory" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.kafka", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/kafka/KafkaManagerConfig.java", "mechanism": "KAFKA-TOPIC", "name": "Remote Job Message Handler Topic", "description": "Publishes Spring Batch step execution context messages to a Kafka topic for remote processing.", "queueOrTopicName": "Configured via fineractProperties.getRemoteJobMessageHandler().getKafka().getTopic().getName()", "messageType": "ContextualMessage (serialized as JSON)", "direction": "PRODUCER", "connectionInfo": "Bootstrap servers configured via fineractProperties" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.kafka", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/kafka/KafkaWorkerConfig.java", "mechanism": "KAFKA-TOPIC", "name": "Kafka Consumer Configuration", "description": "Configures the infrastructure for consuming Kafka messages, including deserialization and connection settings.", "direction": "CONSUMER", "protocol": "Kafka", "connectionInfo": "Bootstrap servers configured via FineractProperties" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.kafka", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/kafka/KafkaRemoteMessageListener.java", "mechanism": "KAFKA-TOPIC", "name": "${fineract.remote-job-message-handler.kafka.topic.name}", "description": "Listens for batch step execution requests distributed via Kafka.", "queueOrTopicName": "${fineract.remote-job-message-handler.kafka.topic.name}", "messageType": "ContextualMessage", "direction": "CONSUMER", "requestBody": "ContextualMessage (JSON payload containing batch context)", "responseBody": "None (Void)", "protocol": "Kafka", "connectionInfo": "Configured via Spring Boot Kafka properties" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.kafka", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/kafka/KafkaJobTopicConfig.java", "mechanism": "KAFKA-TOPIC", "name": "Remote Job Topic", "description": "Configures the creation and administration of a Kafka topic used for remote job message handling.", "queueOrTopicName": "Configured via fineractProperties.getRemoteJobMessageHandler().getKafka().getTopic().getName()", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.spring", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/spring/SpringEventWorkerConfig.java", "mechanism": "OTHER", "name": "inboundFlow", "description": "Spring Integration flow listening for internal application events", "path": "n/a", "method": "n/a", "queueOrTopicName": "inboundRequests", "messageType": "MessagingEvent", "direction": "PRODUCER", "requestBody": "org.springframework.integration.event.core.MessagingEvent", "responseBody": "n/a", "authentication": "n/a", "protocol": "Spring Application Events", "connectionInfo": "Internal Spring Context" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.spring", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/spring/SpringEventManagerConfig.java", "mechanism": "OTHER", "name": "outboundRequests", "description": "Spring Integration DirectChannel used as the source of messages for the flow.", "direction": "CONSUMER", "protocol": "Spring Integration Channel" }, { "namespace": "org.apache.fineract.infrastructure.springbatch.messagehandler.spring", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/springbatch/messagehandler/spring/SpringEventManagerConfig.java", "mechanism": "OTHER", "name": "ApplicationEventPublishingMessageHandler", "description": "Publishes messages as Spring Application Events.", "direction": "PRODUCER", "protocol": "Spring Application Event" }, { "namespace": "org.apache.fineract.infrastructure.sqlbuilder", "filepath": "fineract-provider/src/test/java/org/apache/fineract/infrastructure/sqlbuilder/SqlBuilderStepDefinitions.java", "mechanism": "OTHER", "name": "Cucumber Test Steps", "description": "Defines Gherkin step definitions for automated testing.", "path": "n/a", "method": "n/a", "direction": "OTHER" }, { "namespace": "org.apache.fineract.infrastructure.survey.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/LikelihoodApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Endpoint to retrieve all likelihoods for a given PPI name.", "path": "/v1/likelihood/{ppiName}", "method": "GET", "direction": "PRODUCER", "requestBody": "None", "responseBody": "JSON array of LikelihoodData" }, { "namespace": "org.apache.fineract.infrastructure.survey.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/LikelihoodApiResource.java", "mechanism": "REST", "name": "retrieve", "description": "Endpoint to retrieve a specific likelihood by ID.", "path": "/v1/likelihood/{ppiName}/{likelihoodId}", "method": "GET", "direction": "PRODUCER", "requestBody": "None", "responseBody": "JSON object of LikelihoodData" }, { "namespace": "org.apache.fineract.infrastructure.survey.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/LikelihoodApiResource.java", "mechanism": "REST", "name": "update", "description": "Endpoint to update a specific likelihood.", "path": "/v1/likelihood/{ppiName}/{likelihoodId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object representing likelihood updates", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.infrastructure.survey.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/PovertyLineApiResource.java", "mechanism": "REST", "name": "Get Poverty Line by PPI Name", "description": "Retrieves poverty line data for a specific PPI name.", "path": "/v1/povertyLine/{ppiName}", "method": "GET", "requestBody": "None", "responseBody": "JSON (PpiPovertyLineData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.survey.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/PovertyLineApiResource.java", "mechanism": "REST", "name": "Get Poverty Line by Likelihood", "description": "Retrieves poverty line data for a specific PPI name and likelihood ID.", "path": "/v1/povertyLine/{ppiName}/{likelihoodId}", "method": "GET", "requestBody": "None", "responseBody": "JSON (LikeliHoodPovertyLineData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "retrieveSurveys", "description": "Endpoint to retrieve all surveys.", "path": "/v1/survey", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of SurveyDataTableData", "authentication": "PlatformSecurityContext (OAuth/Basic inferred)" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "retrieveSurvey", "description": "Endpoint to retrieve a specific survey by name.", "path": "/v1/survey/{surveyName}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object of SurveyDataTableData", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "createDatatableEntry", "description": "Endpoint to create a survey entry.", "path": "/v1/survey/{surveyName}/{apptableId}", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON payload defined by SurveyApiResourceSwagger.PostSurveySurveyNameApptableIdRequest", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "getClientSurveyOverview", "description": "Endpoint to get survey scores for a client.", "path": "/v1/survey/{surveyName}/{clientId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of ClientScoresOverview", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "getSurveyEntry", "description": "Endpoint to get a specific survey entry.", "path": "/v1/survey/{surveyName}/{clientId}/{entryId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object (GenericResultsetData)", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "register", "description": "Endpoint to register a survey.", "path": "/v1/survey/register/{surveyName}/{apptable}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON payload", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResource.java", "mechanism": "REST", "name": "deleteDatatableEntries", "description": "Endpoint to delete a survey entry.", "path": "/v1/survey/{surveyName}/{clientId}/{fulfilledId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.infrastructure.survey.api.SurveyApiResourceSwagger", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/api/SurveyApiResourceSwagger.java", "mechanism": "REST", "name": "Survey API Schemas", "description": "Defines the Swagger/OpenAPI schemas for the Survey API request and response bodies, used to generate API documentation.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.infrastructure.survey.handler.UpdateLikelihoodCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/infrastructure/survey/handler/UpdateLikelihoodCommandHandler.java", "mechanism": "OTHER", "name": "LIKELIHOOD UPDATE Command", "description": "Registers a command handler for the 'LIKELIHOOD' entity and 'UPDATE' action within the Fineract command processing infrastructure.", "path": "LIKELIHOOD/UPDATE", "direction": "CONSUMER", "requestBody": "JsonCommand", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SchedulerJobsTestResults.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to set up test data (clients, loans, savings) and trigger scheduler jobs.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON payloads for creating entities (Clients, Loans, etc.)", "responseBody": "JSON responses containing entity IDs and status details", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/AccountingScenarioIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a client consuming the Fineract REST API to perform integration tests.", "path": "Various (dynamic paths for loans, accounts, etc.)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DueDateRespectiveLoanRepaymentScheduleTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client to the Fineract application to perform loan operations.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientSavingsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Calls various Fineract REST endpoints to manage savings accounts, clients, and products.", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/RecurringDepositTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a client consuming the Fineract REST API to perform operations on Recurring Deposit accounts.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and RequestSpecBuilder" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/BatchApiTest.java", "mechanism": "REST", "name": "Fineract Batch API", "description": "Invokes the batch processing endpoint to execute multiple commands in a single request.", "path": "/batches", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract platform REST API for integration testing.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/FixedDepositTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform operations on Fixed Deposit products and accounts.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionOnChargeSubmittedDateTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithDownPaymentConfigurationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanCreditBalanceRefundandRepaymentTypeIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountTransactionsSearchIntegrationTest.java", "mechanism": "REST", "name": "Savings Account API", "description": "Integration tests consuming the Savings Account REST API to search transactions.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/AccountNumberPreferencesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to manage account number preferences and related entities (Clients, Loans, Savings, Groups, Centers).", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyAndChargebackIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform via HTTP REST API calls using RestAssured.", "path": "Various (via helpers)", "method": "GET, POST, PUT", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanReschedulingWithinCenterTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanReschedulingWithinCenterTest.java", "mechanism": "REST", "name": "Create Group", "description": "Explicit REST call to create a group within the test setup.", "path": "/fineract-provider/api/v1/groups", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON containing officeId, name, externalId, etc.", "responseBody": "JSON containing groupId" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanFixedPrincipalPercentageAmortizationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to create clients, products, and loans, and to retrieve repayment schedules.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST", "direction": "PRODUCER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ChargesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform CRUD operations on Charges.", "path": "/charges (inferred via ChargesHelper)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargebackOnPaymentTypeRepaymentTransactionsTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and RequestSpecBuilder" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRescheduleWithAdvancePaymentTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Determined by Utils.initializeRESTAssured() (typically localhost)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DisbursalAndRepaymentScheduleTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client to the Fineract application to perform integration tests.", "path": "Various (via Helper classes)", "method": "GET, POST, PUT", "direction": "PRODUCER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/NotesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class consumes the Fineract REST API to perform operations on Clients, Groups, Loans, Savings, and Notes.", "path": "/clients, /groups, /loans, /savingsaccounts, /loanTransactions, /notes", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsInterestPostingJobIntegrationTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test class acts as a REST client consuming the Fineract API to create resources (clients, accounts) and trigger jobs.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentRescheduleAtDisbursementTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() (likely localhost)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanApplicationScheduleMonthlyTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to create clients, loan products, and loan applications, and to retrieve repayment schedules.", "path": "Various (abstracted via helpers)", "method": "GET/POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/GroupLoanIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanNonTrancheMultipleDisbursementsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a client consuming the Fineract REST API to perform integration tests.", "path": "Various (e.g., /loans, /clients, /loanproducts)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SystemCodeTest.java", "mechanism": "REST", "name": "System Codes API", "description": "Consumes the application's REST API to manage system codes and code values.", "path": "/codes (inferred)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests on Client resources.", "path": "/clients (and related sub-resources)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/MinimumDaysBetweenDisbursalAndFirstRepaymentTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract Platform REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/BatchRequestsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/FundsIntegrationTest.java", "mechanism": "REST", "name": "Funds API", "description": "Consumes the Funds REST API to verify application behavior.", "path": "/funds (inferred)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountOverpaidDateStatusTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanWithAdvancedPaymentAllocationIntegrationTests.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform REST API to create and retrieve resources.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanLastRepaymentDetailsTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "Various (via helpers)", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SkipRepaymentOnMonthFirstTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "Various (handled by helpers)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanChargeExternalIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured() (typically localhost)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ConcurrencyIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests for loan management.", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountArrearsAgeingCOBBusinessStepTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test acts as a REST client consuming the Fineract application APIs to create data and trigger jobs.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured() (typically localhost)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDownPaymentTransactionTypeTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests on loan transactions.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/FinancialActivityAccountsTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to test Financial Activity Account operations.", "path": "Determined by helper classes (e.g., /financialactivityaccounts)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/IdempotencyTest.java", "mechanism": "REST", "name": "updateBusinessStepOrder", "description": "Calls the API to update the order of business steps for a specific job.", "path": "/jobs/{jobName}/steps (inferred)", "method": "PUT", "direction": "PRODUCER", "requestBody": "List JSON", "responseBody": "Empty (204) or Error JSON", "authentication": "Basic Auth" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/IdempotencyTest.java", "mechanism": "REST", "name": "getConfiguredBusinessStepsByJobName", "description": "Calls the API to retrieve the current configuration of business steps for a job.", "path": "/jobs/{jobName}/steps (inferred)", "method": "GET", "direction": "PRODUCER", "responseBody": "JobBusinessStepConfigData JSON", "authentication": "Basic Auth" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPayOffAddChargeWithRefundTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract application APIs to perform operations like creating clients, loans, and transactions.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and RequestSpecBuilder" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountFraudTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to create clients, products, and loans, and to execute commands like 'markAsFraud'.", "path": "/fineract-provider/api/v1/loans/{loanId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON payload (e.g., { \"fraud\": \"true\" })", "responseBody": "JSON response containing command processing result", "authentication": "Basic Auth (Base64 encoded credentials)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayRelationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests on loan transactions.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/BusinessConfigurationApiTest.java", "mechanism": "REST", "name": "Business Configuration API", "description": "Consumes the Fineract Business Configuration REST API to retrieve and update job business steps.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanUndoChargeOffReverseExternalIdTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform loan and account operations during testing.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountBalanceCheckAfterReversalTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductTemplateTest.java", "mechanism": "REST", "name": "Get Loan Product Template", "description": "Consumes the Fineract API to retrieve the loan product template configuration. This is done via the `LoanProductHelper` utility.", "path": "/loanproducts/template", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "GetLoanProductsTemplateResponse", "protocol": "HTTP", "connectionInfo": "Managed by LoanProductHelper" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/FlexibleSavingsInterestPostingIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform via HTTP REST APIs to perform integration tests.", "path": "Various (managed by helper classes)", "method": "Various (GET, POST, PUT)", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/UserAdministrationTest.java", "mechanism": "REST", "name": "User Administration API", "description": "Consumes the application's REST API to manage users, roles, staff, and clients for testing purposes.", "path": "/users, /roles, /staff, /clients", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/RolesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to manage Roles, Users, and Staff for testing purposes.", "path": "/roles, /users, /staff", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ShareProductDatatableIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract Core Banking Platform REST API to manage datatables and share products.", "path": "/datatables, /products/share", "method": "POST, GET", "direction": "BIDIRECTIONAL", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountsExternalIdTest.java", "mechanism": "REST", "name": "Fineract Savings Account API", "description": "Interacts with the Fineract backend to manage savings accounts via HTTP requests.", "path": "/savingsaccounts (inferred)", "method": "POST, PUT, GET, DELETE", "direction": "PRODUCER", "protocol": "HTTP", "connectionInfo": "Configured via IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductUpdateApiTest.java", "mechanism": "REST", "name": "Loan Product API", "description": "Consumes the Fineract Loan Product REST API to create, retrieve, and update loan products.", "path": "/fineract-provider/api/v1/loanproducts (inferred)", "method": "POST, PUT, GET", "direction": "PRODUCER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via REST Assured RequestSpecification" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDisbursalDateValidationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsInterestPostingIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract application REST API to perform test operations.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanAccountLockIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithRepaymentDueEventConfigurationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to create and manage loan products and related entities.", "path": "/loanproducts, /clients, /delinquencybuckets", "method": "POST, PUT, GET", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientAuditingIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/AuditIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform actions and verify audit logs.", "path": "Various (handled by Helper classes)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SchedulerJobsTest.java", "mechanism": "REST", "name": "Fineract Scheduler API", "description": "Interacts with the Fineract platform's scheduler API to manage jobs, update statuses, and trigger executions.", "path": "/jobs (inferred)", "method": "GET, PUT, POST", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanApplicationRejectionForLoanProductWithPeriodicAccrualAccountingTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test acts as a REST client consuming Fineract APIs to create resources (accounts, clients, loans) and perform actions (reject loan).", "direction": "CONSUMER", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured() (typically localhost)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanCOBCatchUpInstanceModeIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class consumes REST APIs exposed by the Fineract application to test Loan COB Catch Up and Scheduler functionality.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/InstanceModeIntegrationTest.java", "mechanism": "REST", "name": "Get Head Office", "description": "Retrieves the head office configuration via the OfficeHelper.", "path": "/offices (inferred)", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/InstanceModeIntegrationTest.java", "mechanism": "REST", "name": "Create Client", "description": "Sends a request to create a new client via the ClientHelper.", "path": "/clients (inferred)", "method": "POST", "direction": "CONSUMER", "requestBody": "PostClientsRequest JSON", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/InstanceModeIntegrationTest.java", "mechanism": "REST", "name": "Run Scheduler Job", "description": "Triggers the execution of a specific scheduler job via the SchedulerJobHelper.", "path": "/jobs/{jobId} (inferred)", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalServicesConfigurationTest.java", "mechanism": "REST", "name": "External Services Configuration API", "description": "Consumes REST endpoints to retrieve and update configuration settings for external services like S3 and SMTP.", "path": "/external-services/{serviceName}/configuration", "method": "GET, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/NotificationApiTest.java", "mechanism": "REST", "name": "Notification API", "description": "Consumes the Notification API to retrieve user notifications.", "path": "/notifications (implied via NotificationHelper)", "method": "GET", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/NotificationApiTest.java", "mechanism": "REST", "name": "User API", "description": "Consumes the User API to create a new user for testing purposes.", "path": "/users (implied via UserHelper)", "method": "POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/NotificationApiTest.java", "mechanism": "REST", "name": "Client API", "description": "Consumes the Client API to create a client and trigger a notification.", "path": "/clients (implied via ClientHelper)", "method": "POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/NotificationApiTest.java", "mechanism": "REST", "name": "Office API", "description": "Consumes the Office API to retrieve head office details.", "path": "/offices (implied via OfficeHelper)", "method": "GET", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanWithdrawnByApplicantIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests on loan management features.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/HookIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Calls to the internal application API to manage Hooks and Offices.", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/HookIntegrationTest.java", "mechanism": "REST", "name": "Echo Webhook Service", "description": "External service used to verify webhook delivery.", "path": "/{uniqueId}/", "method": "GET", "direction": "CONSUMER", "connectionInfo": "http://echo-webhook.herokuapp.com:80" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/HookIntegrationTest.java", "mechanism": "WEBHOOK", "name": "Office Creation Webhook", "description": "The test configures the application to send a webhook to an external URL.", "direction": "PRODUCER", "requestBody": "JSON containing officeId" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/PaymentTypeIntegrationTest.java", "mechanism": "REST", "name": "Payment Types API", "description": "Consumes the Payment Types REST API to perform integration testing.", "path": "/paymenttypes (inferred)", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SearchResourcesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform search operations and client management during tests.", "path": "/search, /clients", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/OfficeIntegrationTest.java", "mechanism": "REST", "name": "Office Management API", "description": "Consumes REST endpoints to create, update, and retrieve Office resources.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CurrenciesTest.java", "mechanism": "REST", "name": "Currency Management API", "description": "Interacts with the application's REST API to retrieve and update currency configurations.", "path": "/currencies (inferred from helper usage)", "method": "GET, PUT", "direction": "CONSUMER", "requestBody": "JSON list of currency codes (for updates)", "responseBody": "JSON object representing currency domain or list of currencies", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountsTest.java", "mechanism": "REST", "name": "submitApplication2", "description": "Submits a new savings account application to the Fineract backend.", "path": "/savingsaccounts", "method": "POST", "direction": "PRODUCER", "requestBody": "PostSavingsAccountsRequest", "responseBody": "PostSavingsAccountsResponse", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountsTest.java", "mechanism": "REST", "name": "handleCommands6 (approve)", "description": "Sends a command to approve a specific savings account.", "path": "/savingsaccounts/{savingsId}?command=approve", "method": "POST", "direction": "PRODUCER", "requestBody": "PostSavingsAccountsAccountIdRequest", "responseBody": "PostSavingsAccountsAccountIdResponse", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountsTest.java", "mechanism": "REST", "name": "handleCommands6 (activate)", "description": "Sends a command to activate a specific savings account.", "path": "/savingsaccounts/{savingsId}?command=activate", "method": "POST", "direction": "PRODUCER", "requestBody": "PostSavingsAccountsAccountIdRequest", "responseBody": "PostSavingsAccountsAccountIdResponse", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalEventConfigurationIntegrationTest.java", "mechanism": "REST", "name": "External Event Configuration API", "description": "Consumes the Fineract REST API to manage external event configurations via the ExternalEventConfigurationHelper.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductExternalIdTest.java", "mechanism": "REST", "name": "Loan Product API", "description": "Consumes the Fineract REST API to manage Loan Products.", "path": "/loanproducts (inferred via helpers)", "method": "POST, GET, PUT", "direction": "CONSUMER", "requestBody": "JSON (Loan Product details)", "responseBody": "JSON (Loan Product details or ID)", "authentication": "Basic Auth (Base64 encoded key)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientCollateralIntegrationTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "Consumes the Fineract application's REST APIs to perform integration tests via REST Assured.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/PasswordPreferencesIntegrationTest.java", "mechanism": "REST", "name": "Password Preferences API", "description": "Consumes the Fineract REST API to update and retrieve password preference settings.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/GlobalConfigInterestChargedFromDateSameAsDisbursalDateTest.java", "mechanism": "REST", "name": "Fineract Global Configuration API", "description": "Consumes the Fineract REST API to retrieve and update global configuration settings.", "path": "/configurations (inferred from helper usage)", "method": "GET, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/TemplateIntegrationTest.java", "mechanism": "REST", "name": "Templates API - List/Create", "description": "Endpoint to retrieve the list of templates or create a new template.", "path": "/fineract-provider/api/v1/templates", "method": "GET, POST", "direction": "CONSUMER", "requestBody": "JSON (for POST)", "responseBody": "JSON List or Resource ID", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/TemplateIntegrationTest.java", "mechanism": "REST", "name": "Templates API - Get/Delete", "description": "Endpoint to retrieve or delete a specific template by ID.", "path": "/fineract-provider/api/v1/templates/{id}", "method": "GET, DELETE", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON Object", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductShortNameValidationTest.java", "mechanism": "REST", "name": "Loan Product API", "description": "Calls the application's REST API to create loan products.", "path": "/loanproducts (inferred)", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object representing the loan product (principal, repayment schedule, short name, etc.)", "responseBody": "JSON response containing the resource ID or error details", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CollateralProductIntegrationTest.java", "mechanism": "REST", "name": "Collateral Product API", "description": "Consumes REST APIs to create and update collateral products.", "path": "Determined by CollateralManagementHelper", "method": "POST/PUT", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON containing resource ID", "authentication": "Basic Auth (Base64 encoded key)" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CreditBureauConfigurationTest.java", "mechanism": "REST", "name": "Credit Bureau Configuration API", "description": "Consumes the Fineract REST API to create and update credit bureau configurations.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingDaysTest.java", "mechanism": "REST", "name": "Working Days API", "description": "Consumes the Fineract REST API to update working days configuration via helper classes.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/XBRLIntegrationTest.java", "mechanism": "REST", "name": "XBRL Taxonomy API", "description": "Consumes the Fineract REST API to retrieve XBRL taxonomies.", "path": "Unknown (encapsulated in XBRLIntegrationTestHelper)", "method": "GET", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/RatesTest.java", "mechanism": "REST", "name": "Rates API", "description": "Consumes the Fineract REST API to perform operations on Rates resources (Create, Read, Update).", "direction": "CONSUMER", "authentication": "Basic Auth", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ProductMixIntegrationTest.java", "mechanism": "REST", "name": "Product Mix API", "description": "Consumes REST APIs to retrieve product mix lists and templates via the ProductMixHelper.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/MakercheckerTest.java", "mechanism": "REST", "name": "Maker Checker List", "description": "Consumes the Maker Checker API to retrieve the inbox list via the MakercheckersHelper.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SurveyIntegrationTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test class acts as a REST client to interact with the Fineract application APIs.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SwaggeruiTest.java", "mechanism": "REST", "name": "Swagger UI HTML", "description": "Accesses the Swagger UI index HTML page to verify it is being served.", "path": "/fineract-provider/swagger-ui/index.html", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SwaggeruiTest.java", "mechanism": "REST", "name": "OpenAPI JSON", "description": "Accesses the Fineract OpenAPI JSON definition to verify it is being served.", "path": "/fineract-provider/fineract.json", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ApiDocsTest.java", "mechanism": "REST", "name": "Legacy API Documentation Endpoint", "description": "Accesses the legacy API documentation HTML page to verify availability.", "path": "/fineract-provider/legacy-docs/apiLive.htm", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "HTML/Text", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ActuatorIntegrationTest.java", "mechanism": "REST", "name": "Actuator Info Endpoint", "description": "Consumes the Spring Boot Actuator info endpoint to retrieve build metadata via RestAssured.", "path": "/fineract-provider/actuator/info", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON containing git build info", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.AccountTransferTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/AccountTransferTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform setup, transfers, and verification.", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Defined in Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.AdvancedPaymentAllocationLoanRepaymentScheduleTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client to the Fineract platform, invoking endpoints for loan management.", "path": "/fineract-provider/api/v1/loans/*", "method": "POST, GET", "requestBody": "JSON (PostLoansRequest, PostLoansLoanIdTransactionsRequest, etc.)", "responseBody": "JSON (PostLoansResponse, GetLoansLoanIdResponse)", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.BaseLoanIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/BaseLoanIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform loan operations and verification.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.CenterIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CenterIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/groups", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object representing group details", "responseBody": "JSON object containing the created group ID", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.ClientExternalIdTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientExternalIdTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests on Client resources.", "path": "/clients, /configurations", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured() (likely localhost)" }, { "namespace": "org.apache.fineract.integrationtests.ClientLoanChargeRefundIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanChargeRefundIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract Core Banking Platform API to perform loan operations.", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.ClientLoanMultipleDisbursementsIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanMultipleDisbursementsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform loan operations (create, approve, disburse, repay).", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.ClientUndoRejectAndWithdrawalIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientUndoRejectAndWithdrawalIntegrationTest.java", "mechanism": "REST", "name": "Fineract API Client Operations", "description": "Invokes Fineract REST APIs to create, reject, withdraw, and undo status changes for clients.", "path": "/fineract-provider/api/v1/clients", "method": "POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.CreditBureauTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CreditBureauTest.java", "mechanism": "REST", "name": "WireMock Token Endpoint", "description": "Mocked external Credit Bureau authentication endpoint.", "path": "/token/", "method": "POST", "direction": "PRODUCER", "requestBody": "unknown", "responseBody": "JSON with access_token, expires_in, token_type, etc.", "protocol": "HTTP", "connectionInfo": "http://localhost:3558" }, { "namespace": "org.apache.fineract.integrationtests.CreditBureauTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CreditBureauTest.java", "mechanism": "REST", "name": "WireMock Search Endpoint", "description": "Mocked external Credit Bureau search endpoint to find a user by ID.", "path": "/search/NRC213", "method": "POST", "direction": "PRODUCER", "requestBody": "unknown", "responseBody": "JSON with ResponseMessage and Data containing UniqueID", "protocol": "HTTP", "connectionInfo": "http://localhost:3558" }, { "namespace": "org.apache.fineract.integrationtests.CreditBureauTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/CreditBureauTest.java", "mechanism": "REST", "name": "WireMock Report Endpoint", "description": "Mocked external Credit Bureau report retrieval endpoint.", "path": "/report/123456", "method": "GET", "direction": "PRODUCER", "requestBody": "none", "responseBody": "JSON with BorrowerInfo, CreditScore, ActiveLoans, and WriteOffLoans", "protocol": "HTTP", "connectionInfo": "http://localhost:3558" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Client Creation", "description": "Creates a new client via the API.", "path": "/clients", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (PostClientsRequest)", "responseBody": "JSON (PostClientsResponse)" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Loan Product Creation", "description": "Creates a new loan product via the API.", "path": "/loanproducts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Loan Account Creation", "description": "Attempts to create a loan account (expected to fail in this test).", "path": "/loans", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (Loan Application)", "responseBody": "JSON (Error Response)" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Interop Transaction Request", "description": "Posts an interoperation transaction request.", "path": "/interop/transactions", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Fixed Deposit Product Creation", "description": "Creates a fixed deposit product.", "path": "/fixeddepositproducts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.integrationtests.DateValidationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DateValidationTest.java", "mechanism": "REST", "name": "Fixed Deposit Application", "description": "Applies for a fixed deposit account (expected to fail in this test).", "path": "/fixeddepositaccounts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON (Error Response)" }, { "namespace": "org.apache.fineract.integrationtests.DelinquencyBucketsIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyBucketsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured() (typically localhost)" }, { "namespace": "org.apache.fineract.integrationtests.ExternalIdSupportIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalIdSupportIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a client consuming the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (via Utils helper)", "connectionInfo": "Configured via RestAssured (localhost/port determined at runtime)" }, { "namespace": "org.apache.fineract.integrationtests.GlobalConfigurationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/GlobalConfigurationTest.java", "mechanism": "REST", "name": "Global Configuration API", "description": "The test class acts as a REST client consuming the Fineract Global Configuration API to read and update system settings.", "path": "/configurations (inferred via helper)", "method": "GET, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.GroupSavingsIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/GroupSavingsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.GroupTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/GroupTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests on Groups, Clients, Staff, and Loans.", "direction": "CONSUMER", "authentication": "Basic Auth", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanAccountBackdatedDisbursementTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountBackdatedDisbursementTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the running Fineract application instance to create clients, products, loans, and perform transactions.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "BIDIRECTIONAL", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanAccountCreditRefundPayoutWithChargebackTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountCreditRefundPayoutWithChargebackTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanAccountPaymentAllocationWithOverlappingDownPaymentInstallmentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountPaymentAllocationWithOverlappingDownPaymentInstallmentTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "Various (handled by helper classes)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanApplicationApprovalTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanApplicationApprovalTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanApplicationUndoLastTrancheTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanApplicationUndoLastTrancheTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform operations like creating clients, loans, and processing transactions.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()" }, { "namespace": "org.apache.fineract.integrationtests.LoanAuditingIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAuditingIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanCOBAccountLockCatchupInlineCOBTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanCOBAccountLockCatchupInlineCOBTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform setup, configuration, and verification steps.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanCatchUpIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanCatchUpIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract application REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanChargeOffAccountingTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeOffAccountingTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "VARIOUS", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()" }, { "namespace": "org.apache.fineract.integrationtests.LoanChargeSpecificDueDateTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeSpecificDueDateTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanDisbursementDetailsIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDisbursementDetailsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Apache Fineract REST API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanMultipleDisbursementRepaymentScheduleTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanMultipleDisbursementRepaymentScheduleTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform via HTTP REST endpoints to perform integration tests.", "path": "Various (e.g., /loans, /clients, /jobs)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanPostChargeOffScenariosTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPostChargeOffScenariosTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract Core Banking Platform API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanProductRepaymentStartDateConfigurationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductRepaymentStartDateConfigurationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanProductWithAdvancedPaymentAllocationIntegrationTests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithAdvancedPaymentAllocationIntegrationTests.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming Fineract APIs to create and manage loan products and accounts.", "path": "/fineract-provider/api/v1/...", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanRepaymentScheduleWithDownPaymentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentScheduleWithDownPaymentTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to create clients, products, and loans, and to retrieve loan schedules.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and RequestSpecBuilder" }, { "namespace": "org.apache.fineract.integrationtests.LoanRescheduleOnDecliningBalanceLoanTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRescheduleOnDecliningBalanceLoanTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanRescheduleRequestTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRescheduleRequestTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the application's APIs to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/JSON" }, { "namespace": "org.apache.fineract.integrationtests.LoanSpecificDueDateChargeAfterMaturityTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanSpecificDueDateChargeAfterMaturityTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/JSON" }, { "namespace": "org.apache.fineract.integrationtests.LoanTransactionAuditingIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionAuditingIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test acts as a REST client consuming the Fineract API to perform integration testing.", "path": "Various (dynamic paths handled by helper classes)", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via RestAssured (localhost)" }, { "namespace": "org.apache.fineract.integrationtests.LoanTransactionChargebackTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionChargebackTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test class acts as a client consuming the Fineract REST API to perform loan operations.", "path": "/fineract-provider/api/v1/loans", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanTransactionFullAmountChargebackForOverpaidLoanTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionFullAmountChargebackForOverpaidLoanTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST API endpoints to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.LoanTransactionReverseReplayTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a client consuming the Fineract Platform REST API to perform integration tests.", "path": "Various (configured via RequestSpecification)", "method": "Various (GET, POST, PUT)", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanTransactionSummaryTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionSummaryTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "/fineract-provider/api/v1/*", "method": "GET, POST, PUT", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.LoanWithWaiveInterestAndWriteOffIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanWithWaiveInterestAndWriteOffIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "Various (abstracted via helpers)", "method": "GET, POST, PUT", "direction": "PRODUCER", "requestBody": "JSON", "responseBody": "JSON", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.RepaymentWithPostDatedChecksTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/RepaymentWithPostDatedChecksTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract Platform REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.SavingsAccountTransactionDatatableIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountTransactionDatatableIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract application APIs to perform integration testing.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.SavingsAccountTransactionTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/SavingsAccountTransactionTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests on savings accounts, clients, and system configurations.", "path": "Various (e.g., /savingsaccounts, /clients, /batches)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.StaffTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/StaffTest.java", "mechanism": "REST", "name": "Staff API", "description": "Integration tests consuming the Staff REST API endpoints.", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.UndoLoanDisbursalWithDownPaymentIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/UndoLoanDisbursalWithDownPaymentIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class consumes Fineract REST APIs via helper classes (ClientHelper, LoanTransactionHelper, etc.) to create clients, products, and perform loan operations.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.accounting", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/accounting/AccountingRuleIntegrationTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test class acts as a REST client consuming the Fineract application APIs to perform setup and validation steps.", "path": "Various (delegated to Helper classes)", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.client.ClientEntityImportHandlerTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/client/ClientEntityImportHandlerTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract application REST API to create prerequisites (Staff, Office, Codes) and perform bulk import operations.", "path": "/clients/downloadtemplate, /clients/uploadtemplate, /codes, /staff, /offices", "method": "POST", "direction": "BIDIRECTIONAL", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.loan.LoanImportHandlerTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/loan/LoanImportHandlerTest.java", "mechanism": "REST", "name": "Create Client", "description": "Creates a new client in the system to be used in the loan import test.", "path": "/fineract-provider/api/v1/clients", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object containing officeId, firstname, lastname, externalId, etc.", "responseBody": "JSON object containing the clientId" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.loan.LoanImportHandlerTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/loan/LoanImportHandlerTest.java", "mechanism": "REST", "name": "Import Loan Template", "description": "Uploads the generated Excel file to the bulk import endpoint via a helper class.", "path": "unknown (encapsulated in LoanTransactionHelper)", "method": "POST", "direction": "PRODUCER", "requestBody": "Multipart file upload (Excel)", "responseBody": "Import Document ID" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.office", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/office/OfficeImportHandlerTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract backend APIs to perform bulk import operations.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.savings", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/savings/SavingsImportHandlerTest.java", "mechanism": "REST", "name": "Create Client", "description": "Creates a new client in the system to be used in the import test.", "path": "/fineract-provider/api/v1/clients", "method": "POST", "requestBody": "JSON object containing officeId, legalFormId, firstname, lastname, externalId, etc.", "responseBody": "JSON object containing the clientId", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.importhandler.savings", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/importhandler/savings/SavingsImportHandlerTest.java", "mechanism": "REST", "name": "Import Savings Template", "description": "Uploads the populated Excel file to the bulk import endpoint (via SavingsAccountHelper).", "path": "/fineract-provider/api/v1/savings/import", "method": "POST", "requestBody": "Multipart file upload (Excel)", "responseBody": "Import Document ID", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.populator.client.ClientEntityWorkbookPopulatorTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/populator/client/ClientEntityWorkbookPopulatorTest.java", "mechanism": "REST", "name": "Fineract REST API", "description": "The test acts as a client consuming the Fineract REST API to create resources and download files.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.populator.loan", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/populator/loan/LoanWorkbookPopulatorTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client, consuming various endpoints of the Fineract application to create test data and retrieve the bulk import workbook.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.populator.office", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/populator/office/OfficeWorkBookPopulatorTest.java", "mechanism": "REST", "name": "Office Workbook Retrieval", "description": "Fetches the Office bulk import Excel workbook from the application server.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.bulkimport.populator.savings", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/bulkimport/populator/savings/SavingsWorkbookPopulateTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test acts as a REST client consuming Fineract APIs to create entities and retrieve the workbook.", "direction": "CONSUMER", "authentication": "Basic Auth", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ClientSearchTest.java", "mechanism": "REST", "name": "Client API", "description": "Integration tests consuming the Client REST API to create and search for clients.", "path": "/clients", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ClientTransactionTest.java", "mechanism": "REST", "name": "Fineract API Client Operations", "description": "Consumes Fineract REST APIs to create clients, manage charges, and handle transactions.", "path": "/clients, /charges, /clients/{clientId}/transactions", "method": "POST, GET", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/IntegrationTest.java", "mechanism": "REST", "name": "Fineract API Client", "description": "Configures and provides a Retrofit-based client to interact with the Fineract REST API.", "path": "/fineract-provider/api/", "method": "N/A", "connectionInfo": "https://localhost:8443/fineract-provider/api/ (default, overridable via system property 'fineract.it.url')" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ReportExportTest.java", "mechanism": "REST", "name": "runReportGetFile", "description": "Invokes the Fineract API to run a specific report and retrieve the file or trigger an export.", "path": "/runreports/{reportName}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via FineractClient" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/OfficeTest.java", "mechanism": "REST", "name": "createOffice", "description": "Creates a new office resource via the Fineract API.", "path": "/offices", "method": "POST", "direction": "CONSUMER", "requestBody": "PostOfficesRequest", "responseBody": "GetOfficesResponse (containing officeId)", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest parent class" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/OfficeTest.java", "mechanism": "REST", "name": "retrieveOffices", "description": "Retrieves a list of office resources via the Fineract API.", "path": "/offices", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "List", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest parent class" }, { "namespace": "org.apache.fineract.integrationtests.client", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/CallSubject.java", "mechanism": "REST", "name": "Retrofit Call Execution", "description": "Executes a Retrofit HTTP call to verify the response status.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Managed by Retrofit configuration" }, { "namespace": "org.apache.fineract.integrationtests.client.ClientTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ClientTest.java", "mechanism": "REST", "name": "Create Client", "description": "Calls the Fineract API to create a new client entity.", "path": "/clients", "method": "POST", "direction": "PRODUCER", "requestBody": "PostClientsRequest (JSON)", "responseBody": "Client ID (Long)", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.client.ClientTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ClientTest.java", "mechanism": "REST", "name": "Retrieve Clients", "description": "Calls the Fineract API to retrieve a paginated list of clients.", "path": "/clients", "method": "GET", "direction": "CONSUMER", "requestBody": "None (Query Parameters)", "responseBody": "GetClientsResponse (JSON)", "protocol": "HTTP", "connectionInfo": "Configured in IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "retrieveAllDocuments", "description": "Retrieves all documents for a specific entity (client).", "path": "/documents/clients/{clientId}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "createDocument", "description": "Uploads a new document for a specific entity.", "path": "/documents/clients/{clientId}", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart/form-data (file, name, description)", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "getDocument", "description": "Retrieves metadata for a specific document.", "path": "/documents/clients/{clientId}/{documentId}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "downloadFile", "description": "Downloads the binary file content of a document.", "path": "/documents/clients/{clientId}/{documentId}/attachment", "method": "GET", "direction": "CONSUMER", "responseBody": "Binary stream (image/jpeg)", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "updateDocument", "description": "Updates metadata of an existing document.", "path": "/documents/clients/{clientId}/{documentId}", "method": "PUT", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.DocumentTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/DocumentTest.java", "mechanism": "REST", "name": "deleteDocument", "description": "Deletes a specific document.", "path": "/documents/clients/{clientId}/{documentId}", "method": "DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Fineract Client" }, { "namespace": "org.apache.fineract.integrationtests.client.ImageTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ImageTest.java", "mechanism": "REST", "name": "Images API", "description": "Consumes the Fineract Images API to manage entity images.", "path": "v1/{entityType}/{entityId}/images", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.client.ImageTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ImageTest.java", "mechanism": "REST", "name": "ImagesApiWithHeadersForTest", "description": "Defines a Retrofit client interface to test specific Accept headers.", "path": "v1/{entityType}/{entityId}/images", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.client.ReportsTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/ReportsTest.java", "mechanism": "REST", "name": "Run Reports API", "description": "Client calls to the Fineract Run Reports API to list and execute reports.", "path": "/fineract-provider/api/v1/runreports/...", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured() and fineract().baseURL()" }, { "namespace": "org.apache.fineract.integrationtests.client.StaffTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/client/StaffTest.java", "mechanism": "REST", "name": "Staff API Client", "description": "Consumes the Fineract Staff REST API to create and retrieve staff members via the generated client wrapper.", "path": "/staff", "method": "POST, GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.cob.CobPartitioningTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/cob/CobPartitioningTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test acts as a REST client interacting with the Fineract platform API to create resources and trigger processes.", "path": "/fineract-provider/api/v1/...", "method": "GET/POST/PUT/DELETE", "direction": "BIDIRECTIONAL", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientHelper.java", "mechanism": "REST", "name": "Client API", "description": "Interacts with the Fineract Client API to manage client resources.", "path": "/fineract-provider/api/v1/clients", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientHelper.java", "mechanism": "REST", "name": "Client Search API", "description": "Interacts with the Client Search API.", "path": "/fineract-provider/api/v1/clientSearchV2", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientHelper.java", "mechanism": "REST", "name": "Client Charges API", "description": "Interacts with the Client Charges API to add, pay, or waive charges.", "path": "/fineract-provider/api/v1/clients/{clientId}/charges", "method": "POST, GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientHelper.java", "mechanism": "REST", "name": "Client Transactions API", "description": "Interacts with the Client Transactions API to retrieve or undo transactions.", "path": "/fineract-provider/api/v1/clients/{clientId}/transactions", "method": "GET, POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientHelper.java", "mechanism": "REST", "name": "Bulk Import API", "description": "Interacts with the Bulk Import API for downloading templates and uploading files.", "path": "/fineract-provider/api/v1/clients/downloadtemplate, /fineract-provider/api/v1/clients/uploadtemplate", "method": "GET, POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ProvisioningIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract Platform REST APIs to perform integration testing.", "path": "Various (configured via RequestSpecification)", "method": "Various (GET, POST, PUT, DELETE)", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Get Credit Bureau Configuration", "description": "Retrieves configuration details for a specific credit bureau.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/config/{creditBureauId}", "method": "GET", "direction": "CONSUMER", "responseBody": "List of configuration maps" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Create Credit Bureau Configuration", "description": "Creates a new configuration entry for a credit bureau.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/configuration/{creditBureauId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with configkey, value, description", "responseBody": "JSON with resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Update Credit Bureau Configuration", "description": "Updates an existing credit bureau configuration.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/configuration/{ConfigurationId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON with configkey (optional), value", "responseBody": "JSON with changes" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Get Organization Credit Bureau Configuration", "description": "Retrieves the organization-level credit bureau configuration.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/organisationCreditBureau", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Add Organization Credit Bureau", "description": "Adds a credit bureau mapping to the organization.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/organisationCreditBureau/{creditBureauId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with alias, isActive" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauConfigurationHelper.java", "mechanism": "REST", "name": "Update Organization Credit Bureau", "description": "Updates the organization's credit bureau mapping.", "path": "/fineract-provider/api/v1/CreditBureauConfiguration/organisationCreditBureau", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON with creditBureauId, isActive" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotesHelper.java", "mechanism": "REST", "name": "Client Notes API", "description": "API endpoints for managing notes on Clients", "path": "/fineract-provider/api/v1/clients/{clientId}/notes", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotesHelper.java", "mechanism": "REST", "name": "Group Notes API", "description": "API endpoints for managing notes on Groups", "path": "/fineract-provider/api/v1/groups/{groupId}/notes", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotesHelper.java", "mechanism": "REST", "name": "Loan Notes API", "description": "API endpoints for managing notes on Loans", "path": "/fineract-provider/api/v1/loans/{loanId}/notes", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotesHelper.java", "mechanism": "REST", "name": "Loan Transaction Notes API", "description": "API endpoints for managing notes on Loan Transactions", "path": "/fineract-provider/api/v1/loanTransactions/{loanTransactionId}/notes", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotesHelper.java", "mechanism": "REST", "name": "Savings Notes API", "description": "API endpoints for managing notes on Savings Accounts", "path": "/fineract-provider/api/v1/savings/{savingsId}/notes", "method": "POST, GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ClientChargesTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes the Fineract REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CalendarHelper.java", "mechanism": "REST", "name": "Create Group Calendar", "description": "Creates a calendar for a group via HTTP POST.", "path": "/fineract-provider/api/v1/groups/{groupId}/calendars", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with frequency, interval, repeatsOnDay, startDate, etc.", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CalendarHelper.java", "mechanism": "REST", "name": "Update Group Calendar", "description": "Updates a calendar for a group via HTTP PUT.", "path": "/fineract-provider/api/v1/groups/{groupId}/calendars/{calendarId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with frequency, interval, repeatsOnDay, startDate, etc.", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CalendarHelper.java", "mechanism": "REST", "name": "Get Group Details", "description": "Retrieves group details to verify calendar creation.", "path": "/fineract-provider/api/v1/groups/{groupId}?associations=all", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing group details and collectionMeetingCalendar", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CalendarHelper.java", "mechanism": "REST", "name": "Create Center Calendar", "description": "Creates a calendar for a center via HTTP POST.", "path": "/fineract-provider/api/v1/centers/{centerId}/calendars", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with frequency, interval, repeatsOnDay, startDate, etc.", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CalendarHelper.java", "mechanism": "REST", "name": "Update Center Calendar", "description": "Updates a calendar for a center via HTTP PUT.", "path": "/fineract-provider/api/v1/centers/{centerId}/calendars/{calendarId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with newMeetingDate, presentMeetingDate, reschedulebasedOnMeetingDates", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ExternalAssetOwnerHelper.java", "mechanism": "REST", "name": "External Asset Owners API", "description": "Interacts with the Fineract External Asset Owners REST API to manage asset transfers.", "path": "/external-asset-owners/*", "method": "GET/POST", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/WorkingDaysHelper.java", "mechanism": "REST", "name": "Working Days API", "description": "API endpoint to manage working days configuration.", "path": "/fineract-provider/api/v1/workingdays", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with recurrence rule, locale, and repayment reschedule type", "responseBody": "JSON object containing resource ID or error details" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/WorkingDaysHelper.java", "mechanism": "REST", "name": "Working Days API", "description": "API endpoint to retrieve working days configuration.", "path": "/fineract-provider/api/v1/workingdays", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing current working days configuration" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/PaymentTypeHelper.java", "mechanism": "REST", "name": "Payment Types API", "description": "Interacts with the Fineract Payment Types REST API to perform CRUD operations.", "path": "/fineract-provider/api/v1/paymenttypes", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/1.1", "connectionInfo": "Defined in Utils.TENANT_IDENTIFIER and base URL configuration" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessStepConfigurationHelper.java", "mechanism": "REST", "name": "Get Configured Business Steps", "description": "Retrieves the configured business steps for a specific job.", "path": "/fineract-provider/api/v1/jobs/{jobName}/steps", "method": "GET", "direction": "CONSUMER", "responseBody": "JobBusinessStepConfigData JSON" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessStepConfigurationHelper.java", "mechanism": "REST", "name": "Get Available Business Steps", "description": "Retrieves the available business steps for a specific job.", "path": "/fineract-provider/api/v1/jobs/{jobName}/available-steps", "method": "GET", "direction": "CONSUMER", "responseBody": "JobBusinessStepDetail JSON" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessStepConfigurationHelper.java", "mechanism": "REST", "name": "Update Business Steps", "description": "Updates the order or configuration of business steps for a job.", "path": "/fineract-provider/api/v1/jobs/{jobName}/steps", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON containing list of BusinessStep", "responseBody": "Empty or ApiParameterError on failure" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/IdempotencyHelper.java", "mechanism": "REST", "name": "Get Configured Business Steps", "description": "Retrieves the configured business steps for a specific job.", "path": "/fineract-provider/api/v1/jobs/{jobName}/steps", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/IdempotencyHelper.java", "mechanism": "REST", "name": "Get Available Business Steps", "description": "Retrieves the available business steps for a specific job.", "path": "/fineract-provider/api/v1/jobs/{jobName}/available-steps", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/IdempotencyHelper.java", "mechanism": "REST", "name": "Update Business Steps", "description": "Updates the business steps configuration for a job, requiring an Idempotency-Key header.", "path": "/fineract-provider/api/v1/jobs/{jobName}/steps", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON representation of BusinessStepWrapper", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/HolidayHelper.java", "mechanism": "REST", "name": "Create Holiday", "description": "Creates a new holiday resource via the API.", "path": "/fineract-provider/api/v1/holidays", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with offices, locale, dateFormat, name, dates, etc.", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/HolidayHelper.java", "mechanism": "REST", "name": "Activate Holiday", "description": "Activates an existing holiday resource.", "path": "/fineract-provider/api/v1/holidays/{holidayID}?command=activate", "method": "POST", "direction": "PRODUCER", "requestBody": "Empty JSON object", "responseBody": "JSON object containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/HolidayHelper.java", "mechanism": "REST", "name": "Get Holiday By ID", "description": "Retrieves details of a specific holiday.", "path": "/fineract-provider/api/v1/holidays/{holidayID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object representing the holiday details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessDateHelper.java", "mechanism": "REST", "name": "Update Business Date", "description": "Updates the business date configuration for a specific type.", "path": "/fineract-provider/api/v1/businessdate", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing type, date, dateFormat, and locale", "responseBody": "JSON object with change details" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessDateHelper.java", "mechanism": "REST", "name": "Get Business Date By Type", "description": "Retrieves the business date configuration for a specific type.", "path": "/fineract-provider/api/v1/businessdate/{type}", "method": "GET", "direction": "CONSUMER", "responseBody": "BusinessDateResponse JSON" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessDateHelper.java", "mechanism": "REST", "name": "Get All Business Dates", "description": "Retrieves all business date configurations.", "path": "/fineract-provider/api/v1/businessdate", "method": "GET", "direction": "CONSUMER", "responseBody": "List of BusinessDateResponse JSON" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/PasswordPreferencesHelper.java", "mechanism": "REST", "name": "Password Preferences API", "description": "API endpoint to manage password validation policies.", "path": "/fineract-provider/api/v1/passwordpreferences", "method": "PUT, GET", "direction": "CONSUMER", "requestBody": "JSON containing validationPolicyId", "responseBody": "JSON object with preference details or ID", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SurveyHelper.java", "mechanism": "REST", "name": "Fulfil Survey API", "description": "Endpoint to submit a filled PPI Kenya 2009 survey.", "path": "/fineract-provider/api/v1/survey/ppi_kenya_2009/clientId", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing survey answers (e.g., ppi_household_members_cd_q1_householdmembers)", "responseBody": "JSON object containing the created resource ID (clientId)" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SurveyHelper.java", "mechanism": "REST", "name": "Retrieve Survey API", "description": "Endpoint to retrieve a specific survey entry by ID.", "path": "/fineract-provider/api/v1/Survey/ppi_kenya_2009/clientid/entryId{generatedClientID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing the survey entry details, specifically the 'id'" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauIntegrationHelper.java", "mechanism": "REST", "name": "Get Credit Report API", "description": "Endpoint to retrieve a credit report configuration/data.", "path": "/fineract-provider/api/v1/creditBureauIntegration/creditReport", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing creditBureauID and NRC", "responseBody": "JSON response from server", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CreditBureauIntegrationHelper.java", "mechanism": "REST", "name": "Upload Credit Report API", "description": "Endpoint to upload a credit report file.", "path": "/fineract-provider/api/v1/creditBureauIntegration/addCreditReport", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart/form-data containing file and creditBureauId query param", "responseBody": "String response from server", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ExternalServicesConfigurationHelper.java", "mechanism": "REST", "name": "Get External Service Configuration", "description": "Retrieves configuration for a specific external service via the Fineract API.", "path": "/fineract-provider/api/v1/externalservice/{serviceName}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined by RequestSpecification context" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ExternalServicesConfigurationHelper.java", "mechanism": "REST", "name": "Update External Service Configuration", "description": "Updates configuration parameters for a specific external service via the Fineract API.", "path": "/fineract-provider/api/v1/externalservice/{serviceName}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object containing configuration key-value pairs", "protocol": "HTTP", "connectionInfo": "Defined by RequestSpecification context" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/TaxGroupHelper.java", "mechanism": "REST", "name": "Create Tax Group", "description": "API endpoint to create a new tax group definition.", "path": "/fineract-provider/api/v1/taxes/group", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing name, locale, dateFormat, and list of taxComponents", "responseBody": "JSON object containing the resourceId of the created tax group" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/TaxComponentHelper.java", "mechanism": "REST", "name": "Create Tax Component", "description": "API endpoint to create a new tax component definition in the system.", "path": "/fineract-provider/api/v1/taxes/component", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object containing name, percentage, locale, dateFormat, startDate, and optional credit account details.", "responseBody": "JSON object containing the resourceId of the created tax component." }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/NotificationHelper.java", "mechanism": "REST", "name": "Get Notifications", "description": "Fetches notifications for the current tenant.", "path": "/fineract-provider/api/v1/notifications", "method": "GET", "direction": "CONSUMER", "responseBody": "GetNotificationsResponse (JSON)", "protocol": "HTTP", "connectionInfo": "Defined in NOTIFICATION_API_URL" }, { "namespace": "org.apache.fineract.integrationtests.common", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BusinessStepHelper.java", "mechanism": "REST", "name": "updateJobBusinessStepConfig", "description": "Updates the business step configuration for a specific job via the Fineract API client.", "path": "/jobs/{jobName}/steps (inferred from client usage)", "method": "PUT", "direction": "PRODUCER", "requestBody": "UpdateBusinessStepConfigRequest containing a list of BusinessStep objects", "responseBody": "Response object (likely void or status confirmation)", "authentication": "Unknown (handled by IntegrationTest parent)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.AuditHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/AuditHelper.java", "mechanism": "REST", "name": "Audit API", "description": "Retrieves audit logs from the Fineract platform.", "path": "/fineract-provider/api/v1/audits", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in AUDIT_BASE_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.AuditHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/AuditHelper.java", "mechanism": "REST", "name": "Audit Search Template API", "description": "Retrieves the search template for audits.", "path": "/fineract-provider/api/v1/audits/searchtemplate", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in AUDITSEARCH_BASE_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Batch API", "description": "The class sends batch requests to the Fineract Batch API endpoint.", "path": "/fineract-provider/api/v1/batches", "method": "POST", "direction": "CONSUMER", "requestBody": "List (JSON)", "responseBody": "List (JSON)" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Clients API (via Batch)", "description": "Constructs payloads to interact with the Clients API.", "path": "v1/clients", "method": "POST/PUT", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Loans API (via Batch)", "description": "Constructs payloads to interact with the Loans API.", "path": "v1/loans", "method": "POST/GET/PUT", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Savings API (via Batch)", "description": "Constructs payloads to interact with the Savings Accounts API.", "path": "v1/savingsaccounts", "method": "POST/GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Datatables API (via Batch)", "description": "Constructs payloads to interact with the Datatables API.", "path": "v1/datatables", "method": "POST/GET/PUT/DELETE", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.integrationtests.common.BatchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/BatchHelper.java", "mechanism": "REST", "name": "Reschedule Loans API (via Batch)", "description": "Constructs payloads to interact with the Reschedule Loans API.", "path": "v1/rescheduleloans", "method": "POST", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Centers API", "description": "API for managing Center resources", "path": "/fineract-provider/api/v1/centers", "method": "GET, POST", "direction": "CONSUMER", "requestBody": "JSON (Center details)", "responseBody": "JSON (Center details or list)" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Center Details API", "description": "API for retrieving, updating, or deleting a specific Center", "path": "/fineract-provider/api/v1/centers/{id}", "method": "GET, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON (Update details)", "responseBody": "JSON (Center details)" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Associate Groups Command", "description": "Command to associate groups with a center", "path": "/fineract-provider/api/v1/centers/{id}?command=associateGroups", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (List of group IDs)", "responseBody": "JSON (Changes)" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Activate Center Command", "description": "Command to activate a center", "path": "/fineract-provider/api/v1/centers/{id}?command=activate", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (Activation date, locale)", "responseBody": "JSON (Changes)" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Assign Staff Command (Groups API)", "description": "Command to assign staff to a group/center", "path": "/fineract-provider/api/v1/groups/{groupId}?command=assignStaff", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (Staff ID)", "responseBody": "JSON (Changes)" }, { "namespace": "org.apache.fineract.integrationtests.common.CenterHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CenterHelper.java", "mechanism": "REST", "name": "Unassign Staff Command (Groups API)", "description": "Command to unassign staff from a group/center", "path": "/fineract-provider/api/v1/groups/{groupId}?command=unassignStaff", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (Staff ID)", "responseBody": "JSON (Changes)" }, { "namespace": "org.apache.fineract.integrationtests.common.CollateralManagementHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CollateralManagementHelper.java", "mechanism": "REST", "name": "Create Client Collateral", "description": "Creates a new collateral entry for a specific client.", "path": "/fineract-provider/api/v1/clients/{clientId}/collaterals", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with collateralId, quantity, locale", "responseBody": "JSON object containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.CollateralManagementHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CollateralManagementHelper.java", "mechanism": "REST", "name": "Get Client Collateral", "description": "Retrieves details of a specific collateral entry for a client.", "path": "/fineract-provider/api/v1/clients{clientId}/collaterals/{collateralId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing quantity" }, { "namespace": "org.apache.fineract.integrationtests.common.CollateralManagementHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CollateralManagementHelper.java", "mechanism": "REST", "name": "Create Collateral Product", "description": "Creates a new collateral product definition.", "path": "/fineract-provider/api/v1/collateral-management", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with name, currency, unitType, quality, pctToBase, basePrice, locale", "responseBody": "JSON object containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.CollateralManagementHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CollateralManagementHelper.java", "mechanism": "REST", "name": "Update Collateral Product", "description": "Updates an existing collateral product definition.", "path": "/fineract-provider/api/v1/collateral-management/{collateralId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with updated product fields", "responseBody": "JSON object containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.CollateralManagementHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CollateralManagementHelper.java", "mechanism": "REST", "name": "Update Client Collateral", "description": "Updates an existing collateral entry for a client.", "path": "/fineract-provider/api/v1/clients/{clientId}/collaterals/{collateralId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with quantity, locale", "responseBody": "JSON object containing changes" }, { "namespace": "org.apache.fineract.integrationtests.common.CurrenciesHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CurrenciesHelper.java", "mechanism": "REST", "name": "Retrieve Currencies", "description": "Fetches currency configurations from the Fineract platform.", "path": "/fineract-provider/api/v1/currencies", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing 'selectedCurrencyOptions' and 'currencyOptions' arrays." }, { "namespace": "org.apache.fineract.integrationtests.common.CurrenciesHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/CurrenciesHelper.java", "mechanism": "REST", "name": "Update Currencies", "description": "Updates the list of selected currencies for the tenant.", "path": "/fineract-provider/api/v1/currencies", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with a 'currencies' array of strings.", "responseBody": "JSON object containing the updated 'changes' and 'currencies' list." }, { "namespace": "org.apache.fineract.integrationtests.common.ExternalEventConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ExternalEventConfigurationHelper.java", "mechanism": "REST", "name": "External Event Configuration API", "description": "API endpoint to retrieve and manage external event configurations.", "path": "/fineract-provider/api/v1/externalevents/configuration", "method": "GET, PUT", "direction": "CONSUMER", "requestBody": "JSON object containing 'externalEventConfigurations' map with event names and boolean enabled states (for PUT).", "responseBody": "JSON object containing the list or map of event configurations.", "protocol": "HTTP", "connectionInfo": "Defined by Utils.TENANT_IDENTIFIER and base URL context" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Get All Global Configurations", "description": "Retrieves all global configuration settings.", "path": "/fineract-provider/api/v1/configurations", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Get Global Configuration By ID", "description": "Retrieves a specific global configuration by its ID.", "path": "/fineract-provider/api/v1/configurations/{configId}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Get Global Configuration By Name", "description": "Retrieves a specific global configuration by its name.", "path": "/fineract-provider/api/v1/configurations/name/{name}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Update Global Configuration", "description": "Updates a global configuration setting (value or enabled flag).", "path": "/fineract-provider/api/v1/configurations/{configId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with 'value', 'enabled', or 'stringValue'", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Get Cache Configuration", "description": "Retrieves cache configuration settings.", "path": "/fineract-provider/api/v1/caches", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GlobalConfigurationHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GlobalConfigurationHelper.java", "mechanism": "REST", "name": "Update Cache Configuration", "description": "Updates cache configuration settings.", "path": "/fineract-provider/api/v1/caches", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with 'cacheType'", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Create Group", "description": "Creates a new group via the API.", "path": "/fineract-provider/api/v1/groups", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with group details (name, officeId, etc.)", "responseBody": "JSON object containing the new group ID" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Associate Client", "description": "Associates a client with a group.", "path": "/fineract-provider/api/v1/groups/{groupId}?command=associateClients", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with clientMembers list", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Disassociate Client", "description": "Disassociates a client from a group.", "path": "/fineract-provider/api/v1/groups/{groupId}?command=disassociateClients", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with clientMembers list", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Activate Group", "description": "Activates a group.", "path": "/fineract-provider/api/v1/groups/{groupId}?command=activate", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with activationDate", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Update Group", "description": "Updates group details.", "path": "/fineract-provider/api/v1/groups/{groupId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Delete Group", "description": "Deletes a group.", "path": "/fineract-provider/api/v1/groups/{groupId}", "method": "DELETE", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Assign Staff", "description": "Assigns staff to a group.", "path": "/fineract-provider/api/v1/groups/{groupId}?command=assignStaff", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with staffId", "responseBody": "JSON object with changes" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Get Group Details", "description": "Retrieves group details.", "path": "/fineract-provider/api/v1/groups/{groupId}", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON object with group details" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Get GLIM Accounts", "description": "Retrieves GLIM accounts for a group.", "path": "/fineract-provider/api/v1/groups/{groupId}/glimaccounts", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON array of GLIM accounts" }, { "namespace": "org.apache.fineract.integrationtests.common.GroupHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/GroupHelper.java", "mechanism": "REST", "name": "Get GSIM Accounts", "description": "Retrieves GSIM accounts for a group.", "path": "/fineract-provider/api/v1/groups/{groupId}/gsimaccounts", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON array of GSIM accounts" }, { "namespace": "org.apache.fineract.integrationtests.common.HookHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/HookHelper.java", "mechanism": "REST", "name": "Fineract Hooks API", "description": "API endpoints for managing webhooks in the Fineract platform.", "path": "/fineract-provider/api/v1/hooks", "method": "POST, PUT, DELETE, GET", "direction": "CONSUMER", "requestBody": "JSON payload containing hook details (name, displayName, config, events)", "responseBody": "JSON response containing resource ID or hook details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.LoanRescheduleRequestHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/LoanRescheduleRequestHelper.java", "mechanism": "REST", "name": "Loan Reschedule API", "description": "API endpoints for managing loan reschedule requests (create, approve, reject, get).", "path": "/fineract-provider/api/v1/rescheduleloans", "method": "POST, GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in LOAN_RESCHEDULE_REQUEST_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.OfficeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/OfficeHelper.java", "mechanism": "REST", "name": "Office Management API", "description": "Endpoints for creating, retrieving, and updating offices.", "path": "/fineract-provider/api/v1/offices", "method": "GET, POST, PUT", "direction": "CONSUMER", "requestBody": "JSON (Office details)", "responseBody": "JSON (Office details or Resource ID)" }, { "namespace": "org.apache.fineract.integrationtests.common.OfficeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/OfficeHelper.java", "mechanism": "REST", "name": "Office Template Upload", "description": "Endpoint to upload office data import templates.", "path": "/fineract-provider/api/v1/offices/uploadtemplate", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart/Form-Data (File)", "responseBody": "String (Import ID)" }, { "namespace": "org.apache.fineract.integrationtests.common.OfficeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/OfficeHelper.java", "mechanism": "REST", "name": "Office Template Download", "description": "Endpoint to download the office data import template.", "path": "/fineract-provider/api/v1/offices/downloadtemplate", "method": "GET", "direction": "CONSUMER", "responseBody": "Binary (Excel file)" }, { "namespace": "org.apache.fineract.integrationtests.common.OfficeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/OfficeHelper.java", "mechanism": "REST", "name": "Import Template Location", "description": "Endpoint to get the location of the output template after import.", "path": "/fineract-provider/api/v1/imports/getOutputTemplateLocation", "method": "GET", "direction": "CONSUMER", "responseBody": "String (Location URL)" }, { "namespace": "org.apache.fineract.integrationtests.common.ProductMixHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ProductMixHelper.java", "mechanism": "REST", "name": "Get Product Mix List", "description": "Retrieves the list of loan product mixes via HTTP GET.", "path": "/fineract-provider/api/v1/loanproducts", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in PRODUCT_MIX_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.ProductMixHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/ProductMixHelper.java", "mechanism": "REST", "name": "Get Product Mix Template", "description": "Retrieves the template for loan product mixes via HTTP GET.", "path": "/fineract-provider/api/v1/loanproducts/template", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in PRODUCT_MIX_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.SchedulerJobHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SchedulerJobHelper.java", "mechanism": "REST", "name": "Get All Scheduler Jobs", "description": "Retrieves a list of all configured scheduler jobs.", "path": "/fineract-provider/api/v1/jobs", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "List of Maps containing job details", "authentication": "Tenant Identifier (Header/Param)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.SchedulerJobHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SchedulerJobHelper.java", "mechanism": "REST", "name": "Get Scheduler Job By ID", "description": "Retrieves details for a specific scheduler job.", "path": "/fineract-provider/api/v1/jobs/{jobId}", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "Map containing job details", "authentication": "Tenant Identifier (Header/Param)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.SchedulerJobHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SchedulerJobHelper.java", "mechanism": "REST", "name": "Get Scheduler Status", "description": "Checks if the scheduler is active.", "path": "/fineract-provider/api/v1/scheduler", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON with 'active' boolean", "authentication": "Tenant Identifier (Header/Param)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.SchedulerJobHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SchedulerJobHelper.java", "mechanism": "REST", "name": "Update Scheduler Job", "description": "Updates the configuration (active status) of a scheduler job.", "path": "/fineract-provider/api/v1/jobs/{jobId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON { \"active\": \"true\"/\"false\" }", "responseBody": "Map containing updated job details", "authentication": "Tenant Identifier (Header/Param)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.SchedulerJobHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SchedulerJobHelper.java", "mechanism": "REST", "name": "Run Scheduler Job", "description": "Manually triggers the execution of a scheduler job.", "path": "/fineract-provider/api/v1/jobs/{jobId}?command=executeJob", "method": "POST", "direction": "CONSUMER", "requestBody": "Empty JSON object", "responseBody": "None (202 Accepted)", "authentication": "Tenant Identifier (Header/Param)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.SearchHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/SearchHelper.java", "mechanism": "REST", "name": "Search API", "description": "Invokes the Fineract Search API to retrieve resources matching specific criteria.", "path": "/fineract-provider/api/v1/search", "method": "GET", "direction": "CONSUMER", "responseBody": "List of GetSearchResponse objects (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.StandingInstructionsHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/StandingInstructionsHelper.java", "mechanism": "REST", "name": "Create Standing Instruction", "description": "Creates a new standing instruction via the API.", "path": "/fineract-provider/api/v1/standinginstructions", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object representing the standing instruction details (recurrence, priority, accounts, etc.)", "responseBody": "JSON object containing the resourceId of the created instruction" }, { "namespace": "org.apache.fineract.integrationtests.common.StandingInstructionsHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/StandingInstructionsHelper.java", "mechanism": "REST", "name": "Get Standing Instruction By ID", "description": "Retrieves a specific standing instruction.", "path": "/fineract-provider/api/v1/standinginstructions/{standingInstructionId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing standing instruction details" }, { "namespace": "org.apache.fineract.integrationtests.common.StandingInstructionsHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/StandingInstructionsHelper.java", "mechanism": "REST", "name": "Get Standing Instruction Run History", "description": "Retrieves the execution history of standing instructions.", "path": "/fineract-provider/api/v1/standinginstructionrunhistory", "method": "GET", "direction": "CONSUMER", "responseBody": "List of history items" }, { "namespace": "org.apache.fineract.integrationtests.common.Utils", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/Utils.java", "mechanism": "REST", "name": "Authentication Login", "description": "Authenticates the user to obtain a base64 encoded key.", "path": "/fineract-provider/api/v1/authentication", "method": "POST", "direction": "CONSUMER", "requestBody": "{\"username\":\"...\", \"password\":\"...\"}", "responseBody": "JSON containing base64EncodedAuthenticationKey", "protocol": "HTTP/HTTPS" }, { "namespace": "org.apache.fineract.integrationtests.common.Utils", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/Utils.java", "mechanism": "REST", "name": "Actuator Health Check", "description": "Checks if the application is up and running before starting tests.", "path": "/fineract-provider/actuator/health", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON health status", "protocol": "HTTP/HTTPS" }, { "namespace": "org.apache.fineract.integrationtests.common.Utils", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/Utils.java", "mechanism": "REST", "name": "Generic API Calls", "description": "The class provides generic wrappers (performServerGet, performServerPost, etc.) to consume any REST endpoint in the application dynamically.", "path": "Dynamic (passed as argument)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/HTTPS" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/FinancialActivityAccountHelper.java", "mechanism": "REST", "name": "Financial Activity Accounts API", "description": "API endpoint for managing financial activity account mappings.", "path": "/fineract-provider/api/v1/financialactivityaccounts", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative URL defined in constant FINANCIAL_ACTIVITY_ACCOUNT_MAPPING_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/AccountRuleHelper.java", "mechanism": "REST", "name": "Accounting Rules API", "description": "Consumes the Fineract API to manage accounting rules.", "path": "/fineract-provider/api/v1/accountingrules", "method": "GET, POST", "direction": "CONSUMER", "responseBody": "JSON list of rules or creation response", "connectionInfo": "Defined in ACCOUNTINGRULES_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting.AccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/AccountHelper.java", "mechanism": "REST", "name": "Create GL Account", "description": "API endpoint to create a new General Ledger account.", "path": "/fineract-provider/api/v1/glaccounts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON representation of GL Account (Asset, Income, Expense, or Liability)", "responseBody": "JSON containing the resourceId of the created account" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting.AccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/AccountHelper.java", "mechanism": "REST", "name": "Get GL Accounts with Running Balance", "description": "API endpoint to retrieve GL accounts with their running balances.", "path": "/fineract-provider/api/v1/glaccounts", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "List of GL Accounts with balance details" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting.AccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/AccountHelper.java", "mechanism": "REST", "name": "Get GL Account by ID", "description": "API endpoint to retrieve a specific GL account by ID with running balance.", "path": "/fineract-provider/api/v1/glaccounts/{accountId}", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "GL Account details with balance" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting.JournalEntryHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/JournalEntryHelper.java", "mechanism": "REST", "name": "Get Journal Entries", "description": "Retrieves accounting journal entries based on various criteria.", "path": "/fineract-provider/api/v1/journalentries", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP/1.1", "connectionInfo": "Configured via RequestSpecification" }, { "namespace": "org.apache.fineract.integrationtests.common.accounting.PeriodicAccrualAccountingHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/accounting/PeriodicAccrualAccountingHelper.java", "mechanism": "REST", "name": "runPeriodicAccrualAccounting", "description": "Invokes the periodic accrual accounting API endpoint.", "path": "/fineract-provider/api/v1/runaccruals", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing 'dateFormat', 'locale', and 'tillDate'", "responseBody": "Unknown (returned as Object)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.charges.ChargesHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/charges/ChargesHelper.java", "mechanism": "REST", "name": "Charges API", "description": "Consumes the Fineract Charges API to manage charge definitions.", "path": "/fineract-provider/api/v1/charges", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.commands.MakercheckersHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/commands/MakercheckersHelper.java", "mechanism": "REST", "name": "Get Maker Checker List", "description": "Retrieves the list of maker-checker entries from the Fineract provider API.", "path": "/fineract-provider/api/v1/makercheckers", "method": "GET", "direction": "CONSUMER", "responseBody": "ArrayList", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Fixed Deposit Account API", "description": "Main API for managing fixed deposit accounts.", "path": "/fineract-provider/api/v1/fixeddepositaccounts", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Defined in FIXED_DEPOSIT_ACCOUNT_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Approve Fixed Deposit", "description": "Command to approve a fixed deposit application.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=approve", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Undo Approval", "description": "Command to undo the approval of a fixed deposit.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=undoapproval", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Reject Application", "description": "Command to reject a fixed deposit application.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=reject", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Withdraw Application", "description": "Command for applicant to withdraw the application.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=withdrawnByApplicant", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Activate Fixed Deposit", "description": "Command to activate the fixed deposit.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=activate", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Calculate Interest", "description": "Command to calculate interest.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=calculateInterest", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Post Interest", "description": "Command to post interest.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=postInterest", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountHelper.java", "mechanism": "REST", "name": "Premature Close", "description": "Command to close the deposit prematurely.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{id}?command=prematureClose", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositAccountStatusChecker", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositAccountStatusChecker.java", "mechanism": "REST", "name": "Get Fixed Deposit Account Status", "description": "Retrieves the status details of a specific fixed deposit account.", "path": "/fineract-provider/api/v1/fixeddepositaccounts/{fixedDepositAccountID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing a 'status' field which is a map of boolean flags." }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositProductHelper.java", "mechanism": "REST", "name": "Create Fixed Deposit Product", "description": "Creates a new fixed deposit product definition.", "path": "/fineract-provider/api/v1/fixeddepositproducts", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object containing product details (name, currency, terms, charts)", "responseBody": "JSON object containing the resourceId of the created product" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve All Fixed Deposit Products", "description": "Fetches a list of all existing fixed deposit products.", "path": "/fineract-provider/api/v1/fixeddepositproducts", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of product objects" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve Fixed Deposit Product By ID", "description": "Fetches details for a single fixed deposit product.", "path": "/fineract-provider/api/v1/fixeddepositproducts/{productId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object representing the product" }, { "namespace": "org.apache.fineract.integrationtests.common.fixeddeposit.FixedDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/fixeddeposit/FixedDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve Interest Rate Charts", "description": "Fetches interest rate chart slabs for a specific product.", "path": "/fineract-provider/api/v1/interestratecharts", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of chart slabs" }, { "namespace": "org.apache.fineract.integrationtests.common.funds.FundsResourceHandler", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/funds/FundsResourceHandler.java", "mechanism": "REST", "name": "Create Fund", "description": "API endpoint to create a new fund.", "path": "/fineract-provider/api/v1/funds", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON representation of the fund", "responseBody": "JSON containing the resourceId", "protocol": "HTTP", "connectionInfo": "Defined by Utils.TENANT_IDENTIFIER and base URL" }, { "namespace": "org.apache.fineract.integrationtests.common.funds.FundsResourceHandler", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/funds/FundsResourceHandler.java", "mechanism": "REST", "name": "Retrieve All Funds", "description": "API endpoint to list all funds.", "path": "/fineract-provider/api/v1/funds", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of fund objects", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.funds.FundsResourceHandler", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/funds/FundsResourceHandler.java", "mechanism": "REST", "name": "Retrieve Single Fund", "description": "API endpoint to retrieve a specific fund by ID.", "path": "/fineract-provider/api/v1/funds/{fundID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of the fund", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.funds.FundsResourceHandler", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/funds/FundsResourceHandler.java", "mechanism": "REST", "name": "Update Fund", "description": "API endpoint to update an existing fund.", "path": "/fineract-provider/api/v1/funds/{fundID}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON representation of fields to update", "responseBody": "JSON object containing changes", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductHelper.java", "mechanism": "REST", "name": "Create Loan Product", "description": "Calls the API to create a new loan product.", "path": "/loanproducts", "method": "POST", "direction": "CONSUMER", "requestBody": "PostLoanProductsRequest", "responseBody": "PostLoanProductsResponse" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductHelper.java", "mechanism": "REST", "name": "Retrieve Loan Product by External ID", "description": "Calls the API to retrieve loan product details by external ID.", "path": "/loanproducts/external-id/{externalId}", "method": "GET", "direction": "CONSUMER", "responseBody": "GetLoanProductsProductIdResponse" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductHelper.java", "mechanism": "REST", "name": "Retrieve Loan Product by ID", "description": "Calls the API to retrieve loan product details by internal ID.", "path": "/loanproducts/{loanProductId}", "method": "GET", "direction": "CONSUMER", "responseBody": "GetLoanProductsProductIdResponse" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductHelper.java", "mechanism": "REST", "name": "Update Loan Product by External ID", "description": "Calls the API to update a loan product using its external ID.", "path": "/loanproducts/external-id/{externalId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "PutLoanProductsProductIdRequest", "responseBody": "PutLoanProductsProductIdResponse" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductHelper.java", "mechanism": "REST", "name": "Get Loan Product Template", "description": "Calls the API to retrieve the loan product template.", "path": "/loanproducts/template", "method": "GET", "direction": "CONSUMER", "responseBody": "GetLoanProductsTemplateResponse" }, { "namespace": "org.apache.fineract.integrationtests.common.loans", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/CobHelper.java", "mechanism": "REST", "name": "Get COB Partitions", "description": "Consumes an internal REST API to retrieve COB partitions.", "path": "/fineract-provider/api/v1/internal/cob/partitions/{partitionSize}", "method": "GET", "direction": "CONSUMER", "responseBody": "List>", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanAccountLockHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanAccountLockHelper.java", "mechanism": "REST", "name": "Internal Place Lock on Loan Account", "description": "Calls an internal API endpoint to place a soft lock on a specific loan account.", "path": "/fineract-provider/api/v1/internal/loans/{loanId}/place-lock/{lockOwner}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (or error string)", "responseBody": "String (API response)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanCOBCatchUpHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanCOBCatchUpHelper.java", "mechanism": "REST", "name": "executeLoanCOBCatchUp", "description": "Triggers the Loan COB Catch Up process on the Fineract backend.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanCOBCatchUpHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanCOBCatchUpHelper.java", "mechanism": "REST", "name": "getOldestCOBProcessedLoan", "description": "Retrieves the oldest loan processed by the COB Catch Up mechanism.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanCOBCatchUpHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanCOBCatchUpHelper.java", "mechanism": "REST", "name": "isCatchUpRunning", "description": "Checks the running status of the Loan COB Catch Up process.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via IntegrationTest base class" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanStatusChecker", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanStatusChecker.java", "mechanism": "REST", "name": "Get Loan Details", "description": "Fetches the details of a specific loan to inspect its status or sub-status.", "path": "/fineract-provider/api/v1/loans/{loanID}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative path constructed in code, base URI managed by RestAssured/Utils" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanTestLifecycleExtension", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanTestLifecycleExtension.java", "mechanism": "REST", "name": "Fineract Loan API", "description": "Interacts with the Fineract platform via HTTP to manage loan lifecycle states.", "path": "/loans/{loanId}/transactions, /loans/{loanId}", "method": "POST", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "connectionInfo": "Configured via Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanTransactionHelper.java", "mechanism": "REST", "name": "Fineract Loan API", "description": "Consumes the Fineract Loan REST API to perform operations.", "path": "/fineract-provider/api/v1/loans", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanTransactionHelper.java", "mechanism": "REST", "name": "Fineract Loan Product API", "description": "Consumes the Fineract Loan Product REST API.", "path": "/fineract-provider/api/v1/loanproducts", "method": "GET, POST, PUT", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanTransactionHelper.java", "mechanism": "REST", "name": "Fineract Interoperation API", "description": "Consumes the Interoperation API for loan repayments via account number.", "path": "/fineract-provider/api/v1/interoperation/transactions/{accountNo}/loanrepayment", "method": "POST", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsTest.java", "mechanism": "REST", "name": "SMS Bridge Mock", "description": "Mocks the external SMS provider service required by the application to list available SMS bridges.", "path": "/smsbridges", "method": "GET", "direction": "PRODUCER", "responseBody": "[{\"id\": 1, \"tenantId\": 1, \"phoneNo\": \"+1234567890\", \"providerName\": \"Dummy SMS Provider...\"}]", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsTest.java", "mechanism": "REST", "name": "Fineract API Client", "description": "Consumes the Fineract REST API to perform campaign operations (create, update, delete, etc.) via the CampaignsHelper.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns API", "description": "API for managing SMS campaigns", "path": "/fineract-provider/api/v1/smscampaigns", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON containing campaign details (name, message, triggerType, etc.)", "responseBody": "JSON containing resourceId", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns API - Retrieve", "description": "API to retrieve a specific campaign", "path": "/fineract-provider/api/v1/smscampaigns/{id}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON containing campaign details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns API - Update", "description": "API to update a specific campaign", "path": "/fineract-provider/api/v1/smscampaigns/{id}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON containing updated campaign details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns API - Delete", "description": "API to delete a specific campaign", "path": "/fineract-provider/api/v1/smscampaigns/{id}", "method": "DELETE", "direction": "CONSUMER", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns API - Action", "description": "API to perform actions (activate/close) on a campaign", "path": "/fineract-provider/api/v1/smscampaigns/{id}?command={command}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON containing action date and locale", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CampaignsHelper.java", "mechanism": "REST", "name": "SMS Campaigns Template API", "description": "API to retrieve campaign templates and options", "path": "/fineract-provider/api/v1/smscampaigns/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON containing template options including business rules/reports", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/EntityDatatableChecksHelper.java", "mechanism": "REST", "name": "Entity Datatable Checks API", "description": "Consumes the Fineract Entity Datatable Checks REST API for integration testing purposes.", "path": "/fineract-provider/api/v1/entityDatatableChecks", "method": "POST, GET, DELETE", "direction": "CONSUMER", "requestBody": "JSON object containing entity, status, datatableName, and optional productId", "responseBody": "JSON object containing resourceId or full response details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation.CurrencyHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/CurrencyHelper.java", "mechanism": "REST", "name": "Currency API", "description": "API endpoint to retrieve and update currency configurations.", "path": "/fineract-provider/api/v1/currencies", "method": "GET, PUT", "direction": "CONSUMER", "requestBody": "JSON object with 'currencies' array (for PUT)", "responseBody": "JSON object containing currency options or changes", "connectionInfo": "Relative path defined in CURRENCY_URL constant" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation.EntityDatatableChecksIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/EntityDatatableChecksIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests on Datatables, Clients, Groups, Loans, and Savings.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.initializeRESTAssured() and RequestSpecBuilder" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation.StaffHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/StaffHelper.java", "mechanism": "REST", "name": "Staff API", "description": "Integration with the Fineract Staff management REST API endpoints.", "path": "/fineract-provider/api/v1/staff", "method": "GET, POST, PUT", "direction": "CONSUMER", "requestBody": "JSON object representing staff details (firstname, lastname, officeId, etc.)", "responseBody": "JSON object containing staff resource details or ID", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.organisation.StaffHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/organisation/StaffHelper.java", "mechanism": "REST", "name": "Group Transfer API", "description": "Integration with the Fineract Group API to transfer staff.", "path": "/fineract-provider/api/v1/groups/{groupId}?command=transferStaff", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with staffId and note", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.products", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyBucketsHelper.java", "mechanism": "REST", "name": "Delinquency Buckets API", "description": "API endpoints for managing delinquency buckets.", "path": "/fineract-provider/api/v1/delinquency/buckets", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative path defined in DELINQUENCY_BUCKETS_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.products", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyRangesHelper.java", "mechanism": "REST", "name": "Delinquency Ranges API", "description": "API endpoints for managing delinquency ranges.", "path": "/fineract-provider/api/v1/delinquency/ranges", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative URL path defined in constant DELINQUENCY_RANGES_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Provisioning Category API", "description": "Retrieves provisioning categories.", "path": "/fineract-provider/api/v1/provisioningcategory", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Create Provisioning Criteria API", "description": "Creates new provisioning criteria.", "path": "/fineract-provider/api/v1/provisioningcriteria", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Provisioning Criteria Detail API", "description": "Retrieves, updates, or deletes a specific provisioning criteria.", "path": "/fineract-provider/api/v1/provisioningcriteria/{criteriaId}", "method": "GET, PUT, DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Create Provisioning Entries API", "description": "Creates provisioning entries.", "path": "/fineract-provider/api/v1/provisioningentries", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Update Provisioning Entry API", "description": "Updates a provisioning entry with a specific command.", "path": "/fineract-provider/api/v1/provisioningentries/{entryId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Provisioning Entry API", "description": "Retrieves a specific provisioning entry.", "path": "/fineract-provider/api/v1/provisioningentries/{provisioningEntry}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Related Provisioning Entries API", "description": "Retrieves entries related to a specific ID.", "path": "/fineract-provider/api/v1/provisioningentries/entries", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.provisioning", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/provisioning/ProvisioningTransactionHelper.java", "mechanism": "REST", "name": "Retrieve All Provisioning Entries API", "description": "Retrieves all provisioning entries.", "path": "/fineract-provider/api/v1/provisioningentries", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.common.rates", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/rates/RatesHelper.java", "mechanism": "REST", "name": "Rates API", "description": "The Fineract Rates API used to manage rate definitions.", "path": "/fineract-provider/api/v1/rates", "method": "GET, POST, PUT", "direction": "CONSUMER", "requestBody": "JSON object containing rate details (name, percentage, locale, etc.)", "responseBody": "JSON object or array containing rate resource details", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositAccountHelper.java", "mechanism": "REST", "name": "Recurring Deposit Account API", "description": "API for managing recurring deposit accounts (create, update, approve, transact).", "path": "/fineract-provider/api/v1/recurringdepositaccounts", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON payload containing account details (clientId, productId, dates, interest settings) or command parameters.", "responseBody": "JSON response containing resource ID, status, or account details.", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositAccountStatusChecker", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositAccountStatusChecker.java", "mechanism": "REST", "name": "Get Recurring Deposit Account Status", "description": "Retrieves the status details of a specific recurring deposit account via the Fineract API.", "path": "/fineract-provider/api/v1/recurringdepositaccounts/{recurringDepositAccountID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing the 'status' map of the account", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositProductHelper.java", "mechanism": "REST", "name": "Create Recurring Deposit Product", "description": "Creates a new recurring deposit product definition in the system.", "path": "/fineract-provider/api/v1/recurringdepositproducts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing product details (name, currency, terms, charts, etc.)", "responseBody": "JSON object containing the resourceId of the created product", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve All Recurring Deposit Products", "description": "Fetches a list of all recurring deposit products.", "path": "/fineract-provider/api/v1/recurringdepositproducts", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of product definitions", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve Recurring Deposit Product By ID", "description": "Fetches details of a single recurring deposit product.", "path": "/fineract-provider/api/v1/recurringdepositproducts/{productId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of the product definition", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.recurringdeposit.RecurringDepositProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/recurringdeposit/RecurringDepositProductHelper.java", "mechanism": "REST", "name": "Retrieve Interest Rate Charts", "description": "Fetches interest rate chart slabs for a specific product.", "path": "/fineract-provider/api/v1/interestratecharts", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing chart slabs", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.savings", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/SavingsStatusChecker.java", "mechanism": "REST", "name": "Savings Account API", "description": "Retrieves status and sub-status information for savings accounts.", "path": "/fineract-provider/api/v1/savingsaccounts/{savingsID}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing status or subStatus fields", "connectionInfo": "Relative URL path defined in SAVINGS_ACCOUNT_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.savings.AccountTransferHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/AccountTransferHelper.java", "mechanism": "REST", "name": "Account Transfer API", "description": "Endpoint to execute account transfers between clients/accounts.", "path": "/fineract-provider/api/v1/accounttransfers", "method": "POST", "requestBody": "JSON object containing from/to client and account IDs, types, amount, date, and locale.", "responseBody": "JSON containing the resource ID (savingsId).", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.savings.AccountTransferHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/AccountTransferHelper.java", "mechanism": "REST", "name": "Loan Refund By Transfer API", "description": "Endpoint to refund a loan via an account transfer.", "path": "/fineract-provider/api/v1/accounttransfers/refundByTransfer", "method": "POST", "requestBody": "JSON object containing from/to client and account IDs, types, amount, date, and locale.", "responseBody": "JSON containing the resource ID (savingsId).", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.savings.SavingsAccountHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/SavingsAccountHelper.java", "mechanism": "REST", "name": "Savings Account API", "description": "Consumes the Fineract Savings Account REST API to perform CRUD operations and commands on savings accounts.", "path": "/fineract-provider/api/v1/savingsaccounts", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via RequestSpecification (RestAssured)" }, { "namespace": "org.apache.fineract.integrationtests.common.savings.SavingsProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/SavingsProductHelper.java", "mechanism": "REST", "name": "Create Savings Product", "description": "Creates a new savings product definition in the system.", "path": "/fineract-provider/api/v1/savingsproducts", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON representation of the savings product (constructed by build())", "responseBody": "JSON containing the resourceId of the created product" }, { "namespace": "org.apache.fineract.integrationtests.common.savings.SavingsProductHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/savings/SavingsProductHelper.java", "mechanism": "REST", "name": "Get Savings Product", "description": "Retrieves a savings product definition to verify its creation.", "path": "/fineract-provider/api/v1/savingsproducts/{id}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON representation of the savings product" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareDividendsTransactionHelper.java", "mechanism": "REST", "name": "Create Share Product Dividend", "description": "Creates a new dividend for a share product via the API.", "path": "/fineract-provider/api/v1/shareproduct/{productId}/dividend", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON containing dividend details", "responseBody": "JSON containing resourceId", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareDividendsTransactionHelper.java", "mechanism": "REST", "name": "Update Share Product Dividend", "description": "Updates or executes a command on a dividend via the API.", "path": "/fineract-provider/api/v1/shareproduct/{productId}/dividend/{dividendId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON containing update details", "responseBody": "JSON containing resourceId", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareDividendsTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Dividend Details", "description": "Fetches details of a specific dividend via the API.", "path": "/fineract-provider/api/v1/shareproduct/{productId}/dividend/{dividendId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON map of dividend details", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareDividendsTransactionHelper.java", "mechanism": "REST", "name": "Retrieve All Dividends", "description": "Fetches all dividends for a share product via the API.", "path": "/fineract-provider/api/v1/shareproduct/{productId}/dividend", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON map/list of dividends", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountTransactionHelper.java", "mechanism": "REST", "name": "Create Share Account", "description": "Calls the API to create a new share account.", "path": "/fineract-provider/api/v1/accounts/share", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON representation of share account", "responseBody": "JSON containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Share Account", "description": "Calls the API to retrieve share account details.", "path": "/fineract-provider/api/v1/accounts/share/{id}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON map of account details" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountTransactionHelper.java", "mechanism": "REST", "name": "Update Share Account", "description": "Calls the API to update a share account.", "path": "/fineract-provider/api/v1/accounts/share/{id}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON representation of updates", "responseBody": "JSON containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.shares", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountTransactionHelper.java", "mechanism": "REST", "name": "Share Account Command", "description": "Calls the API to execute a command on a share account.", "path": "/fineract-provider/api/v1/accounts/share/{id}?command={command}", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON body for command", "responseBody": "JSON containing resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.shares.DividendsIntegrationTests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/DividendsIntegrationTests.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform via HTTP REST endpoints to manage clients, accounts, and dividends.", "path": "Dynamic (handled by TransactionHelpers)", "method": "GET, POST", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.common.shares.ShareAccountIntegrationTests", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountIntegrationTests.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract Core Banking Platform REST API to perform integration tests.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.common.shares.ShareProductTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareProductTransactionHelper.java", "mechanism": "REST", "name": "Create Share Product", "description": "Consumes the API to create a new share product.", "path": "/fineract-provider/api/v1/products/share", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON representation of the share product", "responseBody": "JSON containing the resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.shares.ShareProductTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareProductTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Share Product", "description": "Consumes the API to retrieve details of a share product.", "path": "/fineract-provider/api/v1/products/share/{shareProductId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON map of share product details" }, { "namespace": "org.apache.fineract.integrationtests.common.shares.ShareProductTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareProductTransactionHelper.java", "mechanism": "REST", "name": "Update Share Product", "description": "Consumes the API to update an existing share product.", "path": "/fineract-provider/api/v1/products/share/{shareProductId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON representation of provisioning criteria", "responseBody": "JSON containing the resourceId" }, { "namespace": "org.apache.fineract.integrationtests.common.system", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/system/DatatableHelper.java", "mechanism": "REST", "name": "Datatable API", "description": "Consumes the Fineract Datatable API to manage datatables and their entries.", "path": "/fineract-provider/api/v1/datatables", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.common.system", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/system/AccountNumberPreferencesHelper.java", "mechanism": "REST", "name": "Account Number Formats API", "description": "API endpoint for managing account number preferences.", "path": "/fineract-provider/api/v1/accountnumberformats", "method": "POST, GET, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative path defined in constant ACCOUNT_NUMBER_FORMATS_REQUEST_URL" }, { "namespace": "org.apache.fineract.integrationtests.common.system.CodeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/system/CodeHelper.java", "mechanism": "REST", "name": "Codes API", "description": "API to manage system codes (reference data categories).", "path": "/fineract-provider/api/v1/codes", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON (name)", "responseBody": "JSON (id, name, systemDefined)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.system.CodeHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/system/CodeHelper.java", "mechanism": "REST", "name": "Code Values API", "description": "API to manage specific values within a system code category.", "path": "/fineract-provider/api/v1/codes/{codeId}/codevalues", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "requestBody": "JSON (name, description, position)", "responseBody": "JSON (id, name, description, position)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.common.xbrl.XBRLIntegrationTestHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/xbrl/XBRLIntegrationTestHelper.java", "mechanism": "REST", "name": "Get Taxonomy List", "description": "Retrieves the list of XBRL taxonomies via HTTP GET.", "path": "/fineract-provider/api/v1/mixtaxonomy", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative URL constructed with Utils.TENANT_IDENTIFIER" }, { "namespace": "org.apache.fineract.integrationtests.common.xbrl.XBRLIntegrationTestHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/xbrl/XBRLIntegrationTestHelper.java", "mechanism": "REST", "name": "Get Taxonomy Mapping", "description": "Retrieves the XBRL taxonomy mappings via HTTP GET.", "path": "/fineract-provider/api/v1/mixmapping", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Relative URL constructed with Utils.TENANT_IDENTIFIER" }, { "namespace": "org.apache.fineract.integrationtests.datatable", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/datatable/DatatableIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to test Datatable functionality.", "path": "/fineract-provider/api/v1/datatables/*", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.datatable", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/datatable/DatatableAdvancedQueryTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming Fineract APIs to create entities and query data tables.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.datatable", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/datatable/DatatableUniqueAndIndexColumnTest.java", "mechanism": "REST", "name": "Datatable API", "description": "The test class acts as a consumer of the Fineract Datatable REST API to create, read, and update datatable definitions.", "path": "/datatables", "method": "POST, PUT, GET", "direction": "CONSUMER", "requestBody": "PostDataTablesRequest, PutDataTablesRequest", "responseBody": "PostDataTablesResponse, GetDataTablesResponse", "authentication": "unknown", "protocol": "HTTP", "connectionInfo": "Managed by DatatableHelper/REST Assured" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorHelper.java", "mechanism": "REST", "name": "Create Guarantor", "description": "Creates a new guarantor for a loan via the API.", "path": "/fineract-provider/api/v1/loans/{loanId}/guarantors/", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON representation of the guarantor", "responseBody": "JSON containing the resource ID" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorHelper.java", "mechanism": "REST", "name": "Update Guarantor", "description": "Updates an existing guarantor via the API.", "path": "/fineract-provider/api/v1/loans/{loanId}/guarantors/{guarantorId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON representation of fields to update", "responseBody": "JSON containing changes" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorHelper.java", "mechanism": "REST", "name": "Delete Guarantor", "description": "Deletes a guarantor via the API.", "path": "/fineract-provider/api/v1/loans/{loanId}/guarantors/{guarantorId}", "method": "DELETE", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON response" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorHelper.java", "mechanism": "REST", "name": "Get Guarantor", "description": "Retrieves a specific guarantor via the API.", "path": "/fineract-provider/api/v1/loans/{loanId}/guarantors/{guarantorId}", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON representation of the guarantor" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorHelper.java", "mechanism": "REST", "name": "Get All Guarantors", "description": "Retrieves all guarantors for a loan via the API.", "path": "/fineract-provider/api/v1/loans/{loanId}/guarantors/", "method": "GET", "direction": "CONSUMER", "requestBody": "None", "responseBody": "JSON list of guarantors" }, { "namespace": "org.apache.fineract.integrationtests.guarantor.GuarantorTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/guarantor/GuarantorTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration testing of the Guarantor module.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.inlinecob", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBHelper.java", "mechanism": "REST", "name": "Execute Inline Loan COB", "description": "Invokes the Fineract API to run the Loan Close of Business job inline for specific loans.", "path": "/fineract-provider/api/v1/jobs/LOAN_COB/inline", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object containing a list of loan IDs (e.g., {\"loanIds\": [1, 2]})", "responseBody": "JSON response from the server (structure depends on Utils implementation)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.inlinecob.InlineLoanCOBTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming Fineract APIs to create entities, manage loans, and trigger COB processes.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Get Health", "description": "Checks the health of the interoperation service.", "path": "/fineract-provider/api/v1/interoperation/health", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Get Party", "description": "Retrieves party information by identifier.", "path": "/fineract-provider/api/v1/interoperation/parties/{idType}/{idValue}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Post Party", "description": "Registers or updates a party.", "path": "/fineract-provider/api/v1/interoperation/parties/{idType}/{idValue}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON containing accountId" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Delete Party", "description": "Deletes a party.", "path": "/fineract-provider/api/v1/interoperation/parties/{idType}/{idValue}", "method": "DELETE", "direction": "CONSUMER", "requestBody": "JSON containing accountId" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Get Transaction Request", "description": "Retrieves a transaction request.", "path": "/fineract-provider/api/v1/interoperation/transactions/{transactionCode}/requests/{requestCode}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Post Transaction Request", "description": "Creates a transaction request.", "path": "/fineract-provider/api/v1/interoperation/requests", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with transaction details" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Get Quote", "description": "Retrieves a quote.", "path": "/fineract-provider/api/v1/interoperation/transactions/{transactionCode}/quotes/{quoteCode}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Post Quote", "description": "Creates a quote.", "path": "/fineract-provider/api/v1/interoperation/quotes", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with quote details" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Get Transfer", "description": "Retrieves a transfer.", "path": "/fineract-provider/api/v1/interoperation/transactions/{transactionCode}/transfers/{transferCode}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropHelper.java", "mechanism": "REST", "name": "Post Transfer", "description": "Creates or prepares a transfer.", "path": "/fineract-provider/api/v1/interoperation/transfers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with transfer details" }, { "namespace": "org.apache.fineract.integrationtests.interoperation.InteropTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/interoperation/InteropTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to perform integration tests.", "path": "Various (managed by helper classes)", "method": "GET, POST, PUT, DELETE", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Determined by Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.investor.externalassetowner", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/investor/externalassetowner/ExternalAssetOwnerTransferCancelTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming Fineract APIs to perform operations like creating clients, loans, and managing asset transfers.", "path": "Various (e.g., /loans, /external-asset-owners)", "method": "GET, POST, PUT, DELETE", "direction": "PRODUCER", "protocol": "HTTP/1.1", "connectionInfo": "Configured via Utils.initializeRESTAssured()" }, { "namespace": "org.apache.fineract.integrationtests.investor.externalassetowner", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/investor/externalassetowner/ExternalAssetOwnerTransferTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Consumes Fineract REST APIs to perform integration tests.", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "Configured via Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()" }, { "namespace": "org.apache.fineract.integrationtests.investor.externalassetowner", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/investor/externalassetowner/SearchExternalAssetOwnerTransferTest.java", "mechanism": "REST", "name": "External Asset Owner API", "description": "Consumes the External Asset Owner REST API to search for, initiate, and cancel asset transfers.", "path": "/external-asset-owners/transfers/search", "method": "GET", "direction": "CONSUMER", "requestBody": "PagedRequestExternalAssetOwnerSearchRequest (as query params)", "responseBody": "PageExternalTransferData" }, { "namespace": "org.apache.fineract.integrationtests.investor.externalassetowner.InitiateExternalAssetOwnerTransferTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/investor/externalassetowner/InitiateExternalAssetOwnerTransferTest.java", "mechanism": "REST", "name": "Fineract API", "description": "Interacts with the Fineract platform API to create clients, loans, and manage external asset owner transfers.", "direction": "CONSUMER", "authentication": "Basic Auth", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.support.instancemode", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/support/instancemode/InstanceModeSupportExtension.java", "mechanism": "REST", "name": "Instance Mode Configuration API", "description": "Calls the application's API to change the instance mode (read/write/batch settings).", "direction": "PRODUCER", "authentication": "Basic Auth (via Utils helper)", "protocol": "HTTP", "connectionInfo": "Managed by RestAssured configuration" }, { "namespace": "org.apache.fineract.integrationtests.support.instancemode", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/support/instancemode/InstanceModeHelper.java", "mechanism": "REST", "name": "Change Instance Mode", "description": "Updates the operational mode of the Fineract instance via API.", "path": "/fineract-provider/api/v1/instance-mode", "method": "PUT", "direction": "PRODUCER", "requestBody": "ChangeInstanceModeRequest (JSON)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Create Role", "description": "Creates a new role via the API.", "path": "/fineract-provider/api/v1/roles", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with 'name' and 'description'", "responseBody": "JSON object containing 'resourceId'" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Get Role Details", "description": "Retrieves details of a specific role.", "path": "/fineract-provider/api/v1/roles/{roleId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object with role details" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Disable Role", "description": "Disables a role using a command parameter.", "path": "/fineract-provider/api/v1/roles/{roleId}?command=disable", "method": "POST", "direction": "CONSUMER", "responseBody": "JSON object containing 'resourceId'" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Enable Role", "description": "Enables a role using a command parameter.", "path": "/fineract-provider/api/v1/roles/{roleId}?command=enable", "method": "POST", "direction": "CONSUMER", "responseBody": "JSON object containing 'resourceId'" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Delete Role", "description": "Deletes a role.", "path": "/fineract-provider/api/v1/roles/{roleId}?command=enable", "method": "DELETE", "direction": "CONSUMER", "responseBody": "JSON object containing 'resourceId'" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.roles", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/roles/RolesHelper.java", "mechanism": "REST", "name": "Update Permissions", "description": "Updates permissions for a role.", "path": "/fineract-provider/api/v1/roles/{roleId}/permissions", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with 'permissions' map", "responseBody": "JSON response" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.users", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/users/UserHelper.java", "mechanism": "REST", "name": "Create User", "description": "Creates a new user in the system.", "path": "/fineract-provider/api/v1/users", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object containing user details (username, firstname, lastname, email, officeId, staffId, roles, etc.)", "responseBody": "JSON object containing the resourceId of the created user" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.users", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/users/UserHelper.java", "mechanism": "REST", "name": "Get Users", "description": "Retrieves a list of all users.", "path": "/fineract-provider/api/v1/users", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of user objects" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.users", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/users/UserHelper.java", "mechanism": "REST", "name": "Update User", "description": "Updates an existing user.", "path": "/fineract-provider/api/v1/users/{userId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object containing fields to update", "responseBody": "JSON object containing changes" }, { "namespace": "org.apache.fineract.integrationtests.useradministration.users", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/useradministration/users/UserHelper.java", "mechanism": "REST", "name": "Delete User", "description": "Deletes a user from the system.", "path": "/fineract-provider/api/v1/users/{userId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object confirming deletion" }, { "namespace": "org.apache.fineract.integrationtests.variableinstallments.VariableInstallmentsIntegrationTest", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/variableinstallments/VariableInstallmentsIntegrationTest.java", "mechanism": "REST", "name": "Fineract API", "description": "The test class acts as a REST client consuming the Fineract API to create products, clients, loans, and manage installments.", "direction": "CONSUMER", "authentication": "Basic Auth (Base64 encoded key)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.integrationtests.variableinstallments.VariableIntallmentsTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/variableinstallments/VariableIntallmentsTransactionHelper.java", "mechanism": "REST", "name": "Retrieve Loan Schedule", "description": "Fetches the repayment schedule for a loan via the Fineract API.", "path": "/fineract-provider/api/v1/loans/{loanId}", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "https://localhost:8443/fineract-provider/api/v1/loans/" }, { "namespace": "org.apache.fineract.integrationtests.variableinstallments.VariableIntallmentsTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/variableinstallments/VariableIntallmentsTransactionHelper.java", "mechanism": "REST", "name": "Calculate Loan Schedule (Validate Variations)", "description": "Calculates the loan schedule based on provided variations without persisting them.", "path": "/fineract-provider/api/v1/loans/{loanId}/schedule", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON string containing variation exceptions", "protocol": "HTTP", "connectionInfo": "https://localhost:8443/fineract-provider/api/v1/loans/" }, { "namespace": "org.apache.fineract.integrationtests.variableinstallments.VariableIntallmentsTransactionHelper", "filepath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/variableinstallments/VariableIntallmentsTransactionHelper.java", "mechanism": "REST", "name": "Add Variations (Submit Variations)", "description": "Submits variable installment variations to be added to the loan schedule.", "path": "/fineract-provider/api/v1/loans/{loanId}/schedule", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON string containing variation exceptions", "protocol": "HTTP", "connectionInfo": "https://localhost:8443/fineract-provider/api/v1/loans/" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Interoperation API", "description": "Main API resource for interoperation functionality.", "path": "/v1/interoperation", "method": "GET, POST, DELETE", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Health Check", "description": "Health check endpoint.", "path": "/v1/interoperation/health", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Account Details", "description": "Endpoint to retrieve account details.", "path": "/v1/interoperation/accounts/{accountId}", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Account Transactions", "description": "Endpoint to retrieve account transactions.", "path": "/v1/interoperation/accounts/{accountId}/transactions", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Account Identifiers", "description": "Endpoint to retrieve account identifiers.", "path": "/v1/interoperation/accounts/{accountId}/identifiers", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Account By Identifier", "description": "Endpoint to retrieve account by identifier.", "path": "/v1/interoperation/parties/{idType}/{idValue}", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Register Account Identifier", "description": "Endpoint to register account identifier.", "path": "/v1/interoperation/parties/{idType}/{idValue}", "method": "POST" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Delete Account Identifier", "description": "Endpoint to delete account identifier.", "path": "/v1/interoperation/parties/{idType}/{idValue}", "method": "DELETE" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Transaction Request", "description": "Endpoint to get transaction request details.", "path": "/v1/interoperation/transactions/{transactionCode}/requests/{requestCode}", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Create Transaction Request", "description": "Endpoint to create a transaction request.", "path": "/v1/interoperation/requests", "method": "POST" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Quote", "description": "Endpoint to get quote details.", "path": "/v1/interoperation/transactions/{transactionCode}/quotes/{quoteCode}", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Create Quote", "description": "Endpoint to create a quote.", "path": "/v1/interoperation/quotes", "method": "POST" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Transfer", "description": "Endpoint to get transfer details.", "path": "/v1/interoperation/transactions/{transactionCode}/transfers/{transferCode}", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Perform Transfer", "description": "Endpoint to perform a transfer.", "path": "/v1/interoperation/transfers", "method": "POST" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Get Client KYC", "description": "Endpoint to get client KYC.", "path": "/v1/interoperation/accounts/{accountId}/kyc", "method": "GET" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Disburse Loan", "description": "Endpoint to disburse a loan.", "path": "/v1/interoperation/transactions/{accountId}/disburse", "method": "POST" }, { "namespace": "org.apache.fineract.interoperation.api.InteropApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/interoperation/api/InteropApiResource.java", "mechanism": "REST", "name": "Loan Repayment", "description": "Endpoint to repay a loan.", "path": "/v1/interoperation/transactions/{accountId}/loanrepayment", "method": "POST" }, { "namespace": "org.apache.fineract.investor.api", "filepath": "fineract-investor/src/main/java/org/apache/fineract/investor/api/ExternalAssetOwnersApiResource.java", "mechanism": "REST", "name": "External Asset Owners API", "description": "Provides endpoints for managing external asset owners, including loan transfers (sale/buyback), cancellations, and data retrieval.", "path": "/v1/external-asset-owners", "method": "GET, POST", "direction": "BIDIRECTIONAL", "authentication": "Platform User Rights (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.investor.exception.exceptionmapper.ExternalAssetOwnerInitiateTransferExceptionMapper", "filepath": "fineract-investor/src/main/java/org/apache/fineract/investor/exception/exceptionmapper/ExternalAssetOwnerInitiateTransferExceptionMapper.java", "mechanism": "REST", "name": "ExternalAssetOwnerInitiateTransferExceptionMapper", "description": "JAX-RS ExceptionMapper that maps ExternalAssetOwnerInitiateTransferException to HTTP 403 responses.", "direction": "PRODUCER", "responseBody": "JSON object representing ApiParameterError", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.investor.service", "filepath": "fineract-investor/src/main/java/org/apache/fineract/investor/service/ExternalAssetOwnerLoanStatusChangePlatformServiceImpl.java", "mechanism": "OTHER", "name": "LoanStatusChangedBusinessEvent Listener", "description": "Consumes internal business events triggered when a loan's status changes.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.investor.service.CancelLoanFromExternalAssetOwnerHandler", "filepath": "fineract-investor/src/main/java/org/apache/fineract/investor/service/CancelLoanFromExternalAssetOwnerHandler.java", "mechanism": "OTHER", "name": "ASSET_OWNER_TRANSACTION CANCEL", "description": "Fineract Command Handler for cancelling asset owner transactions.", "path": "ASSET_OWNER_TRANSACTION / CANCEL", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.mix.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/mix/api/MixTaxonomyMappingApiResource.java", "mechanism": "REST", "name": "retrieveTaxonomyMapping", "description": "Endpoint to retrieve MIX taxonomy mapping data.", "path": "/v1/mixmapping", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of MixTaxonomyMappingData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.mix.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/mix/api/MixTaxonomyMappingApiResource.java", "mechanism": "REST", "name": "updateTaxonomyMapping", "description": "Endpoint to update MIX taxonomy mapping configuration.", "path": "/v1/mixmapping", "method": "PUT", "requestBody": "JSON configuration for taxonomy mapping", "responseBody": "JSON representation of CommandProcessingResult", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.mix.api.MixReportApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/mix/api/MixReportApiResource.java", "mechanism": "REST", "name": "retrieveXBRLReport", "description": "Endpoint to retrieve XBRL reports based on date range and currency.", "path": "/v1/mixreport", "method": "GET", "responseBody": "XML String (application/xml)" }, { "namespace": "org.apache.fineract.mix.api.MixTaxonomyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/mix/api/MixTaxonomyApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Retrieves the list of Mix Taxonomy data.", "path": "/v1/mixtaxonomy", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON list of MixTaxonomyData", "authentication": "Platform Security Context", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.mix.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/mix/handler/UpdateTaxonomyMappingCommandHandler.java", "mechanism": "OTHER", "name": "XBRLMAPPING UPDATE Command Handler", "description": "Registers a handler for the Fineract Command Query Separation (CQS) engine to process UPDATE actions on XBRLMAPPING entities.", "path": "XBRLMAPPING/UPDATE", "direction": "CONSUMER", "requestBody": "JsonCommand", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.notification.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/api/NotificationApiResource.java", "mechanism": "REST", "name": "getAllNotifications", "description": "Endpoint to retrieve paginated notifications for the user.", "path": "/v1/notifications", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of Page", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.notification.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/api/NotificationApiResource.java", "mechanism": "REST", "name": "update", "description": "Endpoint to mark notifications as read.", "path": "/v1/notifications", "method": "PUT", "requestBody": "None", "responseBody": "None", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.notification.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/api/NotificationApiResourceSwagger.java", "mechanism": "REST", "name": "GetNotificationsResponse", "description": "Defines the schema and example structure for the response body of the notification retrieval REST API endpoint.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.notification.config", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/config/MessagingConfiguration.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "NotificationQueue", "description": "JMS Queue used for receiving notification events.", "queueOrTopicName": "NotificationQueue", "direction": "CONSUMER", "connectionInfo": "tcp://localhost:61616 (default) or configured via 'brokerUrl' property" }, { "namespace": "org.apache.fineract.notification.config", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/config/MessagingConfiguration.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "JmsTemplate", "description": "JMS Template configured for sending messages to ActiveMQ.", "direction": "PRODUCER", "connectionInfo": "tcp://localhost:61616 (default) or configured via 'brokerUrl' property" }, { "namespace": "org.apache.fineract.notification.eventandlistener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/eventandlistener/ActiveMQNotificationEventListener.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "ActiveMQ Notification Listener", "description": "Consumes JMS messages containing NotificationData objects when ActiveMQ is enabled.", "messageType": "ObjectMessage containing NotificationData", "direction": "CONSUMER", "protocol": "JMS (Jakarta Messaging)", "connectionInfo": "Managed by Spring JMS container (implied by SessionAwareMessageListener)" }, { "namespace": "org.apache.fineract.notification.eventandlistener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/eventandlistener/SpringNotificationEventPublisher.java", "mechanism": "OTHER", "name": "Spring Application Event Bus", "description": "Publishes internal application events using Spring's ApplicationEventPublisher mechanism.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.notification.eventandlistener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/eventandlistener/ActiveMQNotificationEventPublisher.java", "mechanism": "ACTIVEMQ-QUEUE", "name": "NotificationQueue", "description": "ActiveMQ queue used for broadcasting notification events.", "path": "NotificationQueue", "queueOrTopicName": "NotificationQueue", "messageType": "ObjectMessage (NotificationData)", "direction": "PRODUCER", "protocol": "JMS/ActiveMQ", "connectionInfo": "Managed by JmsTemplate" }, { "namespace": "org.apache.fineract.notification.eventandlistener", "filepath": "fineract-provider/src/main/java/org/apache/fineract/notification/eventandlistener/SpringNotificationEventListener.java", "mechanism": "OTHER", "name": "Spring Application Event Listener", "description": "Listens for internal Spring application events (NotificationEvent) as an alternative to external messaging when ActiveMQ is disabled.", "messageType": "NotificationEvent", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.oauth2tests.OAuth2AuthenticationTest", "filepath": "oauth2-tests/src/test/java/org/apache/fineract/oauth2tests/OAuth2AuthenticationTest.java", "mechanism": "REST", "name": "Actuator Health", "description": "Spring Boot Actuator health check endpoint used to verify service availability.", "path": "/fineract-provider/actuator/health", "method": "GET", "direction": "CONSUMER", "protocol": "HTTP", "connectionInfo": "https://localhost:8443" }, { "namespace": "org.apache.fineract.oauth2tests.OAuth2AuthenticationTest", "filepath": "oauth2-tests/src/test/java/org/apache/fineract/oauth2tests/OAuth2AuthenticationTest.java", "mechanism": "REST", "name": "Keycloak Token Endpoint", "description": "External Identity Provider endpoint used to obtain OAuth2 tokens.", "path": "/auth/realms/fineract/token", "method": "POST", "direction": "CONSUMER", "requestBody": "grant_type, client_id, client_secret, assertion", "responseBody": "access_token", "protocol": "HTTP", "connectionInfo": "http://localhost:9000" }, { "namespace": "org.apache.fineract.oauth2tests.OAuth2AuthenticationTest", "filepath": "oauth2-tests/src/test/java/org/apache/fineract/oauth2tests/OAuth2AuthenticationTest.java", "mechanism": "REST", "name": "Fineract API - Offices", "description": "Protected API endpoint to retrieve office details.", "path": "/fineract-provider/api/v1/offices/1", "method": "GET", "direction": "CONSUMER", "authentication": "Bearer Token (OAuth2)", "protocol": "HTTP", "connectionInfo": "https://localhost:8443" }, { "namespace": "org.apache.fineract.oauth2tests.OAuth2AuthenticationTest", "filepath": "oauth2-tests/src/test/java/org/apache/fineract/oauth2tests/OAuth2AuthenticationTest.java", "mechanism": "REST", "name": "Fineract API - User Details", "description": "Protected API endpoint to retrieve current user authentication details.", "path": "/fineract-provider/api/v1/userdetails", "method": "GET", "direction": "CONSUMER", "authentication": "Bearer Token (OAuth2)", "protocol": "HTTP", "connectionInfo": "https://localhost:8443" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Create Holiday", "description": "Endpoint to create a new holiday.", "path": "/v1/holidays", "method": "POST", "requestBody": "JSON object with holiday details (name, dates, offices)", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Activate Holiday", "description": "Endpoint to activate a pending holiday.", "path": "/v1/holidays/{holidayId}", "method": "POST", "requestBody": "Empty JSON or specific command parameters", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Retrieve Holiday", "description": "Endpoint to retrieve a single holiday by ID.", "path": "/v1/holidays/{holidayId}", "method": "GET", "responseBody": "JSON object representing HolidayData" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Update Holiday", "description": "Endpoint to update an existing holiday.", "path": "/v1/holidays/{holidayId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Delete Holiday", "description": "Endpoint to soft-delete a holiday.", "path": "/v1/holidays/{holidayId}", "method": "DELETE", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "List Holidays", "description": "Endpoint to list holidays with optional filtering.", "path": "/v1/holidays", "method": "GET", "responseBody": "JSON array of HolidayData objects" }, { "namespace": "org.apache.fineract.organisation.holiday.api.HolidaysApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/holiday/api/HolidaysApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve options for repayment schedule updates.", "path": "/v1/holidays/template", "method": "GET", "responseBody": "JSON object with template options" }, { "namespace": "org.apache.fineract.organisation.monetary.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/monetary/api/CurrenciesApiResource.java", "mechanism": "REST", "name": "Retrieve Currency Configuration", "description": "Endpoint to retrieve the list of permitted and available currencies.", "path": "/v1/currencies", "method": "GET", "direction": "PRODUCER", "responseBody": "ApplicationCurrencyConfigurationData (JSON)" }, { "namespace": "org.apache.fineract.organisation.monetary.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/monetary/api/CurrenciesApiResource.java", "mechanism": "REST", "name": "Update Currency Configuration", "description": "Endpoint to update the list of permitted currencies.", "path": "/v1/currencies", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON payload with currency options", "responseBody": "CommandProcessingResult (JSON)" }, { "namespace": "org.apache.fineract.organisation.office.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficeTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Office Transactions", "description": "Endpoint to get a list of office transactions.", "path": "/v1/officetransactions", "method": "GET", "responseBody": "JSON array of OfficeTransactionData", "authentication": "PlatformSecurityContext (Internal)" }, { "namespace": "org.apache.fineract.organisation.office.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficeTransactionsApiResource.java", "mechanism": "REST", "name": "New Office Transaction Template", "description": "Endpoint to retrieve a template for creating a new office transaction.", "path": "/v1/officetransactions/template", "method": "GET", "responseBody": "JSON object of OfficeTransactionData (template)", "authentication": "PlatformSecurityContext (Internal)" }, { "namespace": "org.apache.fineract.organisation.office.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficeTransactionsApiResource.java", "mechanism": "REST", "name": "Transfer Money", "description": "Endpoint to create a new office transaction (transfer money).", "path": "/v1/officetransactions", "method": "POST", "requestBody": "JSON object defining the transaction", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext (Internal)" }, { "namespace": "org.apache.fineract.organisation.office.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficeTransactionsApiResource.java", "mechanism": "REST", "name": "Delete Transaction", "description": "Endpoint to delete a specific office transaction.", "path": "/v1/officetransactions/{transactionId}", "method": "DELETE", "responseBody": "JSON object of CommandProcessingResult", "authentication": "PlatformSecurityContext (Internal)" }, { "namespace": "org.apache.fineract.organisation.office.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResourceSwagger.java", "mechanism": "REST", "name": "Offices API Schemas", "description": "Defines the Swagger/OpenAPI schemas (Request and Response bodies) for the Offices REST API endpoints.", "direction": "BOTH", "protocol": "HTTP/JSON" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "List Offices", "description": "Endpoint to retrieve a list of offices.", "path": "/v1/offices", "method": "GET", "responseBody": "JSON array of OfficeData" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Create Office", "description": "Endpoint to create a new office.", "path": "/v1/offices", "method": "POST", "requestBody": "JSON object with office details", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Retrieve Office", "description": "Endpoint to retrieve a specific office by ID.", "path": "/v1/offices/{officeId}", "method": "GET", "responseBody": "JSON object of OfficeData" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Update Office", "description": "Endpoint to update an existing office.", "path": "/v1/offices/{officeId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Retrieve Office by External ID", "description": "Endpoint to retrieve an office using an external ID.", "path": "/v1/offices/external-id/{externalId}", "method": "GET", "responseBody": "JSON object of OfficeData" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Endpoint to download an Excel template for bulk import.", "path": "/v1/offices/downloadtemplate", "method": "GET", "responseBody": "application/vnd.ms-excel file" }, { "namespace": "org.apache.fineract.organisation.office.api.OfficesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/office/api/OfficesApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Endpoint to upload a filled Excel template for bulk import.", "path": "/v1/offices/uploadtemplate", "method": "POST", "requestBody": "Multipart form data with file", "responseBody": "JSON object with import document ID" }, { "namespace": "org.apache.fineract.organisation.provisioning.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/api/ProvisioningCategoryApiResource.java", "mechanism": "REST", "name": "Retrieve All Provisioning Categories", "description": "Endpoint to retrieve all provisioning categories.", "path": "/v1/provisioningcategory", "method": "GET", "responseBody": "JSON array of ProvisioningCategoryData", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.provisioning.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/api/ProvisioningCategoryApiResource.java", "mechanism": "REST", "name": "Create Provisioning Category", "description": "Endpoint to create a new provisioning category.", "path": "/v1/provisioningcategory", "method": "POST", "requestBody": "JSON object defining the category", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.provisioning.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/api/ProvisioningCategoryApiResource.java", "mechanism": "REST", "name": "Update Provisioning Category", "description": "Endpoint to update an existing provisioning category.", "path": "/v1/provisioningcategory/{categoryId}", "method": "PUT", "requestBody": "JSON object with updates", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.provisioning.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/api/ProvisioningCategoryApiResource.java", "mechanism": "REST", "name": "Delete Provisioning Category", "description": "Endpoint to delete a provisioning category.", "path": "/v1/provisioningcategory/{categoryId}", "method": "DELETE", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.provisioning.api.ProvisioningCriteriaApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/api/ProvisioningCriteriaApiResource.java", "mechanism": "REST", "name": "Provisioning Criteria API", "description": "RESTful endpoints for managing Provisioning Criteria.", "path": "/v1/provisioningcriteria", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.provisioning.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/handler/UpdateProvisioningCategoryRequestCommandHandler.java", "mechanism": "OTHER", "name": "PROVISIONCATEGORY UPDATE Command Handler", "description": "Registers a handler for the 'UPDATE' action on 'PROVISIONCATEGORY' entities within the Fineract command framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.provisioning.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/handler/CreateProvisioningCriteriaRequestCommandHandler.java", "mechanism": "OTHER", "name": "PROVISIONCRITERIA CREATE Handler", "description": "Registers as a handler for the internal Command Bus for the entity 'PROVISIONCRITERIA' and action 'CREATE'.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.provisioning.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/provisioning/handler/CreateProvisioningCategoryRequestCommandHandler.java", "mechanism": "OTHER", "name": "PROVISIONCATEGORY CREATE Command", "description": "Registers a handler for the internal command bus to process 'CREATE' actions for 'PROVISIONCATEGORY' entities.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Retrieve Staff", "path": "/v1/staff", "method": "GET", "responseBody": "JSON array of StaffData", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "create", "description": "Create a staff member", "path": "/v1/staff", "method": "POST", "requestBody": "JSON object (StaffApiResourceSwagger.PostStaffRequest)", "responseBody": "JSON object (StaffApiResourceSwagger.CreateStaffResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "retrieveOne", "description": "Retrieve a Staff Member", "path": "/v1/staff/{staffId}", "method": "GET", "responseBody": "JSON object (StaffApiResourceSwagger.RetrieveOneResponse)", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "update", "description": "Update a Staff Member", "path": "/v1/staff/{staffId}", "method": "PUT", "requestBody": "JSON object (StaffApiResourceSwagger.PutStaffRequest)", "responseBody": "JSON object (StaffApiResourceSwagger.UpdateStaffResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "getTemplate", "description": "Download staff import template", "path": "/v1/staff/downloadtemplate", "method": "GET", "responseBody": "application/vnd.ms-excel", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.staff.api.StaffApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/staff/api/StaffApiResource.java", "mechanism": "REST", "name": "postTemplate", "description": "Upload staff template", "path": "/v1/staff/uploadtemplate", "method": "POST", "requestBody": "multipart/form-data", "responseBody": "JSON object (Import Document ID)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.teller.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerJournalApiResource.java", "mechanism": "REST", "name": "getJournalData", "description": "REST endpoint to retrieve cashier journal entries.", "path": "/v1/cashiersjournal", "method": "GET", "requestBody": "None", "responseBody": "JSON array of TellerJournalData objects", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.teller.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/CashierApiResource.java", "mechanism": "REST", "name": "Get Cashier Data", "description": "Endpoint to retrieve cashier information based on filters.", "path": "/v1/cashiers", "method": "GET", "requestBody": "None", "responseBody": "JSON array of CashierData objects", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Get Tellers", "description": "Retrieves list of tellers", "path": "/v1/tellers", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Create Teller", "description": "Creates a new teller", "path": "/v1/tellers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with teller details" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Find Teller", "description": "Retrieves a specific teller", "path": "/v1/tellers/{tellerId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Update Teller", "description": "Updates a specific teller", "path": "/v1/tellers/{tellerId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload with updated teller details" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Delete Teller", "description": "Deletes a specific teller", "path": "/v1/tellers/{tellerId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Get Cashiers", "description": "Lists cashiers for a teller", "path": "/v1/tellers/{tellerId}/cashiers", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Create Cashier", "description": "Allocates a cashier to a teller", "path": "/v1/tellers/{tellerId}/cashiers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with cashier allocation details" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Find Cashier", "description": "Retrieves a specific cashier", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Update Cashier", "description": "Updates a cashier allocation", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload with updated cashier details" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Delete Cashier", "description": "Deletes a cashier allocation", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Allocate Cash", "description": "Allocates cash to a cashier", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}/allocate", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with allocation amount and currency" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Settle Cash", "description": "Settles cash from a cashier", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}/settle", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with settlement amount and currency" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Get Cashier Transactions", "description": "Retrieves transactions for a cashier", "path": "/v1/tellers/{tellerId}/cashiers/{cashierId}/transactions", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Get Teller Transactions", "description": "Retrieves transactions for a teller", "path": "/v1/tellers/{tellerId}/transactions", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.teller.api.TellerApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/teller/api/TellerApiResource.java", "mechanism": "REST", "name": "Get Teller Journals", "description": "Retrieves journals for a teller", "path": "/v1/tellers/{tellerId}/journals", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.organisation.workingdays.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/workingdays/api/WorkingDaysApiResource.java", "mechanism": "REST", "name": "List Working days", "description": "Retrieves the list of working days configuration.", "path": "/v1/workingdays", "method": "GET", "requestBody": "None", "responseBody": "JSON array of WorkingDaysData", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.workingdays.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/workingdays/api/WorkingDaysApiResource.java", "mechanism": "REST", "name": "Update a Working Day", "description": "Updates the configuration for working days.", "path": "/v1/workingdays", "method": "PUT", "requestBody": "JSON object (PutWorkingDaysRequest)", "responseBody": "JSON object (PutWorkingDaysResponse)", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.organisation.workingdays.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/organisation/workingdays/api/WorkingDaysApiResource.java", "mechanism": "REST", "name": "Working Days Template", "description": "Retrieves template data for working days UI.", "path": "/v1/workingdays/template", "method": "GET", "requestBody": "None", "responseBody": "JSON object (GetWorkingDaysTemplateResponse)", "authentication": "PlatformSecurityContext (internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve standing instruction template data.", "path": "/v1/standinginstructions/template", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionApiResource.java", "mechanism": "REST", "name": "Create Standing Instruction", "description": "Endpoint to create a new standing instruction.", "path": "/v1/standinginstructions", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload defined by StandingInstructionApiResourceSwagger.PostStandingInstructionsRequest" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionApiResource.java", "mechanism": "REST", "name": "Update/Delete Standing Instruction", "description": "Endpoint to update or delete a standing instruction.", "path": "/v1/standinginstructions/{standingInstructionId}", "method": "PUT", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload defined by StandingInstructionApiResourceSwagger.PutStandingInstructionsStandingInstructionIdRequest" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionApiResource.java", "mechanism": "REST", "name": "List Standing Instructions", "description": "Endpoint to list standing instructions with filtering.", "path": "/v1/standinginstructions", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionApiResource.java", "mechanism": "REST", "name": "Retrieve Standing Instruction", "description": "Endpoint to retrieve a specific standing instruction.", "path": "/v1/standinginstructions/{standingInstructionId}", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/StandingInstructionHistoryApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Endpoint to retrieve standing instruction run history", "path": "/v1/standinginstructionrunhistory", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of StandingInstructionHistoryData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "Retrieve Account Transfer Template", "description": "Retrieves a template for creating account transfers.", "path": "/v1/accounttransfers/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON (AccountTransferData)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "Create new Transfer", "description": "Creates a new transfer of monetary funds.", "path": "/v1/accounttransfers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (PostAccountTransfersRequest)", "responseBody": "JSON (PostAccountTransfersResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "List account transfers", "description": "Lists account transfers with pagination and search.", "path": "/v1/accounttransfers", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON (GetAccountTransfersResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "Retrieve account transfer", "description": "Retrieves a specific account transfer by ID.", "path": "/v1/accounttransfers/{transferId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON (GetAccountTransfersPageItems)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "Retrieve Refund Template", "description": "Retrieves a template for refunding a loan by transfer.", "path": "/v1/accounttransfers/templateRefundByTransfer", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON (GetAccountTransfersTemplateRefundByTransferResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.account.api.AccountTransfersApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/account/api/AccountTransfersApiResource.java", "mechanism": "REST", "name": "Refund by Transfer", "description": "Executes a refund of an active loan by transfer.", "path": "/v1/accounttransfers/refundByTransfer", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON (PostAccountTransfersRefundByTransferRequest)", "responseBody": "JSON (PostAccountTransfersRefundByTransferResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Retrieve Share Account Template", "description": "Retrieves the template data required for creating a share account.", "path": "/v1/accounts/{type}/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object containing field defaults and allowed value lists" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Retrieve Share Account", "description": "Retrieves details of a specific share account.", "path": "/v1/accounts/{type}/{accountId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object representing the share account" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "List Share Accounts", "description": "Lists share applications or accounts with pagination.", "path": "/v1/accounts/{type}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of share accounts" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Create Share Account", "description": "Submits a new share application.", "path": "/v1/accounts/{type}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object with account details (clientId, productId, etc.)", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Handle Account Commands", "description": "Performs actions like approve, reject, activate, close, or redeem on a share account.", "path": "/v1/accounts/{type}/{accountId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object specific to the command (e.g., note, date)", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Update Share Account", "description": "Modifies a share application.", "path": "/v1/accounts/{type}/{accountId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Downloads an Excel template for bulk import.", "path": "/v1/accounts/{type}/downloadtemplate", "method": "GET", "direction": "CONSUMER", "responseBody": "application/vnd.ms-excel file" }, { "namespace": "org.apache.fineract.portfolio.accounts.api.AccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/api/AccountsApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Uploads a populated Excel template for bulk import.", "path": "/v1/accounts/{type}/uploadtemplate", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart form data containing the file", "responseBody": "JSON object with import document ID" }, { "namespace": "org.apache.fineract.portfolio.address.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/address/api/EntityFieldConfigurationApiResource.java", "mechanism": "REST", "name": "getAddresses", "description": "Retrieves the Entity Field Configuration for a specific entity.", "path": "/v1/fieldconfiguration/{entity}", "method": "GET", "requestBody": "None", "responseBody": "JSON array of FieldConfigurationData", "authentication": "PlatformSecurityContext (Internal Token/Session)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.calendar.api.CalendarsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/calendar/api/CalendarsApiResource.java", "mechanism": "REST", "name": "Calendar Management API", "description": "API endpoints for managing calendars associated with entities.", "path": "/v1/{entityType}/{entityId}/calendars", "method": "GET, POST, PUT, DELETE", "requestBody": "JSON (for POST/PUT)", "responseBody": "JSON (CalendarData or CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.calendar.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/calendar/handler/UpdateCalendarCommandHandler.java", "mechanism": "OTHER", "name": "CALENDAR UPDATE Command Handler", "description": "Registers a handler for UPDATE actions on the CALENDAR entity via the Fineract Command framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "retrieveAllCharges", "description": "Retrieve list of defined charges", "path": "/v1/charges", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of ChargeData", "authentication": "PlatformSecurityContext (READ permission)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "retrieveCharge", "description": "Retrieve details of a specific charge", "path": "/v1/charges/{chargeId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of ChargeData", "authentication": "PlatformSecurityContext (READ permission)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "retrieveNewChargeDetails", "description": "Retrieve charge template", "path": "/v1/charges/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of ChargeData (Template)", "authentication": "PlatformSecurityContext (READ permission)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "createCharge", "description": "Create a new charge", "path": "/v1/charges", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object (PostChargesRequest)", "responseBody": "JSON object (PostChargesResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "updateCharge", "description": "Update an existing charge", "path": "/v1/charges/{chargeId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object (PutChargesChargeIdRequest)", "responseBody": "JSON object (PutChargesChargeIdResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.api.ChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/api/ChargesApiResource.java", "mechanism": "REST", "name": "deleteCharge", "description": "Delete a charge", "path": "/v1/charges/{chargeId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "JSON object (DeleteChargesChargeIdResponse)", "authentication": "PlatformSecurityContext", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.charge.service.ChargeReadPlatformServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/charge/service/ChargeReadPlatformServiceImpl.java", "mechanism": "OTHER", "name": "Spring Cache", "description": "The method 'retrieveAllCharges' is annotated with @Cacheable(value = \"charges\", ...), indicating it integrates with a caching mechanism (like EhCache, Redis, or an in-memory map) managed by Spring's cache abstraction layer. This caches the full list of charges to improve performance for subsequent requests.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "retrieveAllClientIdentifiers", "description": "List all Identifiers for a Client", "path": "/v1/clients/{clientId}/identifiers", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of ClientIdentifierData" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "newClientIdentifierDetails", "description": "Retrieve Client Identifier Details Template", "path": "/v1/clients/{clientId}/identifiers/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of ClientIdentifierData with template fields" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "createClientIdentifier", "description": "Create an Identifier for a Client", "path": "/v1/clients/{clientId}/identifiers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON object (PostClientsClientIdIdentifiersRequest)", "responseBody": "JSON object (PostClientsClientIdIdentifiersResponse)" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "retrieveClientIdentifiers", "description": "Retrieve a specific Client Identifier", "path": "/v1/clients/{clientId}/identifiers/{identifierId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object of ClientIdentifierData" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "updateClientIdentifer", "description": "Update a Client Identifier", "path": "/v1/clients/{clientId}/identifiers/{identifierId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON object (PutClientsClientIdIdentifiersIdentifierIdRequest)", "responseBody": "JSON object (PutClientsClientIdIdentifiersIdentifierIdResponse)" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientIdentifiersApiResource.java", "mechanism": "REST", "name": "deleteClientIdentifier", "description": "Delete a Client Identifier", "path": "/v1/clients/{clientId}/identifiers/{identifierId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "JSON object (DeleteClientsClientIdIdentifiersIdentifierIdResponse)" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientAddressApiResource.java", "mechanism": "REST", "name": "getAddressesTemplate", "description": "Endpoint to retrieve an address template", "path": "/v1/client/addresses/template", "method": "GET", "responseBody": "JSON object containing address template fields" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientAddressApiResource.java", "mechanism": "REST", "name": "addClientAddress", "description": "Endpoint to create a new address for a client", "path": "/v1/client/{clientid}/addresses", "method": "POST", "requestBody": "JSON object with address details", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientAddressApiResource.java", "mechanism": "REST", "name": "getAddresses", "description": "Endpoint to list addresses for a client with optional filtering", "path": "/v1/client/{clientid}/addresses", "method": "GET", "responseBody": "JSON array of address data objects" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientAddressApiResource.java", "mechanism": "REST", "name": "updateClientAddress", "description": "Endpoint to update an existing client address", "path": "/v1/client/{clientid}/addresses", "method": "PUT", "requestBody": "JSON object with updated address fields", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Get Family Member", "description": "Retrieves a single family member by ID.", "path": "/v1/clients/{clientId}/familymembers/{familyMemberId}", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object representing ClientFamilyMembersData" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Get Family Members", "description": "Retrieves all family members for a client.", "path": "/v1/clients/{clientId}/familymembers", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON array of ClientFamilyMembersData" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Get Template", "description": "Retrieves a template for creating a family member.", "path": "/v1/clients/{clientId}/familymembers/template", "method": "GET", "direction": "CONSUMER", "responseBody": "JSON object with template options" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Update Family Member", "description": "Updates an existing family member.", "path": "/v1/clients/{clientId}/familymembers/{familyMemberId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload with update details", "responseBody": "JSON object representing CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Add Family Member", "description": "Creates a new family member.", "path": "/v1/clients/{clientId}/familymembers", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with new family member details", "responseBody": "JSON object representing CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientFamilyMembersApiResource.java", "mechanism": "REST", "name": "Delete Family Member", "description": "Deletes a family member.", "path": "/v1/clients/{clientId}/familymembers/{familyMemberId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "JSON object representing CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResourceSwagger.java", "mechanism": "REST", "name": "GetClientsClientIdTransactionsResponse", "description": "Defines the response schema for retrieving a paginated list of client transactions.", "path": "/clients/{clientId}/transactions", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing totalFilteredRecords and a set of pageItems (transactions)." }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResourceSwagger.java", "mechanism": "REST", "name": "GetClientsClientIdTransactionsTransactionIdResponse", "description": "Defines the response schema for retrieving a specific client transaction by ID.", "path": "/clients/{clientId}/transactions/{transactionId}", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing transaction details like id, officeId, type, date, currency, and amount." }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResourceSwagger.java", "mechanism": "REST", "name": "PostClientsClientIdTransactionsTransactionIdResponse", "description": "Defines the response schema for modifying a specific client transaction (e.g., undoing a transaction).", "path": "/clients/{clientId}/transactions/{transactionId}", "method": "POST", "direction": "PRODUCER", "responseBody": "JSON object containing resourceId, clientId, and officeId." }, { "namespace": "org.apache.fineract.portfolio.client.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/InternalClientInformationApiResource.java", "mechanism": "REST", "name": "Get Client Audit Fields", "description": "Endpoint to retrieve audit information (created/modified details) for a specific client.", "path": "/v1/internal/client/{clientId}/audit", "method": "GET", "requestBody": "None", "responseBody": "JSON object containing audit fields (createdBy, createdDate, lastModifiedBy, lastModifiedDate)", "authentication": "unknown", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "List Client Charges", "description": "Retrieves a paginated list of charges for a client.", "path": "/v1/clients/{clientId}/charges", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Retrieves a template for creating a new client charge.", "path": "/v1/clients/{clientId}/charges/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "Retrieve Client Charge", "description": "Retrieves a specific client charge.", "path": "/v1/clients/{clientId}/charges/{chargeId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "Add Client Charge", "description": "Creates a new charge for a client.", "path": "/v1/clients/{clientId}/charges", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload defined by ClientChargesApiResourceSwagger.PostClientsClientIdChargesRequest" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "Pay, Waive, or Inactivate Charge", "description": "Performs actions (pay, waive, inactivate) on a client charge based on the command parameter.", "path": "/v1/clients/{clientId}/charges/{chargeId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload defined by ClientChargesApiResourceSwagger.PostClientsClientIdChargesChargeIdRequest" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientChargesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientChargesApiResource.java", "mechanism": "REST", "name": "Delete Client Charge", "description": "Deletes a client charge.", "path": "/v1/clients/{clientId}/charges/{chargeId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "List Client Transactions (Internal ID)", "description": "Retrieve all transactions for a client using internal ID", "path": "/v1/clients/{clientId}/transactions", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON list of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Transaction (Internal ID)", "description": "Retrieve a specific transaction using internal IDs", "path": "/v1/clients/{clientId}/transactions/{transactionId}", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON object of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Undo Client Transaction (Internal ID)", "description": "Undo a specific transaction using internal IDs", "path": "/v1/clients/{clientId}/transactions/{transactionId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload (optional)", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "List Client Transactions (External ID)", "description": "Retrieve all transactions for a client using external ID", "path": "/v1/clients/external-id/{clientExternalId}/transactions", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON list of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Transaction (External ID)", "description": "Retrieve a specific transaction using external client ID", "path": "/v1/clients/external-id/{clientExternalId}/transactions/{transactionId}", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON object of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Undo Client Transaction (External ID)", "description": "Undo a specific transaction using external client ID", "path": "/v1/clients/external-id/{clientExternalId}/transactions/{transactionId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload (optional)", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Transaction (External Transaction ID)", "description": "Retrieve a specific transaction using external transaction ID", "path": "/v1/clients/{clientId}/transactions/external-id/{transactionExternalId}", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON object of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Transaction (Both External IDs)", "description": "Retrieve a specific transaction using both external client and transaction IDs", "path": "/v1/clients/external-id/{clientExternalId}/transactions/external-id/{transactionExternalId}", "method": "GET", "direction": "CONSUMER", "requestBody": "n/a", "responseBody": "JSON object of ClientTransactionData" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Undo Client Transaction (External Transaction ID)", "description": "Undo a specific transaction using external transaction ID", "path": "/v1/clients/{clientId}/transactions/external-id/{transactionExternalId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload (optional)", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientTransactionsApiResource.java", "mechanism": "REST", "name": "Undo Client Transaction (Both External IDs)", "description": "Undo a specific transaction using both external client and transaction IDs", "path": "/v1/clients/external-id/{clientExternalId}/transactions/external-id/{transactionExternalId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload (optional)", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Template", "description": "Retrieve Client Details Template", "path": "/v1/clients/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "List Clients", "description": "List Clients with pagination and sorting", "path": "/v1/clients", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Client", "description": "Retrieve a Client by ID", "path": "/v1/clients/{clientId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Create Client", "description": "Create a Client", "path": "/v1/clients", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with client details" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Update Client", "description": "Update a Client", "path": "/v1/clients/{clientId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload with updates" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Delete Client", "description": "Delete a Client", "path": "/v1/clients/{clientId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Activate/Command Client", "description": "Activate, Close, Reject, Withdraw, etc.", "path": "/v1/clients/{clientId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload for command" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Client Accounts", "description": "Retrieve client accounts overview", "path": "/v1/clients/{clientId}/accounts", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Download client import template", "path": "/v1/clients/downloadtemplate", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Upload client template", "path": "/v1/clients/uploadtemplate", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart form data" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Obligee Details", "description": "Retrieve client obligee details", "path": "/v1/clients/{clientId}/obligeedetails", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Transfer Proposal", "description": "Retrieve client transfer template", "path": "/v1/clients/{clientId}/transferproposaldate", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Client by External ID", "description": "Retrieve a Client by External Id", "path": "/v1/clients/external-id/{externalId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Accounts by External ID", "description": "Retrieve client accounts overview by External Id", "path": "/v1/clients/external-id/{externalId}/accounts", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Update Client by External ID", "description": "Update a Client using the External Id", "path": "/v1/clients/external-id/{externalId}", "method": "PUT", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Command Client by External ID", "description": "Activate/Command Client using External Id", "path": "/v1/clients/external-id/{externalId}", "method": "POST", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Delete Client by External ID", "description": "Delete a Client using External Id", "path": "/v1/clients/external-id/{externalId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Obligee by External ID", "description": "Retrieve client obligee details using External Id", "path": "/v1/clients/external-id/{externalId}/obligeedetails", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.ClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientsApiResource.java", "mechanism": "REST", "name": "Retrieve Transfer Proposal by External ID", "description": "Retrieve client transfer template using External Id", "path": "/v1/clients/external-id/{externalId}/transferproposaldate", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.api.v2.search.ClientSearchV2ApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/v2/search/ClientSearchV2ApiResource.java", "mechanism": "REST", "name": "searchByText", "description": "API endpoint for searching clients by text.", "path": "/v2/clients/search", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "PagedRequest (JSON)", "responseBody": "Page (JSON)" }, { "namespace": "org.apache.fineract.portfolio.client.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/handler/CreateClientChargeCommandHandler.java", "mechanism": "OTHER", "name": "CLIENT_CHARGE_ACTION_CREATE", "description": "Internal command handler registration for creating client charges. This handler is mapped to the 'CLIENT_CHARGES' resource and 'CREATE' action via the Fineract Command Bus.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/handler/CreateClientCommandHandler.java", "mechanism": "OTHER", "name": "CLIENT CREATE Command Handler", "description": "Registers as a handler for the CREATE action on the CLIENT entity within the Fineract command processing framework.", "path": "CLIENT/CREATE", "method": "CommandType Annotation", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.client.service.ClientWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/client/service/ClientWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Publishes business events (ClientCreateBusinessEvent, ClientActivateBusinessEvent, ClientRejectBusinessEvent) to the internal event handling system.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.collateral.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateral/api/CollateralsApiResource.java", "mechanism": "REST", "name": "Loan Collateral API", "description": "API endpoints for managing loan collaterals.", "path": "/v1/loans/{loanId}/collaterals", "method": "GET, POST, PUT, DELETE", "requestBody": "JSON (for POST/PUT)", "responseBody": "JSON", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Get Client Collaterals", "description": "Retrieve a list of collateral products for a client.", "path": "/v1/clients/{clientId}/collaterals", "method": "GET", "direction": "PRODUCER", "responseBody": "List" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Get Client Collateral Data", "description": "Retrieve details of a specific client collateral.", "path": "/v1/clients/{clientId}/collaterals/{clientCollateralId}", "method": "GET", "direction": "PRODUCER", "responseBody": "ClientCollateralManagementData" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Get Client Collateral Template", "description": "Retrieve the template for creating client collateral.", "path": "/v1/clients/{clientId}/collaterals/template", "method": "GET", "direction": "PRODUCER", "responseBody": "List" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Add Client Collateral", "description": "Create a new collateral entry for a client.", "path": "/v1/clients/{clientId}/collaterals", "method": "POST", "direction": "CONSUMER", "requestBody": "PostClientCollateralRequest", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Update Client Collateral", "description": "Update an existing collateral entry.", "path": "/v1/clients/{clientId}/collaterals/{collateralId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "PutClientCollateralRequest", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/ClientCollateralManagementApiResource.java", "mechanism": "REST", "name": "Delete Client Collateral", "description": "Delete a client collateral entry.", "path": "/v1/clients/{clientId}/collaterals/{collateralId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "createCollateral", "description": "Endpoint to create a new collateral product.", "path": "/v1/collateral-management", "method": "POST", "requestBody": "JSON representation of CollateralManagementProduct", "responseBody": "JSON representation of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "getCollateral", "description": "Endpoint to fetch a specific collateral product by ID.", "path": "/v1/collateral-management/{collateralId}", "method": "GET", "responseBody": "JSON representation of CollateralManagementData" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "getAllCollaterals", "description": "Endpoint to fetch all collateral products.", "path": "/v1/collateral-management", "method": "GET", "responseBody": "JSON array of CollateralManagementData" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "getCollateralTemplate", "description": "Endpoint to fetch the template (currencies) for creating collaterals.", "path": "/v1/collateral-management/template", "method": "GET", "responseBody": "JSON array of CurrencyData" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "updateCollateral", "description": "Endpoint to update an existing collateral product.", "path": "/v1/collateral-management/{collateralId}", "method": "PUT", "requestBody": "JSON representation of updates", "responseBody": "JSON representation of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/CollateralManagementApiResource.java", "mechanism": "REST", "name": "deleteCollateral", "description": "Endpoint to delete a collateral product.", "path": "/v1/collateral-management/{collateralId}", "method": "DELETE", "responseBody": "JSON representation of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/LoanCollateralManagementApiResource.java", "mechanism": "REST", "name": "deleteLoanCollateral", "description": "Endpoint to delete a loan collateral entry.", "path": "/v1/loan-collateral-management/{id}", "method": "DELETE", "requestBody": "n/a", "responseBody": "JSON representation of CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.collateralmanagement.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collateralmanagement/api/LoanCollateralManagementApiResource.java", "mechanism": "REST", "name": "getLoanCollateral", "description": "Endpoint to retrieve details of a loan collateral entry.", "path": "/v1/loan-collateral-management/{collateralId}", "method": "GET", "requestBody": "n/a", "responseBody": "JSON representation of LoanCollateralResponseData", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.collectionsheet.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collectionsheet/api/CollectionSheetApiResource.java", "mechanism": "REST", "name": "generateCollectionSheet", "description": "Generates or saves individual collection sheets based on the command parameter.", "path": "/v1/collectionsheet", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload (CollectionSheetApiResourceSwagger.PostCollectionSheetRequest)", "responseBody": "JSON response (CollectionSheetApiResourceSwagger.PostCollectionSheetResponse)" }, { "namespace": "org.apache.fineract.portfolio.collectionsheet.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/collectionsheet/handler/SaveIndividualCollectionSheetCommandHandler.java", "mechanism": "OTHER", "name": "COLLECTIONSHEET SAVE Command Handler", "description": "Registers a handler for the SAVE action on the COLLECTIONSHEET entity using the Fineract Command framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "getDelinquencyRanges", "description": "List all Delinquency Ranges", "path": "/v1/delinquency/ranges", "method": "GET", "direction": "PRODUCER", "responseBody": "Array of DelinquencyRangeData", "authentication": "PlatformSecurityContext (READ permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "getDelinquencyRange", "description": "Retrieve a specific Delinquency Range based on the Id", "path": "/v1/delinquency/ranges/{delinquencyRangeId}", "method": "GET", "direction": "PRODUCER", "responseBody": "DelinquencyRangeData", "authentication": "PlatformSecurityContext (READ permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "createDelinquencyRange", "description": "Create Delinquency Range", "path": "/v1/delinquency/ranges", "method": "POST", "direction": "CONSUMER", "requestBody": "PostDelinquencyRangeRequest", "responseBody": "PostDelinquencyRangeResponse", "authentication": "PlatformSecurityContext (CREATE permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "updateDelinquencyRange", "description": "Update Delinquency Range based on the Id", "path": "/v1/delinquency/ranges/{delinquencyRangeId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "PostDelinquencyRangeRequest", "responseBody": "PutDelinquencyRangeResponse", "authentication": "PlatformSecurityContext (UPDATE permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "deleteDelinquencyRange", "description": "Delete Delinquency Range based on the Id", "path": "/v1/delinquency/ranges/{delinquencyRangeId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "DeleteDelinquencyRangeResponse", "authentication": "PlatformSecurityContext (DELETE permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "getDelinquencyBuckets", "description": "List all Delinquency Buckets", "path": "/v1/delinquency/buckets", "method": "GET", "direction": "PRODUCER", "responseBody": "Array of DelinquencyBucketData", "authentication": "PlatformSecurityContext (READ permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "getDelinquencyBucket", "description": "Retrieve a specific Delinquency Bucket based on the Id", "path": "/v1/delinquency/buckets/{delinquencyBucketId}", "method": "GET", "direction": "PRODUCER", "responseBody": "DelinquencyBucketData", "authentication": "PlatformSecurityContext (READ permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "createDelinquencyBucket", "description": "Create Delinquency Bucket", "path": "/v1/delinquency/buckets", "method": "POST", "direction": "CONSUMER", "requestBody": "PostDelinquencyBucketRequest", "responseBody": "PostDelinquencyBucketResponse", "authentication": "PlatformSecurityContext (CREATE permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "updateDelinquencyBucket", "description": "Update Delinquency Bucket based on the Id", "path": "/v1/delinquency/buckets/{delinquencyBucketId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "PostDelinquencyBucketRequest", "responseBody": "PutDelinquencyBucketResponse", "authentication": "PlatformSecurityContext (UPDATE permission)" }, { "namespace": "org.apache.fineract.portfolio.delinquency.api.DelinquencyApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java", "mechanism": "REST", "name": "deleteDelinquencyBucket", "description": "Delete Delinquency Bucket based on the Id", "path": "/v1/delinquency/buckets/{delinquencyBucketId}", "method": "DELETE", "direction": "CONSUMER", "responseBody": "DeleteDelinquencyBucketResponse", "authentication": "PlatformSecurityContext (DELETE permission)" }, { "namespace": "org.apache.fineract.portfolio.floatingrates.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/floatingrates/api/FloatingRatesApiResource.java", "mechanism": "REST", "name": "Create Floating Rate", "description": "Endpoint to create a new floating rate.", "path": "/v1/floatingrates", "method": "POST", "requestBody": "JSON object with floating rate details (name, isBaseLendingRate, etc.)", "responseBody": "JSON object containing the result of the creation command", "authentication": "PlatformSecurityContext (implied)" }, { "namespace": "org.apache.fineract.portfolio.floatingrates.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/floatingrates/api/FloatingRatesApiResource.java", "mechanism": "REST", "name": "List Floating Rates", "description": "Endpoint to retrieve all floating rates.", "path": "/v1/floatingrates", "method": "GET", "responseBody": "JSON array of floating rate data", "authentication": "PlatformSecurityContext (implied)" }, { "namespace": "org.apache.fineract.portfolio.floatingrates.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/floatingrates/api/FloatingRatesApiResource.java", "mechanism": "REST", "name": "Retrieve Floating Rate", "description": "Endpoint to retrieve a single floating rate by ID.", "path": "/v1/floatingrates/{floatingRateId}", "method": "GET", "responseBody": "JSON object of the floating rate data", "authentication": "PlatformSecurityContext (implied)" }, { "namespace": "org.apache.fineract.portfolio.floatingrates.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/floatingrates/api/FloatingRatesApiResource.java", "mechanism": "REST", "name": "Update Floating Rate", "description": "Endpoint to update an existing floating rate.", "path": "/v1/floatingrates/{floatingRateId}", "method": "PUT", "requestBody": "JSON object with updated floating rate details", "responseBody": "JSON object containing the result of the update command", "authentication": "PlatformSecurityContext (implied)" }, { "namespace": "org.apache.fineract.portfolio.floatingrates.handler.UpdateFloatingRateCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/floatingrates/handler/UpdateFloatingRateCommandHandler.java", "mechanism": "OTHER", "name": "FLOATINGRATE UPDATE Command Handler", "description": "Registers a handler for the 'UPDATE' action on the 'FLOATINGRATE' entity within the application's command processing framework.", "direction": "CONSUMER", "protocol": "Internal Command Bus" }, { "namespace": "org.apache.fineract.portfolio.fund.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/fund/api/FundsApiResource.java", "mechanism": "REST", "name": "retrieveFunds", "description": "Endpoint to retrieve a list of funds.", "path": "/v1/funds", "method": "GET", "responseBody": "JSON array of FundData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.fund.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/fund/api/FundsApiResource.java", "mechanism": "REST", "name": "createFund", "description": "Endpoint to create a new fund.", "path": "/v1/funds", "method": "POST", "requestBody": "JSON object defining the fund", "responseBody": "JSON object with command processing result", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.fund.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/fund/api/FundsApiResource.java", "mechanism": "REST", "name": "retrieveFund", "description": "Endpoint to retrieve a specific fund by ID.", "path": "/v1/funds/{fundId}", "method": "GET", "responseBody": "JSON object of FundData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.fund.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/fund/api/FundsApiResource.java", "mechanism": "REST", "name": "updateFund", "description": "Endpoint to update an existing fund.", "path": "/v1/funds/{fundId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.fund.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/fund/handler/CreateFundCommandHandler.java", "mechanism": "OTHER", "name": "CREATE FUND Command Handler", "description": "Fineract Command Handler registered for Entity 'FUND' and Action 'CREATE'.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/GroupsApiResource.java", "mechanism": "REST", "name": "Groups API", "description": "RESTful endpoints for managing Groups.", "path": "/v1/groups", "method": "GET, POST, PUT, DELETE", "requestBody": "JSON (application/json) or Multipart (multipart/form-data)", "responseBody": "JSON (application/json) or Excel (application/vnd.ms-excel)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Retrieve Center Template", "description": "Endpoint to retrieve a template for creating or closing a center.", "path": "/v1/centers/template", "method": "GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "List Centers", "description": "Endpoint to retrieve a paginated list of centers.", "path": "/v1/centers", "method": "GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Retrieve Center", "description": "Endpoint to retrieve details of a specific center.", "path": "/v1/centers/{centerId}", "method": "GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Create Center", "description": "Endpoint to create a new center.", "path": "/v1/centers", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with center details (name, officeId, etc.)" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Update Center", "description": "Endpoint to update an existing center.", "path": "/v1/centers/{centerId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with fields to update" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Delete Center", "description": "Endpoint to delete a center.", "path": "/v1/centers/{centerId}", "method": "DELETE", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Center Actions", "description": "Endpoint to perform actions like activate, close, or manage groups for a center.", "path": "/v1/centers/{centerId}", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON payload specific to the command" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Retrieve Center Accounts", "description": "Endpoint to retrieve account summaries for a center.", "path": "/v1/centers/{centerId}/accounts", "method": "GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Endpoint to download the bulk import Excel template.", "path": "/v1/centers/downloadtemplate", "method": "GET", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.group.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/CentersApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Endpoint to upload a bulk import Excel file.", "path": "/v1/centers/uploadtemplate", "method": "POST", "direction": "PRODUCER", "requestBody": "Multipart form data containing the file" }, { "namespace": "org.apache.fineract.portfolio.group.api.GroupsLevelApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/api/GroupsLevelApiResource.java", "mechanism": "REST", "name": "retrieveAllGroups", "description": "API endpoint to retrieve all group levels.", "path": "/v1/grouplevels", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON collection of GroupLevelData", "authentication": "PlatformSecurityContext (Requires 'GROUP' read permission)", "protocol": "HTTP" }, { "namespace": "org.apache.fineract.portfolio.group.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/handler/CloseCenterCommandHandler.java", "mechanism": "OTHER", "name": "CommandType CENTER CLOSE", "description": "Registers a handler for the CLOSE action on CENTER entities within the Fineract command processing framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.group.service.GroupingTypesWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/group/service/GroupingTypesWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Publishes business events (CentersCreateBusinessEvent, GroupsCreateBusinessEvent) to an internal event handling system.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Retrieve Chart Template", "description": "Retrieves a template for creating a new interest rate chart.", "path": "/v1/interestratecharts/template", "method": "GET", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Retrieve All Charts", "description": "Retrieves all interest rate charts, optionally filtered by product ID.", "path": "/v1/interestratecharts", "method": "GET", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Retrieve One Chart", "description": "Retrieves a specific interest rate chart by ID.", "path": "/v1/interestratecharts/{chartId}", "method": "GET", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Create Chart", "description": "Creates a new interest rate chart.", "path": "/v1/interestratecharts", "method": "POST", "requestBody": "JSON payload defined by PostInterestRateChartsRequest", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Update Chart", "description": "Updates an existing interest rate chart.", "path": "/v1/interestratecharts/{chartId}", "method": "PUT", "requestBody": "JSON payload defined by PutInterestRateChartsChartIdRequest", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartsApiResource.java", "mechanism": "REST", "name": "Delete Chart", "description": "Deletes an interest rate chart.", "path": "/v1/interestratecharts/{chartId}", "method": "DELETE", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a template for creating a new interest rate chart slab.", "path": "/v1/interestratecharts/{chartId}/chartslabs/template", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Retrieve All Slabs", "description": "Endpoint to retrieve all slabs associated with a chart.", "path": "/v1/interestratecharts/{chartId}/chartslabs", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Retrieve One Slab", "description": "Endpoint to retrieve a single slab by ID.", "path": "/v1/interestratecharts/{chartId}/chartslabs/{chartSlabId}", "method": "GET", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Create Slab", "description": "Endpoint to create a new interest rate slab.", "path": "/v1/interestratecharts/{chartId}/chartslabs", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload with slab details (periodType, fromPeriod, annualInterestRate, etc.)" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Update Slab", "description": "Endpoint to update an existing slab.", "path": "/v1/interestratecharts/{chartId}/chartslabs/{chartSlabId}", "method": "PUT", "direction": "BIDIRECTIONAL", "requestBody": "JSON payload with fields to update" }, { "namespace": "org.apache.fineract.portfolio.interestratechart.api.InterestRateChartSlabsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/interestratechart/api/InterestRateChartSlabsApiResource.java", "mechanism": "REST", "name": "Delete Slab", "description": "Endpoint to delete a slab.", "path": "/v1/interestratecharts/{chartId}/chartslabs/{chartSlabId}", "method": "DELETE", "direction": "BIDIRECTIONAL" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanChargesApiResource.java", "mechanism": "REST", "name": "Loan Charges API", "description": "REST API endpoints for managing loan charges.", "path": "/v1/loans", "method": "GET, POST, PUT, DELETE", "requestBody": "JSON (LoanChargeData)", "responseBody": "JSON (LoanChargeData or CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanScheduleApiResource.java", "mechanism": "REST", "name": "Loan Schedule Endpoint", "description": "Endpoint to calculate loan schedules or manage loan term variations.", "path": "/v1/loans/{loanId}/schedule", "method": "POST", "requestBody": "JSON payload containing schedule exceptions or variation details (LoanScheduleApiResourceSwagger.PostLoansLoanIdScheduleRequest)", "responseBody": "JSON containing LoanScheduleData or CommandProcessingResult", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/BulkLoansApiResource.java", "mechanism": "REST", "name": "loanReassignmentTemplate", "description": "Endpoint to retrieve template data for bulk loan reassignment.", "path": "/v1/loans/loanreassignment/template", "method": "GET", "requestBody": "None (Query Parameters: officeId, fromLoanOfficerId)", "responseBody": "JSON representation of BulkTransferLoanOfficerData", "authentication": "PlatformSecurityContext (OAuth2/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/BulkLoansApiResource.java", "mechanism": "REST", "name": "loanReassignment", "description": "Endpoint to execute the bulk loan reassignment command.", "path": "/v1/loans/loanreassignment", "method": "POST", "requestBody": "JSON payload containing reassignment details", "responseBody": "JSON representation of CommandProcessingResult", "authentication": "PlatformSecurityContext (OAuth2/Basic implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanDisbursementDetailApiResource.java", "mechanism": "REST", "name": "updateDisbursementDate", "description": "Updates the disbursement date for a specific loan disbursement.", "path": "/v1/loans/{loanId}/disbursements/{disbursementId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanDisbursementDetailApiResource.java", "mechanism": "REST", "name": "addAndDeleteDisbursementDetail", "description": "Adds or deletes disbursement details for a loan.", "path": "/v1/loans/{loanId}/disbursements/editDisbursements", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanDisbursementDetailApiResource.java", "mechanism": "REST", "name": "retriveDetail", "description": "Retrieves details of a specific disbursement.", "path": "/v1/loans/{loanId}/disbursements/{disbursementId}", "method": "GET", "direction": "PRODUCER", "requestBody": "None", "responseBody": "JSON" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.InternalLoanInformationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/InternalLoanInformationApiResource.java", "mechanism": "REST", "name": "Get Loan Audit Fields", "description": "Endpoint to retrieve audit metadata for a loan.", "path": "/v1/internal/loan/{loanId}/audit", "method": "GET", "direction": "PRODUCER", "requestBody": "none", "responseBody": "JSON object containing createdBy, createdDate, lastModifiedBy, lastModifiedDate" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.InternalLoanInformationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/InternalLoanInformationApiResource.java", "mechanism": "REST", "name": "Get Loan Transaction Audit Fields", "description": "Endpoint to retrieve audit metadata for a loan transaction.", "path": "/v1/internal/loan/{loanId}/transaction/{transactionId}/audit", "method": "GET", "direction": "PRODUCER", "requestBody": "none", "responseBody": "JSON object containing createdBy, createdDate, lastModifiedBy, lastModifiedDate" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.InternalLoanInformationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/InternalLoanInformationApiResource.java", "mechanism": "REST", "name": "Get Loans By Status", "description": "Endpoint to retrieve a list of loan IDs matching a status.", "path": "/v1/internal/loan/status/{statusId}", "method": "GET", "direction": "PRODUCER", "requestBody": "none", "responseBody": "JSON array of Long (loan IDs)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.InternalLoanInformationApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/InternalLoanInformationApiResource.java", "mechanism": "REST", "name": "Get Advanced Payment Allocation Rules", "description": "Endpoint to retrieve payment allocation rules for a loan.", "path": "/v1/internal/loan/{loanId}/advanced-payment-allocation-rules", "method": "GET", "direction": "PRODUCER", "requestBody": "none", "responseBody": "JSON array of AdvancedPaymentData" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoanTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoanTransactionsApiResource.java", "mechanism": "REST", "name": "Loan Transactions API", "description": "API endpoints for managing loan transactions (retrieval, execution, adjustment).", "path": "/v1/loans", "method": "GET, POST, PUT", "requestBody": "JSON (LoanTransactionData)", "responseBody": "JSON (LoanTransactionData or CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Approval Template", "description": "Endpoint to retrieve the approval template for a loan.", "path": "/v1/loans/{loanId}/template", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Template", "description": "Endpoint to retrieve a template for creating a new loan application.", "path": "/v1/loans/template", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan", "description": "Endpoint to retrieve details of a specific loan.", "path": "/v1/loans/{loanId}", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "List Loans", "description": "Endpoint to list loans with pagination and search.", "path": "/v1/loans", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Calculate Schedule or Submit Application", "description": "Endpoint to calculate loan schedule or submit a new application.", "path": "/v1/loans", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Modify Loan Application", "description": "Endpoint to modify an existing loan application.", "path": "/v1/loans/{loanId}", "method": "PUT" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Delete Loan Application", "description": "Endpoint to delete a loan application.", "path": "/v1/loans/{loanId}", "method": "DELETE" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "State Transitions", "description": "Endpoint to perform state transitions (approve, disburse, etc.) on a loan.", "path": "/v1/loans/{loanId}", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Download Loan Template", "description": "Endpoint to download Excel template for loan import.", "path": "/v1/loans/downloadtemplate", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Get GLIM Repayment Template", "description": "Endpoint to get repayment template for GLIM account.", "path": "/v1/loans/glimAccount/{glimId}", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "GLIM State Transitions", "description": "Endpoint for GLIM loan state transitions.", "path": "/v1/loans/glimAccount/{glimId}", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Download Repayment Template", "description": "Endpoint to download Excel template for repayment import.", "path": "/v1/loans/repayments/downloadtemplate", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Upload Loan Template", "description": "Endpoint to upload loan import file.", "path": "/v1/loans/uploadtemplate", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Upload Repayment Template", "description": "Endpoint to upload repayment import file.", "path": "/v1/loans/repayments/uploadtemplate", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Get Delinquency Tags", "description": "Endpoint to get delinquency tag history.", "path": "/v1/loans/{loanId}/delinquencytags", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Retrieve Approval Template (External ID)", "description": "Endpoint to retrieve approval template using external ID.", "path": "/v1/loans/external-id/{loanExternalId}/template", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan (External ID)", "description": "Endpoint to retrieve loan details using external ID.", "path": "/v1/loans/external-id/{loanExternalId}", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Modify Loan (External ID)", "description": "Endpoint to modify loan using external ID.", "path": "/v1/loans/external-id/{loanExternalId}", "method": "PUT" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Delete Loan (External ID)", "description": "Endpoint to delete loan using external ID.", "path": "/v1/loans/external-id/{loanExternalId}", "method": "DELETE" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "State Transitions (External ID)", "description": "Endpoint for state transitions using external ID.", "path": "/v1/loans/external-id/{loanExternalId}", "method": "POST" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.api.LoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/api/LoansApiResource.java", "mechanism": "REST", "name": "Get Delinquency Tags (External ID)", "description": "Endpoint to get delinquency tags using external ID.", "path": "/v1/loans/external-id/{loanExternalId}/delinquencytags", "method": "GET" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.guarantor.api.GuarantorsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/guarantor/api/GuarantorsApiResource.java", "mechanism": "REST", "name": "Guarantors API", "description": "RESTful endpoints for managing loan guarantors.", "path": "/v1/loans/{loanId}/guarantors", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.guarantor.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/guarantor/handler/DeleteGuarantorCommandHandler.java", "mechanism": "OTHER", "name": "GUARANTOR DELETE Command Handler", "description": "Registers a handler for the internal command processing system for the GUARANTOR entity with action DELETE.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/LoanRepaymentCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler (LOAN REPAYMENT)", "description": "Registers a handler for the internal command processing framework for Entity 'LOAN' and Action 'REPAYMENT'.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/LoanApplicationApprovalUndoCommandHandler.java", "mechanism": "OTHER", "name": "LOAN APPROVALUNDO Command Handler", "description": "Registers a handler for the internal command bus to process LOAN APPROVALUNDO actions.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/DeleteLoanChargeCommandHandler.java", "mechanism": "OTHER", "name": "LOANCHARGE DELETE Command Handler", "description": "Registers a handler for the internal command bus to process DELETE actions on LOANCHARGE entities.", "direction": "CONSUMER", "requestBody": "JsonCommand containing loanId and entityId", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/UpdateLoanChargeCommandHandler.java", "mechanism": "OTHER", "name": "Fineract Command Handler", "description": "Registers as a handler for the Fineract Command Processing infrastructure via @CommandType.", "path": "LOANCHARGE / UPDATE", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/GLIMBulkRepaymentCommandHandler.java", "mechanism": "OTHER", "name": "GLIMLOAN REPAYMENT Command Handler", "description": "Registers a handler for 'GLIMLOAN' entity 'REPAYMENT' actions within the Fineract command processing framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/WriteOffLoanCommandHandler.java", "mechanism": "OTHER", "name": "LOAN WRITEOFF Command Handler", "description": "Registers a handler for the 'WRITEOFF' action on 'LOAN' entities within the Fineract command processing framework.", "direction": "CONSUMER", "requestBody": "JsonCommand containing Loan ID and write-off details", "protocol": "Internal Java Interface / Spring Bean" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.handler.UndoChargeOffLoanCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/handler/UndoChargeOffLoanCommandHandler.java", "mechanism": "OTHER", "name": "LOAN UNDOCHARGEOFF", "description": "Fineract Command Handler registered for the LOAN entity and UNDOCHARGEOFF action.", "direction": "CONSUMER", "protocol": "Internal CQRS Dispatch" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.jobs.addaccrualentries", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/jobs/addaccrualentries/AddAccrualEntriesTasklet.java", "mechanism": "OTHER", "name": "AddAccrualEntriesTasklet", "description": "Spring Batch Tasklet execution point", "direction": "BOTH" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.jobs.addperiodicaccrualentriesforloanswithincomepostedastransactions", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/jobs/addperiodicaccrualentriesforloanswithincomepostedastransactions/AddPeriodicAccrualEntriesForLoansConfig.java", "mechanism": "OTHER", "name": "ADD_PERIODIC_ACCRUAL_ENTRIES_FOR_LOANS_WITH_INCOME_POSTED_AS_TRANSACTIONS", "description": "Spring Batch Job definition for processing periodic accrual entries.", "direction": "OTHER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.jobs.applychargetooverdueloaninstallment.ApplyChargeToOverdueLoanInstallmentConfig", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/jobs/applychargetooverdueloaninstallment/ApplyChargeToOverdueLoanInstallmentConfig.java", "mechanism": "OTHER", "name": "APPLY_CHARGE_TO_OVERDUE_LOAN_INSTALLMENT", "description": "Spring Batch Job definition for applying charges to overdue loans.", "direction": "OTHER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.jobs.applychargetooverdueloaninstallment.ApplyChargeToOverdueLoanInstallmentTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/jobs/applychargetooverdueloaninstallment/ApplyChargeToOverdueLoanInstallmentTasklet.java", "mechanism": "OTHER", "name": "Spring Batch Tasklet", "description": "Implements a Spring Batch Tasklet to run as a background job step.", "direction": "OTHER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.jobs.applyholidaystoloans", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/jobs/applyholidaystoloans/ApplyHolidaysToLoansTasklet.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Publishes internal business events when a loan is rescheduled due to a holiday.", "messageType": "LoanRescheduledDueHolidayBusinessEvent", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.api.RescheduleLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/rescheduleloan/api/RescheduleLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Reschedule Reasons Template", "description": "Endpoint to retrieve template data for creating reschedule requests.", "path": "/v1/rescheduleloans/template", "method": "GET", "responseBody": "JSON (LoanRescheduleRequestData)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.api.RescheduleLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/rescheduleloan/api/RescheduleLoansApiResource.java", "mechanism": "REST", "name": "Read Loan Reschedule Request", "description": "Endpoint to retrieve a specific request or preview a schedule.", "path": "/v1/rescheduleloans/{scheduleId}", "method": "GET", "responseBody": "JSON (LoanRescheduleRequestData or LoanScheduleData)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.api.RescheduleLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/rescheduleloan/api/RescheduleLoansApiResource.java", "mechanism": "REST", "name": "Create Loan Reschedule Request", "description": "Endpoint to submit a new loan reschedule request.", "path": "/v1/rescheduleloans", "method": "POST", "requestBody": "JSON", "responseBody": "JSON (CommandProcessingResult)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.api.RescheduleLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/rescheduleloan/api/RescheduleLoansApiResource.java", "mechanism": "REST", "name": "Update Loan Reschedule Request", "description": "Endpoint to approve or reject a reschedule request.", "path": "/v1/rescheduleloans/{scheduleId}", "method": "POST", "requestBody": "JSON", "responseBody": "JSON (CommandProcessingResult)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.rescheduleloan.api.RescheduleLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/rescheduleloan/api/RescheduleLoansApiResource.java", "mechanism": "REST", "name": "Retrieve All Reschedule Requests", "description": "Endpoint to list reschedule requests with optional filtering.", "path": "/v1/rescheduleloans", "method": "GET", "responseBody": "JSON Array (LoanRescheduleRequestData)" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/ReplayedTransactionBusinessEventServiceImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Internal application event bus for notifying business events.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanStatusChangePlatformServiceImpl.java", "mechanism": "OTHER", "name": "LoanStatusChangedBusinessEvent Listener", "description": "Listens for internal business events indicating a change in loan status.", "messageType": "LoanStatusChangedBusinessEvent", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.service.LoanApplicationWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanApplicationWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Publishes internal business events when loan states change (Created, Approved, Rejected, Undo Approval).", "messageType": "LoanBusinessEvent", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.loanaccount.service.LoanWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Internal event notification service used to broadcast business events (e.g., LoanDisbursalBusinessEvent) to other parts of the system.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Create Loan Product", "description": "Endpoint to create a new loan product.", "path": "/v1/loanproducts", "method": "POST", "requestBody": "JSON object representing the loan product definition", "responseBody": "JSON object with the created resource ID" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Retrieve All Loan Products", "description": "Endpoint to list all loan products.", "path": "/v1/loanproducts", "method": "GET", "responseBody": "JSON array of loan product data" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a template for creating loan products.", "path": "/v1/loanproducts/template", "method": "GET", "responseBody": "JSON object with default values and dropdown options" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Product", "description": "Endpoint to retrieve a single loan product by ID.", "path": "/v1/loanproducts/{productId}", "method": "GET", "responseBody": "JSON object with loan product details" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Update Loan Product", "description": "Endpoint to update a loan product by ID.", "path": "/v1/loanproducts/{productId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with the updated resource ID" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Product by External ID", "description": "Endpoint to retrieve a single loan product by its external ID.", "path": "/v1/loanproducts/external-id/{externalProductId}", "method": "GET", "responseBody": "JSON object with loan product details" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/api/LoanProductsApiResource.java", "mechanism": "REST", "name": "Update Loan Product by External ID", "description": "Endpoint to update a loan product by its external ID.", "path": "/v1/loanproducts/external-id/{externalProductId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with the updated resource ID" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/handler/CreateLoanProductCommandHandler.java", "mechanism": "OTHER", "name": "Fineract Command Handler", "description": "Registers a handler for the CREATE action on LOANPRODUCT entities via the Fineract Command framework annotation @CommandType.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.loanproduct.productmix.api.ProductMixApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/productmix/api/ProductMixApiResource.java", "mechanism": "REST", "name": "Product Mix API", "description": "RESTful endpoints for managing loan product mix configurations.", "path": "/v1/loanproducts/{productId}/productmix", "method": "GET, POST, PUT, DELETE", "requestBody": "JSON (ProductMixData)", "responseBody": "JSON (ProductMixData or CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.meeting.api.MeetingsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/meeting/api/MeetingsApiResource.java", "mechanism": "REST", "name": "Meetings API", "description": "API endpoints for managing meetings and attendance.", "path": "/v1/{entityType}/{entityId}/meetings", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.note.api.NotesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/note/api/NotesApiResource.java", "mechanism": "REST", "name": "Notes API", "description": "RESTful endpoints for managing notes on various resources.", "path": "/v1/{resourceType}/{resourceId}/notes", "method": "GET, POST, PUT, DELETE", "direction": "PRODUCER", "requestBody": "JSON (NoteData)", "responseBody": "JSON (NoteData or CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResource.java", "mechanism": "REST", "name": "getAllPaymentTypes", "description": "Retrieve all Payment Types", "path": "/v1/paymenttypes", "method": "GET", "responseBody": "JSON array of PaymentTypeData", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResource.java", "mechanism": "REST", "name": "retrieveOnePaymentType", "description": "Retrieve a Payment Type", "path": "/v1/paymenttypes/{paymentTypeId}", "method": "GET", "responseBody": "JSON object of PaymentTypeData", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResource.java", "mechanism": "REST", "name": "createPaymentType", "description": "Create a Payment Type", "path": "/v1/paymenttypes", "method": "POST", "requestBody": "JSON object (name, description, etc.)", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResource.java", "mechanism": "REST", "name": "updatePaymentType", "description": "Update a Payment Type", "path": "/v1/paymenttypes/{paymentTypeId}", "method": "PUT", "requestBody": "JSON object (fields to update)", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResource.java", "mechanism": "REST", "name": "deleteCode", "description": "Delete a Payment Type", "path": "/v1/paymenttypes/{paymentTypeId}", "method": "DELETE", "responseBody": "JSON object (CommandProcessingResult)", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.paymenttype.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/paymenttype/api/PaymentTypeApiResourceSwagger.java", "mechanism": "REST", "name": "Payment Types API Schemas", "description": "Defines the Swagger/OpenAPI schemas (Request and Response bodies) for Payment Type REST operations.", "path": "/paymenttypes (implied by schema names)", "method": "GET, POST, PUT, DELETE", "direction": "BOTH", "requestBody": "PostPaymentTypesRequest, PutPaymentTypesPaymentTypeIdRequest", "responseBody": "GetPaymentTypesResponse, PostPaymentTypesResponse, PutPaymentTypesPaymentTypeIdResponse, DeletePaymentTypesPaymentTypeIdResponse" }, { "namespace": "org.apache.fineract.portfolio.products.api.ProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/products/api/ProductsApiResource.java", "mechanism": "REST", "name": "Products API", "description": "RESTful endpoints for managing products.", "path": "/v1/products/{type}", "method": "GET, POST, PUT", "requestBody": "JSON (ProductData)", "responseBody": "JSON (ProductData or CommandProcessingResult)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.rate.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/rate/api/RateApiResource.java", "mechanism": "REST", "name": "retrieveRate", "description": "Endpoint to retrieve a single rate by ID.", "path": "/v1/rates/{rateId}", "method": "GET", "responseBody": "JSON representation of RateData" }, { "namespace": "org.apache.fineract.portfolio.rate.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/rate/api/RateApiResource.java", "mechanism": "REST", "name": "createRate", "description": "Endpoint to create a new rate.", "path": "/v1/rates", "method": "POST", "requestBody": "JSON payload for rate creation", "responseBody": "JSON representation of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.rate.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/rate/api/RateApiResource.java", "mechanism": "REST", "name": "getAllRates", "description": "Endpoint to retrieve all rates.", "path": "/v1/rates", "method": "GET", "responseBody": "JSON array of RateData" }, { "namespace": "org.apache.fineract.portfolio.rate.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/rate/api/RateApiResource.java", "mechanism": "REST", "name": "updateRate", "description": "Endpoint to update an existing rate.", "path": "/v1/rates/{rateId}", "method": "PUT", "requestBody": "JSON payload for rate update", "responseBody": "JSON representation of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/api/RepaymentWithPostDatedChecksApiResource.java", "mechanism": "REST", "name": "Get All Post Dated Checks", "description": "Endpoint to retrieve all post-dated checks for a loan.", "path": "/v1/loans/{loanId}/postdatedchecks", "method": "GET", "responseBody": "List" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/api/RepaymentWithPostDatedChecksApiResource.java", "mechanism": "REST", "name": "Get Post Dated Check", "description": "Endpoint to retrieve a specific post-dated check by installment ID.", "path": "/v1/loans/{loanId}/postdatedchecks/{installmentId}", "method": "GET", "responseBody": "PostDatedChecksData" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/api/RepaymentWithPostDatedChecksApiResource.java", "mechanism": "REST", "name": "Update Post Dated Check", "description": "Endpoint to update a post-dated check or mark it as bounced.", "path": "/v1/loans/{loanId}/postdatedchecks/{postDatedCheckId}", "method": "PUT", "requestBody": "JSON payload defined by PostDatedChecksApiResourceSwagger.UpdatePostDatedCheckRequest", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/api/RepaymentWithPostDatedChecksApiResource.java", "mechanism": "REST", "name": "Delete Post Dated Check", "description": "Endpoint to delete a post-dated check.", "path": "/v1/loans/{loanId}/postdatedchecks/{postDatedCheckId}", "method": "DELETE", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/handler/BouncePostDatedCheckHandler.java", "mechanism": "OTHER", "name": "Fineract Command Handler", "description": "Registers a handler for the REPAYMENT_WITH_POSTDATEDCHECKS entity and BOUNCE action.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.repaymentwithpostdatedchecks.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/repaymentwithpostdatedchecks/handler/EditPostDatedChecksHandler.java", "mechanism": "OTHER", "name": "REPAYMENT_WITH_POSTDATEDCHECKS UPDATE", "description": "Internal Command Handler for updating post-dated checks.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "Create Recurring Deposit Product", "description": "Endpoint to create a new recurring deposit product definition.", "path": "/v1/recurringdepositproducts", "method": "POST", "requestBody": "JSON object representing the recurring deposit product", "responseBody": "JSON object with the command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "Update Recurring Deposit Product", "description": "Endpoint to update an existing recurring deposit product.", "path": "/v1/recurringdepositproducts/{productId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with the command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "List Recurring Deposit Products", "description": "Endpoint to retrieve all recurring deposit products.", "path": "/v1/recurringdepositproducts", "method": "GET", "responseBody": "JSON array of recurring deposit products" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Recurring Deposit Product", "description": "Endpoint to retrieve a single recurring deposit product by ID.", "path": "/v1/recurringdepositproducts/{productId}", "method": "GET", "responseBody": "JSON object representing the recurring deposit product" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a template with default values and options for creating a product.", "path": "/v1/recurringdepositproducts/template", "method": "GET", "responseBody": "JSON object representing the product template" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositProductsApiResource.java", "mechanism": "REST", "name": "Delete Recurring Deposit Product", "description": "Endpoint to delete a recurring deposit product.", "path": "/v1/recurringdepositproducts/{productId}", "method": "DELETE", "responseBody": "JSON object with the command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountChargesApiResource.java", "mechanism": "REST", "name": "Savings Account Charges API", "description": "API endpoints for managing charges on savings accounts.", "path": "/v1/savingsaccounts/{savingsAccountId}/charges", "method": "GET, POST, PUT, DELETE", "direction": "BIDIRECTIONAL", "requestBody": "JSON (SavingsAccountChargeData)", "responseBody": "JSON (SavingsAccountChargeData or CommandProcessingResult)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Transaction Template", "description": "Retrieves the template data required for creating a new savings transaction.", "path": "/v1/savingsaccounts/{savingsId}/transactions/template", "method": "GET", "requestBody": "None", "responseBody": "JSON object containing template data and payment type options." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Retrieve Transaction", "description": "Retrieves a specific savings account transaction.", "path": "/v1/savingsaccounts/{savingsId}/transactions/{transactionId}", "method": "GET", "requestBody": "None", "responseBody": "JSON object representing the transaction." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Search Transactions", "description": "Searches for transactions based on query parameters.", "path": "/v1/savingsaccounts/{savingsId}/transactions/search", "method": "GET", "requestBody": "None", "responseBody": "JSON array/page of transactions." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Advanced Query", "description": "Executes an advanced search query for transactions.", "path": "/v1/savingsaccounts/{savingsId}/transactions/query", "method": "POST", "requestBody": "JSON object containing advanced query criteria.", "responseBody": "JSON list of query results." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Execute Transaction", "description": "Performs a transaction (deposit, withdrawal, etc.) based on the command parameter.", "path": "/v1/savingsaccounts/{savingsId}/transactions", "method": "POST", "requestBody": "JSON object containing transaction details.", "responseBody": "JSON object containing the command processing result." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Adjust Transaction", "description": "Modifies an existing transaction (reverse, undo, etc.) based on the command parameter.", "path": "/v1/savingsaccounts/{savingsId}/transactions/{transactionId}", "method": "POST", "requestBody": "JSON object containing adjustment details.", "responseBody": "JSON object containing the command processing result." }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Fixed Deposit Account Transactions API", "description": "API endpoints for managing fixed deposit account transactions.", "path": "/v1/fixeddepositaccounts/{fixedDepositAccountId}/transactions", "method": "GET, POST", "requestBody": "JSON payload for transaction details (deposit/withdrawal/adjust)", "responseBody": "JSON representation of the transaction or processing result", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/DepositAccountOnHoldFundTransactionsApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Endpoint to retrieve on-hold transactions for a savings account.", "path": "/v1/savingsaccounts/{savingsId}/onholdtransactions", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of Page", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Retrieve Fixed Deposit Account Template", "path": "/v1/fixeddepositaccounts/template", "method": "GET", "requestBody": "None", "responseBody": "JSON (DepositAccountData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "List Accounts", "description": "List Fixed deposit applications/accounts", "path": "/v1/fixeddepositaccounts", "method": "GET", "requestBody": "None", "responseBody": "JSON Array (DepositAccountData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Submit Application", "description": "Submit new fixed deposit application", "path": "/v1/fixeddepositaccounts", "method": "POST", "requestBody": "JSON (PostFixedDepositAccountsRequest)", "responseBody": "JSON (PostFixedDepositAccountsResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve One", "description": "Retrieve a fixed deposit application/account", "path": "/v1/fixeddepositaccounts/{accountId}", "method": "GET", "requestBody": "None", "responseBody": "JSON (FixedDepositAccountData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Update Application", "description": "Modify a fixed deposit application", "path": "/v1/fixeddepositaccounts/{accountId}", "method": "PUT", "requestBody": "JSON (PutFixedDepositAccountsAccountIdRequest)", "responseBody": "JSON (PutFixedDepositAccountsAccountIdResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Handle Commands", "description": "Approve, Reject, Activate, Close, Calculate Interest, etc.", "path": "/v1/fixeddepositaccounts/{accountId}", "method": "POST", "requestBody": "JSON (PostFixedDepositAccountsAccountIdRequest)", "responseBody": "JSON (PostFixedDepositAccountsAccountIdResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Delete Application", "description": "Delete a fixed deposit application", "path": "/v1/fixeddepositaccounts/{accountId}", "method": "DELETE", "requestBody": "None", "responseBody": "JSON (DeleteFixedDepositAccountsAccountIdResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Account Closure Template", "description": "Retrieve account closure template", "path": "/v1/fixeddepositaccounts/{accountId}/template", "method": "GET", "requestBody": "None", "responseBody": "JSON (DepositAccountData)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Download fixed deposit import template", "path": "/v1/fixeddepositaccounts/downloadtemplate", "method": "GET", "requestBody": "None", "responseBody": "application/vnd.ms-excel", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Upload fixed deposit import template", "path": "/v1/fixeddepositaccounts/uploadtemplate", "method": "POST", "requestBody": "Multipart/Form-Data", "responseBody": "JSON (ImportDocumentId)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Download Transaction Template", "description": "Download fixed deposit transaction import template", "path": "/v1/fixeddepositaccounts/transaction/downloadtemplate", "method": "GET", "requestBody": "None", "responseBody": "application/vnd.ms-excel", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java", "mechanism": "REST", "name": "Upload Transaction Template", "description": "Upload fixed deposit transaction import template", "path": "/v1/fixeddepositaccounts/transaction/uploadtemplate", "method": "POST", "requestBody": "Multipart/Form-Data", "responseBody": "JSON (ImportDocumentId)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "Create Fixed Deposit Product", "description": "Endpoint to create a new fixed deposit product definition.", "path": "/v1/fixeddepositproducts", "method": "POST", "requestBody": "JSON object matching FixedDepositProductData structure", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "Update Fixed Deposit Product", "description": "Endpoint to update an existing fixed deposit product.", "path": "/v1/fixeddepositproducts/{productId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "List Fixed Deposit Products", "description": "Endpoint to retrieve a list of all fixed deposit products.", "path": "/v1/fixeddepositproducts", "method": "GET", "responseBody": "JSON array of FixedDepositProductData" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Fixed Deposit Product", "description": "Endpoint to retrieve a single fixed deposit product by ID.", "path": "/v1/fixeddepositproducts/{productId}", "method": "GET", "responseBody": "JSON object of FixedDepositProductData" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve template data for creating a fixed deposit product.", "path": "/v1/fixeddepositproducts/template", "method": "GET", "responseBody": "JSON object with default values and dropdown options" }, { "namespace": "org.apache.fineract.portfolio.savings.api.FixedDepositProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositProductsApiResource.java", "mechanism": "REST", "name": "Delete Fixed Deposit Product", "description": "Endpoint to delete a fixed deposit product.", "path": "/v1/fixeddepositproducts/{productId}", "method": "DELETE", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountTransactionsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountTransactionsApiResource.java", "mechanism": "REST", "name": "Recurring Deposit Account Transactions API", "description": "API endpoints for managing transactions on recurring deposit accounts.", "path": "/v1/recurringdepositaccounts/{recurringDepositAccountId}/transactions", "method": "GET, POST", "requestBody": "JSON payload containing transaction details (amount, date, payment type, etc.)", "responseBody": "JSON representation of the transaction data or processing result", "authentication": "PlatformSecurityContext (implied OAuth/Basic Auth)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Retrieve recurring Deposit Account Template", "path": "/v1/recurringdepositaccounts/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "List Accounts", "description": "List Recurring deposit applications/accounts", "path": "/v1/recurringdepositaccounts", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Submit Application", "description": "Submit new recurring deposit application", "path": "/v1/recurringdepositaccounts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload with account details" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve One", "description": "Retrieve a recurring deposit application/account", "path": "/v1/recurringdepositaccounts/{accountId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Update Application", "description": "Modify a recurring deposit application", "path": "/v1/recurringdepositaccounts/{accountId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload with update details" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Handle Commands", "description": "Perform actions like approve, reject, activate, close, etc.", "path": "/v1/recurringdepositaccounts/{accountId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload (optional depending on command)" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Delete Application", "description": "Delete a recurring deposit application", "path": "/v1/recurringdepositaccounts/{accountId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Closure Template", "description": "Retrieve account closure template", "path": "/v1/recurringdepositaccounts/{accountId}/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Download Import Template", "description": "Download bulk import template for accounts", "path": "/v1/recurringdepositaccounts/downloadtemplate", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Upload Import Template", "description": "Upload bulk import template for accounts", "path": "/v1/recurringdepositaccounts/uploadtemplate", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart form data" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Download Transaction Template", "description": "Download bulk import template for transactions", "path": "/v1/recurringdepositaccounts/transactions/downloadtemplate", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.api.RecurringDepositAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/RecurringDepositAccountsApiResource.java", "mechanism": "REST", "name": "Upload Transaction Template", "description": "Upload bulk import template for transactions", "path": "/v1/recurringdepositaccounts/transactions/uploadtemplate", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart form data" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsAccountsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsAccountsApiResource.java", "mechanism": "REST", "name": "Savings Account API", "description": "Exposes RESTful endpoints for managing savings accounts.", "path": "/v1/savingsaccounts", "method": "GET, POST, PUT, DELETE", "direction": "PRODUCER", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "Create Savings Product", "description": "Endpoint to create a new savings product.", "path": "/v1/savingsproducts", "method": "POST", "requestBody": "JSON object representing the savings product (SavingsProductsApiResourceSwagger.PostSavingsProductsRequest)", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "Update Savings Product", "description": "Endpoint to update an existing savings product.", "path": "/v1/savingsproducts/{productId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "List Savings Products", "description": "Endpoint to retrieve all savings products.", "path": "/v1/savingsproducts", "method": "GET", "responseBody": "JSON array of savings product data" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Savings Product", "description": "Endpoint to retrieve a single savings product by ID.", "path": "/v1/savingsproducts/{productId}", "method": "GET", "responseBody": "JSON object of savings product data" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a template with defaults and options for creating a savings product.", "path": "/v1/savingsproducts/template", "method": "GET", "responseBody": "JSON object containing template data and dropdown options" }, { "namespace": "org.apache.fineract.portfolio.savings.api.SavingsProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/SavingsProductsApiResource.java", "mechanism": "REST", "name": "Delete Savings Product", "description": "Endpoint to delete a savings product.", "path": "/v1/savingsproducts/{productId}", "method": "DELETE", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/ApplyAnnualFeeSavingsAccountCommandHandler.java", "mechanism": "OTHER", "name": "SAVINGSACCOUNT | APPLYANNUALFEE", "description": "Registers as a command handler in the Fineract CQRS system via the @CommandType annotation.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/CalculateInterestRecurringDepositAccountCommandHandler.java", "mechanism": "OTHER", "name": "RECURRINGDEPOSITACCOUNT | CALCULATEINTEREST", "description": "Fineract Command Handler registration via @CommandType annotation. This integrates the class into the application's command processing pipeline.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/CalculateInterestFixedDepositAccountCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler: FIXEDDEPOSITACCOUNT - CALCULATEINTEREST", "description": "Registers a handler for the internal command dispatching system to process interest calculation requests for fixed deposit accounts.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/UndoTransactionFixedDepositAccountCommandHandler.java", "mechanism": "OTHER", "name": "FIXEDDEPOSITACCOUNT UNDOTRANSACTION", "description": "Registers a command handler for the 'UNDOTRANSACTION' action on 'FIXEDDEPOSITACCOUNT' entities within the Fineract command processing framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/RecurringDepositAccountUpdateDepositAmountCommandHandler.java", "mechanism": "OTHER", "name": "RECURRINGDEPOSITACCOUNT.UPDATEDEPOSITAMOUNT", "description": "Internal Command Handler integration point for Fineract's CQRS command processing pipeline.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/SavingsAccountApplicationDeletionCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler Registration", "description": "Registers as a handler for SAVINGSACCOUNT DELETE commands via the @CommandType annotation, integrating with the application's internal command processing bus.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/CloseRecurringDepositAccountCommandHandler.java", "mechanism": "OTHER", "name": "RECURRINGDEPOSITACCOUNT CLOSE", "description": "Fineract Command Handler for closing recurring deposit accounts", "path": "n/a", "method": "CLOSE", "direction": "CONSUMER", "requestBody": "JsonCommand", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/CloseFixedDepositAccountCommandHandler.java", "mechanism": "OTHER", "name": "CommandType Annotation", "description": "Registers this class as a handler for internal command processing within the Fineract framework.", "path": "Entity: FIXEDDEPOSITACCOUNT, Action: CLOSE", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/UnblockDebitsFromSavingsAccountCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler Registration", "description": "Registers as a handler for SAVINGSACCOUNT entity and UNBLOCKDEBIT action via the Fineract Command framework.", "direction": "CONSUMER", "requestBody": "JsonCommand containing savingsId", "responseBody": "CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/CalculateInterestSavingsAccountCommandHandler.java", "mechanism": "OTHER", "name": "SAVINGSACCOUNT CALCULATEINTEREST", "description": "Internal Command Handler registered via @CommandType to process 'CALCULATEINTEREST' actions for 'SAVINGSACCOUNT' entities.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/ActivateSavingsAccountCommandHandler.java", "mechanism": "OTHER", "name": "SAVINGSACCOUNT-ACTIVATE", "description": "Fineract Command Handler for activating savings accounts, mapped via @CommandType annotation.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/BlockSavingsAccountCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler (SAVINGSACCOUNT | BLOCK)", "description": "Registers a handler for the internal command processing engine for the entity 'SAVINGSACCOUNT' and action 'BLOCK'.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/AddSavingsAccountChargeCommandHandler.java", "mechanism": "OTHER", "name": "SAVINGSACCOUNTCHARGE CREATE Command", "description": "Internal Fineract Command Handler for creating savings account charges", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/DeleteSavingsProductCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler Registration", "description": "Registers this class as a handler for the internal command processing bus via the @CommandType annotation.", "path": "SAVINGSPRODUCT/DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler.FixedDepositAccountApplicationDeletionCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/FixedDepositAccountApplicationDeletionCommandHandler.java", "mechanism": "OTHER", "name": "Fixed Deposit Account Application Deletion Command", "description": "This class acts as a handler for an internal command within the Apache Fineract framework, following a CQRS pattern. It is registered via the @CommandType annotation to listen for 'DELETE' commands on the 'FIXEDDEPOSITACCOUNT' entity. When such a command is dispatched by the internal command bus, this handler's processCommand method is invoked to execute the deletion logic.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler.FixedDepositTransactionAdjustmentCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/FixedDepositTransactionAdjustmentCommandHandler.java", "mechanism": "OTHER", "name": "FIXEDDEPOSITACCOUNT.ADJUSTTRANSACTION", "description": "This handler is registered to process internal commands for adjusting a transaction on a fixed deposit account. It is invoked by the application's command bus/dispatcher when a command with entity 'FIXEDDEPOSITACCOUNT' and action 'ADJUSTTRANSACTION' is submitted. The command is typically triggered by an API call, but this class is one step removed from the direct API endpoint.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.handler.GSIMDepositCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/handler/GSIMDepositCommandHandler.java", "mechanism": "OTHER", "name": "GSIMACCOUNT DEPOSIT Command Handler", "description": "Registers a handler for the internal command bus for Entity 'GSIMACCOUNT' and Action 'DEPOSIT' via the @CommandType annotation.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.savings.jobs.applyannualfeeforsavings", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/jobs/applyannualfeeforsavings/ApplyAnnualFeeForSavingsConfig.java", "mechanism": "OTHER", "name": "APPLY_ANNUAL_FEE_FOR_SAVINGS", "description": "Spring Batch Job definition used by the application scheduler to apply annual fees.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.portfolio.savings.jobs.payduesavingscharges", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/jobs/payduesavingscharges/PayDueSavingsChargesConfig.java", "mechanism": "OTHER", "name": "PAY_DUE_SAVINGS_CHARGES", "description": "Spring Batch Job definition for processing due savings charges", "direction": "OTHER" }, { "namespace": "org.apache.fineract.portfolio.savings.jobs.transferinteresttosavings", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/jobs/transferinteresttosavings/TransferInterestToSavingsConfig.java", "mechanism": "OTHER", "name": "TRANSFER_INTEREST_TO_SAVINGS", "description": "Defines a Spring Batch Job for transferring interest to savings, which is likely triggered by an internal scheduler.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.portfolio.savings.jobs.updatesavingsdormantaccounts.UpdateSavingsDormantAccountsTasklet", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/jobs/updatesavingsdormantaccounts/UpdateSavingsDormantAccountsTasklet.java", "mechanism": "OTHER", "name": "UpdateSavingsDormantAccountsTasklet", "description": "Spring Batch Tasklet execution logic for updating savings account statuses." }, { "namespace": "org.apache.fineract.portfolio.savings.service.SavingsAccountWritePlatformServiceJpaRepositoryImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/service/SavingsAccountWritePlatformServiceJpaRepositoryImpl.java", "mechanism": "OTHER", "name": "BusinessEventNotifierService", "description": "Internal event bus to notify other parts of the system about business events.", "messageType": "SavingsActivateBusinessEvent, SavingsCloseBusinessEvent, SavingsPostInterestBusinessEvent", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.search.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/search/api/SearchApiResource.java", "mechanism": "REST", "name": "retrieveAdHocSearchQueryTemplate", "description": "Retrieves the ad-hoc search query template.", "path": "/v1/search/template", "method": "GET", "requestBody": "None", "responseBody": "JSON object representing the ad-hoc search template", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.search.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/search/api/SearchApiResource.java", "mechanism": "REST", "name": "searchData", "description": "Searches for resources (clients, groups, loans) based on query parameters.", "path": "/v1/search", "method": "GET", "requestBody": "None", "responseBody": "JSON array of search results", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.search.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/search/api/SearchApiResource.java", "mechanism": "REST", "name": "advancedSearch", "description": "Performs an advanced ad-hoc search using a JSON request body.", "path": "/v1/search/advance", "method": "POST", "requestBody": "JSON object containing ad-hoc query search conditions", "responseBody": "JSON array of ad-hoc search results", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfBeneficiariesTPTApiResource.java", "mechanism": "REST", "name": "Get Template", "description": "Retrieves template data for creating a beneficiary.", "path": "/v1/self/beneficiaries/tpt/template", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON object containing account type options" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfBeneficiariesTPTApiResource.java", "mechanism": "REST", "name": "Add Beneficiary", "description": "Adds a new third-party beneficiary.", "path": "/v1/self/beneficiaries/tpt", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON object with name, officeName, accountNumber, transferLimit", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfBeneficiariesTPTApiResource.java", "mechanism": "REST", "name": "Update Beneficiary", "description": "Updates an existing beneficiary.", "path": "/v1/self/beneficiaries/tpt/{beneficiaryId}", "method": "PUT", "direction": "PRODUCER", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfBeneficiariesTPTApiResource.java", "mechanism": "REST", "name": "Delete Beneficiary", "description": "Deletes a beneficiary.", "path": "/v1/self/beneficiaries/tpt/{beneficiaryId}", "method": "DELETE", "direction": "PRODUCER", "responseBody": "JSON object with command processing result" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfBeneficiariesTPTApiResource.java", "mechanism": "REST", "name": "Retrieve All", "description": "Retrieves all beneficiaries for the user.", "path": "/v1/self/beneficiaries/tpt", "method": "GET", "direction": "PRODUCER", "responseBody": "JSON array of beneficiary data" }, { "namespace": "org.apache.fineract.portfolio.self.account.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/account/api/SelfAccountTransferApiResource.java", "mechanism": "REST", "name": "Self Account transfer", "description": "API endpoints for self-service account transfers", "path": "/v1/self/accounttransfers", "method": "GET, POST", "direction": "BIDIRECTIONAL", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "List Clients associated to the user", "path": "/v1/self/clients", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveOne", "description": "Retrieve a Client", "path": "/v1/self/clients/{clientId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveAssociatedAccounts", "description": "Retrieve client accounts overview", "path": "/v1/self/clients/{clientId}/accounts", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveImage", "description": "Retrieve Client Image", "path": "/v1/self/clients/{clientId}/images", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveAllClientCharges", "description": "List Client Charges", "path": "/v1/self/clients/{clientId}/charges", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveClientCharge", "description": "Retrieve a Client Charge", "path": "/v1/self/clients/{clientId}/charges/{chargeId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveAllClientTransactions", "description": "List Client Transactions", "path": "/v1/self/clients/{clientId}/transactions", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveClientTransaction", "description": "Retrieve a Client Transaction", "path": "/v1/self/clients/{clientId}/transactions/{transactionId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "addNewClientImage", "description": "Add new client image (Multipart)", "path": "/v1/self/clients/{clientId}/images", "method": "POST", "direction": "CONSUMER", "requestBody": "Multipart Form Data" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "addNewClientImage", "description": "Add new client image (JSON/Text)", "path": "/v1/self/clients/{clientId}/images", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON or Text" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "deleteClientImage", "description": "Delete Client Image", "path": "/v1/self/clients/{clientId}/images", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.api.SelfClientsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/api/SelfClientsApiResource.java", "mechanism": "REST", "name": "retrieveObligeeDetails", "description": "Retrieve Obligee Details", "path": "/v1/self/clients/{clientId}/obligeedetails", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.client.data.SelfClientDataValidator", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/client/data/SelfClientDataValidator.java", "mechanism": "REST", "name": "REST Request Validation", "description": "Consumes JAX-RS UriInfo to validate incoming HTTP query parameters for client data operations.", "path": "n/a", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResourceSwagger.java", "mechanism": "REST", "name": "Self Loans API Schemas", "description": "Defines the JSON schemas (Requests and Responses) for the Self Service Loans REST API. While this file does not contain the JAX-RS annotations, it defines the contract for endpoints such as retrieving loan details, creating loans, and updating loan status.", "path": "/self/loans (implied by schema names)", "method": "GET, POST, PUT", "direction": "BOTH" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan", "description": "Endpoint to retrieve a single loan by ID.", "path": "/v1/self/loans/{loanId}", "method": "GET", "responseBody": "JSON representation of the Loan" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Transaction", "description": "Endpoint to retrieve a specific transaction for a loan.", "path": "/v1/self/loans/{loanId}/transactions/{transactionId}", "method": "GET", "responseBody": "JSON representation of the Transaction" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "List Loan Charges", "description": "Endpoint to list all charges for a loan.", "path": "/v1/self/loans/{loanId}/charges", "method": "GET", "responseBody": "JSON array of Loan Charges" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Charge", "description": "Endpoint to retrieve a specific charge for a loan.", "path": "/v1/self/loans/{loanId}/charges/{chargeId}", "method": "GET", "responseBody": "JSON representation of the Loan Charge" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Loan Template", "description": "Endpoint to retrieve loan template data for UI construction.", "path": "/v1/self/loans/template", "method": "GET", "responseBody": "JSON representation of the Loan Template" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Calculate Schedule or Submit Application", "description": "Endpoint to calculate repayment schedule or submit a new loan application.", "path": "/v1/self/loans", "method": "POST", "requestBody": "JSON payload for loan application", "responseBody": "JSON response with schedule or loan details" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Modify Loan Application", "description": "Endpoint to modify a pending loan application.", "path": "/v1/self/loans/{loanId}", "method": "PUT", "requestBody": "JSON payload for modification", "responseBody": "JSON response of modified loan" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "State Transitions", "description": "Endpoint for loan state transitions (e.g., withdrawal).", "path": "/v1/self/loans/{loanId}", "method": "POST", "requestBody": "JSON payload for transition", "responseBody": "JSON response of transition result" }, { "namespace": "org.apache.fineract.portfolio.self.loanaccount.api.SelfLoansApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/loanaccount/api/SelfLoansApiResource.java", "mechanism": "REST", "name": "Retrieve Guarantors", "description": "Endpoint to retrieve guarantors for a loan.", "path": "/v1/self/loans/{loanId}/guarantors", "method": "GET", "responseBody": "JSON representation of Guarantors" }, { "namespace": "org.apache.fineract.portfolio.self.pockets.api.PocketApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/pockets/api/PocketApiResource.java", "mechanism": "REST", "name": "Link/Delink Accounts", "description": "Endpoint to link or delink accounts to/from a pocket.", "path": "/v1/self/pockets", "method": "POST", "requestBody": "JSON payload containing account details to link/delink", "responseBody": "JSON result of the command processing", "authentication": "Unknown (likely handled by filter/interceptor)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.pockets.api.PocketApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/pockets/api/PocketApiResource.java", "mechanism": "REST", "name": "Retrieve Linked Accounts", "description": "Endpoint to retrieve all accounts linked to the pocket.", "path": "/v1/self/pockets", "method": "GET", "requestBody": "None", "responseBody": "JSON array of linked accounts", "authentication": "Unknown (likely handled by filter/interceptor)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.pockets.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/pockets/handler/DelinkAccountsFromPocketCommandHandler.java", "mechanism": "OTHER", "name": "Fineract Command Bus", "description": "Registers as a handler for the 'DELINKACCOUNTS' action on the 'POCKET' entity via the @CommandType annotation.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.products.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfLoanProductsApiResource.java", "mechanism": "REST", "name": "retrieveAllLoanProducts", "description": "Endpoint to retrieve all loan products for self-service.", "path": "/v1/self/loanproducts", "method": "GET", "requestBody": "None", "responseBody": "JSON array of loan products", "authentication": "Implicit (likely Basic Auth or OAuth handled by container/filter)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.products.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfLoanProductsApiResource.java", "mechanism": "REST", "name": "retrieveLoanProductDetails", "description": "Endpoint to retrieve details of a specific loan product.", "path": "/v1/self/loanproducts/{productId}", "method": "GET", "requestBody": "None", "responseBody": "JSON object of loan product details", "authentication": "Implicit", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.products.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfSavingsProductsApiResource.java", "mechanism": "REST", "name": "retrieveAll", "description": "Endpoint to retrieve all savings products for a self-service client.", "path": "/v1/self/savingsproducts", "method": "GET", "requestBody": "None", "responseBody": "JSON array of savings products", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.products.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfSavingsProductsApiResource.java", "mechanism": "REST", "name": "retrieveOne", "description": "Endpoint to retrieve a single savings product by ID.", "path": "/v1/self/savingsproducts/{productId}", "method": "GET", "requestBody": "None", "responseBody": "JSON object of savings product details", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.products.api.SelfShareProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfShareProductsApiResource.java", "mechanism": "REST", "name": "retrieveProduct", "description": "Endpoint to retrieve a single share product by ID.", "path": "/v1/self/products/share/{productId}", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of the share product", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.products.api.SelfShareProductsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/products/api/SelfShareProductsApiResource.java", "mechanism": "REST", "name": "retrieveAllProducts", "description": "Endpoint to retrieve all share products.", "path": "/v1/self/products/share", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of a list of share products", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.registration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/registration/api/SelfServiceRegistrationApiResource.java", "mechanism": "REST", "name": "createSelfServiceRegistrationRequest", "description": "Endpoint for submitting a self-service registration request.", "path": "/v1/self/registration", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON string containing registration details", "responseBody": "Success message string" }, { "namespace": "org.apache.fineract.portfolio.self.registration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/registration/api/SelfServiceRegistrationApiResource.java", "mechanism": "REST", "name": "createSelfServiceUser", "description": "Endpoint for creating a self-service user.", "path": "/v1/self/registration/user", "method": "POST", "direction": "BIDIRECTIONAL", "requestBody": "JSON string containing user details", "responseBody": "JSON object containing the created user's ID" }, { "namespace": "org.apache.fineract.portfolio.self.registration.service.SelfServiceRegistrationWritePlatformServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/registration/service/SelfServiceRegistrationWritePlatformServiceImpl.java", "mechanism": "OTHER", "name": "GmailBackedPlatformEmailService", "description": "Sends authorization emails to users via an internal email service wrapper.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.self.registration.service.SelfServiceRegistrationWritePlatformServiceImpl", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/registration/service/SelfServiceRegistrationWritePlatformServiceImpl.java", "mechanism": "OTHER", "name": "SmsMessageScheduledJobService", "description": "Queues and triggers SMS messages for delivery via an internal job service.", "direction": "PRODUCER" }, { "namespace": "org.apache.fineract.portfolio.self.runreport.SelfRunReportApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/runreport/SelfRunReportApiResource.java", "mechanism": "REST", "name": "runReport", "description": "Endpoint to run a report for self-service users.", "path": "/v1/self/runreports/{reportName}", "method": "GET", "requestBody": "None (Query parameters via UriInfo)", "responseBody": "JSON, CSV, PDF, HTML, or Excel depending on negotiation", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Retrieve Savings Account", "description": "Endpoint to retrieve a single savings account for the authenticated user.", "path": "/v1/self/savingsaccounts/{accountId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Retrieve Savings Transaction", "description": "Endpoint to retrieve a specific transaction for a savings account.", "path": "/v1/self/savingsaccounts/{accountId}/transactions/{transactionId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "List Savings Charges", "description": "Endpoint to list charges for a savings account.", "path": "/v1/self/savingsaccounts/{accountId}/charges", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Retrieve Savings Charge", "description": "Endpoint to retrieve a specific charge for a savings account.", "path": "/v1/self/savingsaccounts/{accountId}/charges/{savingsAccountChargeId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a savings account application template.", "path": "/v1/self/savingsaccounts/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Submit Application", "description": "Endpoint to submit a new savings account application.", "path": "/v1/self/savingsaccounts", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload containing application details" }, { "namespace": "org.apache.fineract.portfolio.self.savings.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/savings/api/SelfSavingsApiResource.java", "mechanism": "REST", "name": "Modify Application", "description": "Endpoint to modify an existing savings account application.", "path": "/v1/self/savingsaccounts/{accountId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload containing modification details" }, { "namespace": "org.apache.fineract.portfolio.self.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/security/api/SelfUserApiResource.java", "mechanism": "REST", "name": "Update User", "description": "API endpoint for self-service users to update their own profile information.", "path": "/v1/self/user", "method": "PUT", "requestBody": "JSON object containing 'password' and 'repeatPassword'.", "responseBody": "JSON response confirming the update.", "authentication": "Implicitly required via PlatformSecurityContext usage." }, { "namespace": "org.apache.fineract.portfolio.self.security.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/security/api/SelfAuthenticationApiResource.java", "mechanism": "REST", "name": "Self Authentication", "description": "Endpoint for self-service user authentication.", "path": "/v1/self/authentication", "method": "POST", "direction": "PRODUCER", "requestBody": "JSON structure defined by AuthenticationApiResourceSwagger.PostAuthenticationRequest", "responseBody": "JSON structure defined by SelfAuthenticationApiResourceSwagger.PostSelfAuthenticationResponse", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.security.api.SelfUserDetailsApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/security/api/SelfUserDetailsApiResource.java", "mechanism": "REST", "name": "Fetch Authenticated User Details", "description": "Endpoint to retrieve the authenticated user's details, roles, and permissions.", "path": "/v1/self/userdetails", "method": "GET", "responseBody": "JSON representation of user details (SelfUserDetailsApiResourceSwagger.GetSelfUserDetailsResponse)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.shareaccounts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/shareaccounts/api/SelfShareAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve Share Account Template", "description": "Endpoint to retrieve data required to create a share account application.", "path": "/v1/self/shareaccounts/template", "method": "GET", "requestBody": "None", "responseBody": "JSON object containing ShareAccountData (products, charges, client info)", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.shareaccounts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/shareaccounts/api/SelfShareAccountsApiResource.java", "mechanism": "REST", "name": "Submit new share application", "description": "Endpoint to submit a new share account application.", "path": "/v1/self/shareaccounts", "method": "POST", "requestBody": "JSON object with share application details (clientId, productId, etc.)", "responseBody": "JSON object with creation result", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.shareaccounts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/shareaccounts/api/SelfShareAccountsApiResource.java", "mechanism": "REST", "name": "Retrieve a share application/account", "description": "Endpoint to retrieve details of a specific share account.", "path": "/v1/self/shareaccounts/{accountId}", "method": "GET", "requestBody": "None", "responseBody": "JSON object containing AccountData", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.spm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/spm/api/SelfScorecardApiResource.java", "mechanism": "REST", "name": "findByClient", "description": "Endpoint to retrieve scorecards for a specific client.", "path": "/v1/self/surveys/scorecards/clients/{clientId}", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.spm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/spm/api/SelfScorecardApiResource.java", "mechanism": "REST", "name": "createScorecard", "description": "Endpoint to create a new scorecard for a survey.", "path": "/v1/self/surveys/scorecards/{surveyId}", "method": "POST", "requestBody": "ScorecardData (JSON)", "responseBody": "None", "authentication": "PlatformSecurityContext (implied)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.self.spm.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/self/spm/api/SelfSpmApiResource.java", "mechanism": "REST", "name": "fetchAllSurveys", "description": "Endpoint to retrieve active surveys for self-service users.", "path": "/v1/self/surveys", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (Implicit)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.shareaccounts.handler.RejectShareAccountCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareaccounts/handler/RejectShareAccountCommandHandler.java", "mechanism": "OTHER", "name": "SHAREACCOUNT REJECT Command", "description": "Registers as a handler for the SHAREACCOUNT entity and REJECT action within the Fineract command processing framework via @CommandType.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/api/ShareDividendApiResource.java", "mechanism": "REST", "name": "Retrieve All Dividends", "description": "Retrieves a list of dividends for a share product.", "path": "/v1/shareproduct/{productId}/dividend", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/api/ShareDividendApiResource.java", "mechanism": "REST", "name": "Retrieve Dividend Details", "description": "Retrieves details of a specific dividend.", "path": "/v1/shareproduct/{productId}/dividend/{dividendId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/api/ShareDividendApiResource.java", "mechanism": "REST", "name": "Create Dividend", "description": "Creates a new dividend payout.", "path": "/v1/shareproduct/{productId}/dividend", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON payload defining the dividend payout" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/api/ShareDividendApiResource.java", "mechanism": "REST", "name": "Update Dividend", "description": "Updates (approves) a dividend payout.", "path": "/v1/shareproduct/{productId}/dividend/{dividendId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON payload for the update" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/api/ShareDividendApiResource.java", "mechanism": "REST", "name": "Delete Dividend", "description": "Deletes a dividend payout.", "path": "/v1/shareproduct/{productId}/dividend/{dividendId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.shareproducts.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/shareproducts/handler/DeleteShareProductDividendCommandHandler.java", "mechanism": "OTHER", "name": "Command Handler", "description": "Registers as a handler for the Fineract Command Processing infrastructure.", "path": "SHAREPRODUCT / DELETE_DIVIDEND", "method": "n/a", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxGroupApiResource.java", "mechanism": "REST", "name": "List Tax Groups", "description": "Retrieves a list of all tax groups.", "path": "/v1/taxes/group", "method": "GET", "responseBody": "JSON array of TaxGroupData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxGroupApiResource.java", "mechanism": "REST", "name": "Retrieve Tax Group", "description": "Retrieves a specific tax group by ID.", "path": "/v1/taxes/group/{taxGroupId}", "method": "GET", "responseBody": "JSON object of TaxGroupData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxGroupApiResource.java", "mechanism": "REST", "name": "Retrieve Tax Group Template", "description": "Retrieves a template for creating a tax group.", "path": "/v1/taxes/group/template", "method": "GET", "responseBody": "JSON object of TaxGroupData (Template)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxGroupApiResource.java", "mechanism": "REST", "name": "Create Tax Group", "description": "Creates a new tax group.", "path": "/v1/taxes/group", "method": "POST", "requestBody": "JSON object defining the tax group", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxGroupApiResource.java", "mechanism": "REST", "name": "Update Tax Group", "description": "Updates an existing tax group.", "path": "/v1/taxes/group/{taxGroupId}", "method": "PUT", "requestBody": "JSON object with fields to update", "responseBody": "JSON object with command processing result", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.portfolio.tax.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResourceSwagger.java", "mechanism": "REST", "name": "Tax Component API Schemas", "description": "Defines the request and response body schemas for Tax Component REST API operations, used by Swagger to generate API documentation.", "direction": "BOTH" }, { "namespace": "org.apache.fineract.portfolio.tax.api.TaxComponentApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResource.java", "mechanism": "REST", "name": "List Tax Components", "description": "Endpoint to retrieve all tax components.", "path": "/v1/taxes/component", "method": "GET", "responseBody": "JSON array of TaxComponentData" }, { "namespace": "org.apache.fineract.portfolio.tax.api.TaxComponentApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResource.java", "mechanism": "REST", "name": "Retrieve Tax Component", "description": "Endpoint to retrieve a single tax component by ID.", "path": "/v1/taxes/component/{taxComponentId}", "method": "GET", "responseBody": "JSON object of TaxComponentData" }, { "namespace": "org.apache.fineract.portfolio.tax.api.TaxComponentApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResource.java", "mechanism": "REST", "name": "Retrieve Template", "description": "Endpoint to retrieve a tax component template.", "path": "/v1/taxes/component/template", "method": "GET", "responseBody": "JSON object of TaxComponentData" }, { "namespace": "org.apache.fineract.portfolio.tax.api.TaxComponentApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResource.java", "mechanism": "REST", "name": "Create Tax Component", "description": "Endpoint to create a new tax component.", "path": "/v1/taxes/component", "method": "POST", "requestBody": "JSON object defining the tax component", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.tax.api.TaxComponentApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/tax/api/TaxComponentApiResource.java", "mechanism": "REST", "name": "Update Tax Component", "description": "Endpoint to update an existing tax component.", "path": "/v1/taxes/component/{taxComponentId}", "method": "PUT", "requestBody": "JSON object with updated fields", "responseBody": "JSON object of CommandProcessingResult" }, { "namespace": "org.apache.fineract.portfolio.transfer.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/transfer/handler/ProposeAndAcceptClientTransferCommandHandler.java", "mechanism": "OTHER", "name": "CommandType: CLIENT - PROPOSEANDACCEPTTRANSFER", "description": "Registers a handler for the PROPOSEANDACCEPTTRANSFER action on the CLIENT entity within the Fineract command framework.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.portfolio.transfer.handler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/transfer/handler/RejectClientTransferCommandHandler.java", "mechanism": "OTHER", "name": "REJECTTRANSFER", "description": "Fineract Command Handler for the 'REJECTTRANSFER' action on the 'CLIENT' entity. This is part of the internal command processing pipeline, likely triggered via a generic REST command endpoint.", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.spm.api.LookupTableApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/LookupTableApiResource.java", "mechanism": "REST", "name": "fetchLookupTables", "description": "List all Lookup Table entries for a survey", "path": "/v1/surveys/{surveyId}/lookuptables", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.LookupTableApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/LookupTableApiResource.java", "mechanism": "REST", "name": "findLookupTable", "description": "Retrieve a Lookup Table entry by key", "path": "/v1/surveys/{surveyId}/lookuptables/{key}", "method": "GET", "requestBody": "None", "responseBody": "LookupTableData (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.LookupTableApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/LookupTableApiResource.java", "mechanism": "REST", "name": "createLookupTable", "description": "Create a Lookup Table entry", "path": "/v1/surveys/{surveyId}/lookuptables", "method": "POST", "requestBody": "LookupTableData (JSON)", "responseBody": "None", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.ScorecardApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/ScorecardApiResource.java", "mechanism": "REST", "name": "List Scorecards by Survey", "description": "Endpoint to retrieve all scorecards for a given survey ID.", "path": "/v1/surveys/scorecards/{surveyId}", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.ScorecardApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/ScorecardApiResource.java", "mechanism": "REST", "name": "Create Scorecard", "description": "Endpoint to create a new scorecard entry.", "path": "/v1/surveys/scorecards/{surveyId}", "method": "POST", "requestBody": "ScorecardData (JSON)", "responseBody": "None (200 OK)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.ScorecardApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/ScorecardApiResource.java", "mechanism": "REST", "name": "List Scorecards by Survey and Client", "description": "Endpoint to retrieve scorecards for a specific survey and client.", "path": "/v1/surveys/scorecards/{surveyId}/clients/{clientId}", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.ScorecardApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/ScorecardApiResource.java", "mechanism": "REST", "name": "List Scorecards by Client", "description": "Endpoint to retrieve all scorecards for a specific client.", "path": "/v1/surveys/scorecards/clients/{clientId}", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.spm.api.SpmApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/SpmApiResource.java", "mechanism": "REST", "name": "List all Surveys", "description": "Endpoint to retrieve a list of surveys, optionally filtering for active ones.", "path": "/v1/surveys", "method": "GET", "requestBody": "None", "responseBody": "List (JSON)", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.spm.api.SpmApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/SpmApiResource.java", "mechanism": "REST", "name": "Retrieve a Survey", "description": "Endpoint to retrieve a specific survey by ID.", "path": "/v1/surveys/{id}", "method": "GET", "requestBody": "None", "responseBody": "SurveyData (JSON)", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.spm.api.SpmApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/SpmApiResource.java", "mechanism": "REST", "name": "Create a Survey", "description": "Endpoint to create a new survey.", "path": "/v1/surveys", "method": "POST", "requestBody": "SurveyData (JSON)", "responseBody": "{\"resourceId\": } (JSON)", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.spm.api.SpmApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/SpmApiResource.java", "mechanism": "REST", "name": "Edit Survey", "description": "Endpoint to update an existing survey.", "path": "/v1/surveys/{id}", "method": "PUT", "requestBody": "SurveyData (JSON)", "responseBody": "{\"resourceId\": } (JSON)", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.spm.api.SpmApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/spm/api/SpmApiResource.java", "mechanism": "REST", "name": "Activate/Deactivate Survey", "description": "Endpoint to change the status of a survey via a command query parameter.", "path": "/v1/surveys/{id}", "method": "POST", "requestBody": "None", "responseBody": "None", "authentication": "PlatformSecurityContext" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Retrieve All Templates", "description": "Get a list of all templates or filter by type and entity.", "path": "/v1/templates", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Retrieve Template Details", "description": "Get template metadata/structure.", "path": "/v1/templates/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Create Template", "description": "Create a new template.", "path": "/v1/templates", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON representation of the template" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Retrieve One Template", "description": "Get a specific template by ID.", "path": "/v1/templates/{templateId}", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Get Template By Template", "description": "Get template data for a specific ID.", "path": "/v1/templates/{templateId}/template", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Update Template", "description": "Update an existing template.", "path": "/v1/templates/{templateId}", "method": "PUT", "direction": "CONSUMER", "requestBody": "JSON representation of the template updates" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Delete Template", "description": "Delete a template.", "path": "/v1/templates/{templateId}", "method": "DELETE", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.template.api.TemplatesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/api/TemplatesApiResource.java", "mechanism": "REST", "name": "Merge Template", "description": "Merge a template with data to produce a document.", "path": "/v1/templates/{templateId}", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON data map for merging", "responseBody": "HTML or text content" }, { "namespace": "org.apache.fineract.template.handler.UpdateTemplateCommandHandler", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/handler/UpdateTemplateCommandHandler.java", "mechanism": "OTHER", "name": "TEMPLATE UPDATE Command Handler", "description": "Registers as a handler for UPDATE actions on TEMPLATE entities via the Fineract Command processing infrastructure.", "direction": "CONSUMER", "protocol": "Internal Java Interface / Spring Bean", "connectionInfo": "Annotation: @CommandType(entity = \"TEMPLATE\", action = \"UPDATE\")" }, { "namespace": "org.apache.fineract.template.service", "filepath": "fineract-provider/src/main/java/org/apache/fineract/template/service/TemplateMergeService.java", "mechanism": "REST", "name": "Template Data Mappers", "description": "Fetches JSON data from dynamic URLs defined in the template configuration to populate the template context.", "path": "Dynamic (defined in template mappers)", "method": "GET", "direction": "CONSUMER", "authentication": "Basic Auth (using application token or SecurityContext credentials)", "protocol": "HTTP/1.1", "connectionInfo": "Dynamic URLs resolved at runtime" }, { "namespace": "org.apache.fineract.twofactortests.TwoFactorAuthenticationTest", "filepath": "twofactor-tests/src/test/java/org/apache/fineract/twofactortests/TwoFactorAuthenticationTest.java", "mechanism": "REST", "name": "Authentication API", "description": "Endpoint for user login and authentication.", "path": "/fineract-provider/api/v1/authentication", "method": "POST", "direction": "CONSUMER", "requestBody": "JSON with username and password", "responseBody": "JSON with authentication key and 2FA status" }, { "namespace": "org.apache.fineract.twofactortests.TwoFactorAuthenticationTest", "filepath": "twofactor-tests/src/test/java/org/apache/fineract/twofactortests/TwoFactorAuthenticationTest.java", "mechanism": "REST", "name": "Two-Factor API", "description": "Endpoints for managing 2FA: requesting tokens, validating tokens, and configuration.", "path": "/fineract-provider/api/v1/twofactor", "method": "GET, POST, PUT", "direction": "CONSUMER", "requestBody": "JSON for validation or configuration", "responseBody": "JSON with tokens or configuration details" }, { "namespace": "org.apache.fineract.twofactortests.TwoFactorAuthenticationTest", "filepath": "twofactor-tests/src/test/java/org/apache/fineract/twofactortests/TwoFactorAuthenticationTest.java", "mechanism": "REST", "name": "Actuator Health", "description": "Spring Boot Actuator health check endpoint.", "path": "/fineract-provider/actuator/health", "method": "GET", "direction": "CONSUMER" }, { "namespace": "org.apache.fineract.twofactortests.TwoFactorAuthenticationTest", "filepath": "twofactor-tests/src/test/java/org/apache/fineract/twofactortests/TwoFactorAuthenticationTest.java", "mechanism": "OTHER", "name": "SMTP Mock", "description": "Interacts with a mocked SMTP server (GreenMail) to intercept emails sent by the application.", "direction": "CONSUMER", "protocol": "SMTP" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Retrieve All Users", "description": "Endpoint to retrieve a list of all users.", "path": "/v1/users", "method": "GET", "responseBody": "Array of AppUserData JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Retrieve One User", "description": "Endpoint to retrieve a single user by ID.", "path": "/v1/users/{userId}", "method": "GET", "responseBody": "AppUserData JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Retrieve User Template", "description": "Endpoint to retrieve a user creation template.", "path": "/v1/users/template", "method": "GET", "responseBody": "AppUserData JSON (Template)" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Create User", "description": "Endpoint to create a new user.", "path": "/v1/users", "method": "POST", "requestBody": "User creation JSON", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Update User", "description": "Endpoint to update an existing user.", "path": "/v1/users/{userId}", "method": "PUT", "requestBody": "User update JSON", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Delete User", "description": "Endpoint to delete a user.", "path": "/v1/users/{userId}", "method": "DELETE", "responseBody": "CommandProcessingResult JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Download Template", "description": "Endpoint to download Excel template for bulk import.", "path": "/v1/users/downloadtemplate", "method": "GET", "responseBody": "application/vnd.ms-excel" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/UsersApiResource.java", "mechanism": "REST", "name": "Upload Template", "description": "Endpoint to upload Excel template for bulk import.", "path": "/v1/users/uploadtemplate", "method": "POST", "requestBody": "multipart/form-data", "responseBody": "Import Document ID JSON" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/PermissionsApiResource.java", "mechanism": "REST", "name": "Permissions API", "description": "API endpoint for managing application permissions.", "path": "/v1/permissions", "method": "GET", "responseBody": "JSON array of PermissionData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/PermissionsApiResource.java", "mechanism": "REST", "name": "Update Permissions API", "description": "API endpoint for updating permission settings (Maker-Checker).", "path": "/v1/permissions", "method": "PUT", "requestBody": "JSON object defining permission updates", "responseBody": "CommandProcessingResult JSON", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/PasswordPreferencesApiResource.java", "mechanism": "REST", "name": "Retrieve Password Preferences", "description": "Endpoint to retrieve the active password validation policy.", "path": "/v1/passwordpreferences", "method": "GET", "requestBody": "None", "responseBody": "JSON representation of PasswordValidationPolicyData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/PasswordPreferencesApiResource.java", "mechanism": "REST", "name": "Update Password Preferences", "description": "Endpoint to update the password validation policy.", "path": "/v1/passwordpreferences", "method": "PUT", "requestBody": "JSON payload for PutPasswordPreferencesTemplateRequest", "responseBody": "JSON representation of CommandProcessingResult", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/PasswordPreferencesApiResource.java", "mechanism": "REST", "name": "Retrieve Password Preferences Template", "description": "Endpoint to list all available password validation policies.", "path": "/v1/passwordpreferences/template", "method": "GET", "requestBody": "None", "responseBody": "JSON array of PasswordValidationPolicyData", "authentication": "PlatformSecurityContext (Internal)", "protocol": "HTTP/1.1" }, { "namespace": "org.apache.fineract.useradministration.api", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResourceSwagger.java", "mechanism": "REST", "name": "Roles API Schemas", "description": "Defines the Swagger/OpenAPI schemas (Request and Response bodies) for the Roles management REST API. These schemas model the data structures for creating, retrieving, updating, and deleting roles and their permissions.", "path": "/roles (inferred)", "method": "GET, POST, PUT, DELETE", "direction": "BOTH" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "retrieveAllRoles", "description": "List all roles", "path": "/v1/roles", "method": "GET", "responseBody": "JSON array of RoleData" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "createRole", "description": "Create a new role", "path": "/v1/roles", "method": "POST", "requestBody": "JSON object with name and description", "responseBody": "JSON object with resourceId" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "retrieveRole", "description": "Retrieve a specific role", "path": "/v1/roles/{roleId}", "method": "GET", "responseBody": "JSON object of RoleData" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "actionsOnRoles", "description": "Enable or Disable a role", "path": "/v1/roles/{roleId}", "method": "POST", "requestBody": "Empty or JSON", "responseBody": "JSON object with resourceId" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "updateRole", "description": "Update a role", "path": "/v1/roles/{roleId}", "method": "PUT", "requestBody": "JSON object with updates", "responseBody": "JSON object with resourceId" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "retrieveRolePermissions", "description": "Retrieve permissions for a role", "path": "/v1/roles/{roleId}/permissions", "method": "GET", "responseBody": "JSON object of RolePermissionsData" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "updateRolePermissions", "description": "Update permissions for a role", "path": "/v1/roles/{roleId}/permissions", "method": "PUT", "requestBody": "JSON object with permissions", "responseBody": "JSON object with resourceId" }, { "namespace": "org.apache.fineract.useradministration.api.RolesApiResource", "filepath": "fineract-provider/src/main/java/org/apache/fineract/useradministration/api/RolesApiResource.java", "mechanism": "REST", "name": "deleteRole", "description": "Delete a role", "path": "/v1/roles/{roleId}", "method": "DELETE", "responseBody": "JSON object with resourceId" }, { "namespace": "window", "filepath": "fineract-provider/src/main/resources/static/legacy-docs/jquery-1.7.min.js", "mechanism": "REST", "name": "jQuery.ajax", "description": "Performs asynchronous HTTP requests to fetch or send data to a server.", "path": "Dynamic (determined by url parameter)", "method": "Dynamic (GET, POST, PUT, DELETE)", "direction": "BIDIRECTIONAL", "protocol": "HTTP/1.1" } ], "billOfMaterials": [ { "name": "awaitility", "groupId": "org.awaitility", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "bcpg-jdk15on", "groupId": "org.bouncycastle", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "bcpkix-jdk15to18", "groupId": "org.bouncycastle", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "bcprov-jdk15on", "groupId": "org.bouncycastle", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "bcprov-jdk15to18", "groupId": "org.bouncycastle", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "bug-pattern", "groupId": "jp.skypencil.findbugs.slf4j", "versions": [ "1.5.0" ], "hasConflict": false, "scopes": [ "spotbugsPlugins" ], "locations": [ "build.gradle" ] }, { "name": "checkstyle", "groupId": "com.puppycrawl.tools", "versions": [ "10.12.1" ], "hasConflict": false, "scopes": [ "checkstyle" ], "locations": [ "build.gradle" ] }, { "name": "classgraph", "groupId": "io.github.classgraph", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "commons-io", "groupId": "commons-io", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "commons-lang3", "groupId": "org.apache.commons", "versions": [ "3.12.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "converter-jackson", "groupId": "com.squareup.retrofit2", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "cucumber-core", "groupId": "io.cucumber", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "cucumber-java", "groupId": "io.cucumber", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "cucumber-java8", "groupId": "io.cucumber", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "cucumber-junit-platform-engine", "groupId": "io.cucumber", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "cucumber-spring", "groupId": "io.cucumber", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "eclipselink", "groupId": "org.eclipse.persistence", "versions": [ "4.0.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "error_prone_core", "groupId": "com.google.errorprone", "versions": [ "2.20.0" ], "hasConflict": false, "scopes": [ "errorprone" ], "locations": [ "build.gradle" ] }, { "name": "fineract-core", "groupId": "org.apache.fineract", "versions": [ "latest" ], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "fineract-war/build.gradle" ] }, { "name": "fineract-core", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "custom/docker/build.gradle" ] }, { "name": "fineract-investor", "groupId": "org.apache.fineract", "versions": [ "latest" ], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "fineract-war/build.gradle" ] }, { "name": "fineract-loan", "groupId": "org.apache.fineract", "versions": [ "latest" ], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "fineract-war/build.gradle" ] }, { "name": "fineract-provider", "groupId": "org.apache.fineract", "versions": [ "latest" ], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "fineract-war/build.gradle" ] }, { "name": "fineract-provider", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "custom/docker/build.gradle" ] }, { "name": "freemarker", "groupId": "org.freemarker", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "gradle-cargo-plugin", "groupId": "com.bmuschko", "versions": [ "2.9.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "jackson-databind", "groupId": "com.fasterxml.jackson.core", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "jakarta.activation", "groupId": "com.sun.activation", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "jakarta.mail", "groupId": "com.sun.mail", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "jakarta.servlet-api", "groupId": "jakarta.servlet", "versions": [ "6.0.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "jakarta.ws.rs-api", "groupId": "jakarta.ws.rs", "versions": [ "3.1.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "jib-layer-filter-extension-gradle", "groupId": "com.google.cloud.tools", "versions": [ "0.3.0" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "jul-to-slf4j", "groupId": "org.slf4j", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "junit-jupiter-api", "groupId": "org.junit.jupiter", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "junit-jupiter-engine", "groupId": "org.junit.jupiter", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "junit-jupiter-params", "groupId": "org.junit.jupiter", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "junit-platform-runner", "groupId": "org.junit.platform", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "log4j-over-slf4j", "groupId": "org.slf4j", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "logback-classic", "groupId": "ch.qos.logback", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "logback-core", "groupId": "ch.qos.logback", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "logging-interceptor", "groupId": "com.squareup.okhttp3", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "lombok", "groupId": "org.projectlombok", "versions": [], "hasConflict": false, "scopes": [ "annotationProcessor", "compileOnly", "testAnnotationProcessor", "testCompileOnly" ], "locations": [ "build.gradle" ] }, { "name": "mapstruct-processor", "groupId": "org.mapstruct", "versions": [], "hasConflict": false, "scopes": [ "annotationProcessor", "testAnnotationProcessor" ], "locations": [ "build.gradle" ] }, { "name": "mariadb-java-client", "groupId": "org.mariadb.jdbc", "versions": [], "hasConflict": false, "scopes": [ "compile", "implementation" ], "locations": [ "custom/docker/build.gradle", "fineract-provider/build.gradle" ] }, { "name": "mockito-core", "groupId": "org.mockito", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "mockito-inline", "groupId": "org.mockito", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "mockito-junit-jupiter", "groupId": "org.mockito", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "mysql-connector-java", "groupId": "mysql", "versions": [ "8.0.33" ], "hasConflict": false, "scopes": [ "compile", "driver", "runtime" ], "locations": [ "custom/docker/build.gradle", "twofactor-tests/build.gradle", "oauth2-tests/build.gradle", "integration-tests/build.gradle", "fineract-provider/build.gradle" ] }, { "name": "okhttp", "groupId": "com.squareup.okhttp3", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "org.eclipse.jgit", "groupId": "org.eclipse.jgit", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "org.eclipse.jgit.ssh.apache", "groupId": "org.eclipse.jgit", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "postgresql", "groupId": "org.postgresql", "versions": [], "hasConflict": false, "scopes": [ "compile", "implementation" ], "locations": [ "custom/docker/build.gradle", "fineract-provider/build.gradle" ] }, { "name": "retrofit", "groupId": "com.squareup.retrofit2", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "semver4j", "groupId": "com.vdurmont", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "sevntu-checks", "groupId": "com.github.sevntu-checkstyle", "versions": [ "1.44.1" ], "hasConflict": false, "scopes": [ "checkstyle" ], "locations": [ "build.gradle" ] }, { "name": "slf4j-api", "groupId": "org.slf4j", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "spring-boot-autoconfigure-processor", "groupId": "org.springframework.boot", "versions": [], "hasConflict": false, "scopes": [ "annotationProcessor", "provided", "testAnnotationProcessor" ], "locations": [ "build.gradle", "custom/docker/build.gradle" ] }, { "name": "spring-boot-configuration-processor", "groupId": "org.springframework.boot", "versions": [], "hasConflict": false, "scopes": [ "annotationProcessor", "provided", "testAnnotationProcessor" ], "locations": [ "build.gradle", "custom/docker/build.gradle" ] }, { "name": "spring-boot-starter-test", "groupId": "org.springframework.boot", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "spring-context", "groupId": "org.springframework", "versions": [], "hasConflict": false, "scopes": [ "implementation" ], "locations": [ "build.gradle" ] }, { "name": "svnkit", "groupId": "org.tmatesoft.svnkit", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "swagger-jaxrs2-jakarta", "groupId": "io.swagger.core.v3", "versions": [ "2.2.11" ], "hasConflict": false, "scopes": [ "classpath" ], "locations": [ "build.gradle" ] }, { "name": "text-io", "groupId": "org.beryx", "versions": [], "hasConflict": false, "scopes": [ "compile" ], "locations": [ "buildSrc/build.gradle" ] }, { "name": "truth", "groupId": "com.google.truth", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] }, { "name": "truth-java8-extension", "groupId": "com.google.truth.extensions", "versions": [], "hasConflict": false, "scopes": [ "testImplementation" ], "locations": [ "build.gradle" ] } ], "codeQualitySummary": { "topComplexFunctions": [ { "complexity": 80, "functionName": "window::ajax", "filePath": "fineract-provider/src/main/resources/static/legacy-docs/jquery-1.7.min.js", "linesOfCode": 1, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "LONG PARAMETER LIST" ] }, { "complexity": 75, "functionName": "org.apache.fineract.portfolio.loanproduct.serialization.LoanProductDataValidator::validateForUpdate", "filePath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/serialization/LoanProductDataValidator.java", "linesOfCode": 350, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DEEP NESTING" ] }, { "complexity": 68, "functionName": "org.apache.fineract.portfolio.loanaccount.service.LoanApplicationWritePlatformServiceJpaRepositoryImpl::modifyApplication", "filePath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanApplicationWritePlatformServiceJpaRepositoryImpl.java", "linesOfCode": 265, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DEEP NESTING", "FEATURE ENVY" ] }, { "complexity": 68, "functionName": "org.apache.fineract.portfolio.loanproduct.domain.LoanProduct::update", "filePath": "fineract-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/domain/LoanProduct.java", "linesOfCode": 315, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "FEATURE ENVY" ] }, { "complexity": 68, "functionName": "org.apache.fineract.portfolio.loanproduct.serialization.LoanProductDataValidator::validateForCreate", "filePath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/serialization/LoanProductDataValidator.java", "linesOfCode": 325, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DEEP NESTING" ] }, { "complexity": 65, "functionName": "org.apache.fineract.portfolio.loanaccount.serialization.LoanApplicationCommandFromApiJsonHelper::validateForModify", "filePath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/serialization/LoanApplicationCommandFromApiJsonHelper.java", "linesOfCode": 285, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DUPLICATE CODE", "DEEP NESTING" ] }, { "complexity": 53, "functionName": "org.apache.fineract.integrationtests.common.shares.ShareAccountIntegrationTests::testCreateShareAccountWithCharges", "filePath": "integration-tests/src/test/java/org/apache/fineract/integrationtests/common/shares/ShareAccountIntegrationTests.java", "linesOfCode": 385, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DUPLICATE CODE", "MAGIC NUMBERS", "DEEP NESTING" ] }, { "complexity": 52, "functionName": "org.apache.fineract.portfolio.loanaccount.serialization.LoanApplicationCommandFromApiJsonHelper::validateForCreate", "filePath": "fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/serialization/LoanApplicationCommandFromApiJsonHelper.java", "linesOfCode": 235, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "DEEP NESTING" ] }, { "complexity": 51, "functionName": "org.apache.fineract.portfolio.loanaccount.domain.Loan::loanApplicationModification", "filePath": "fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java", "linesOfCode": 155, "codeSmells": [ "LONG METHOD", "COMPLEX CONDITIONAL", "LONG PARAMETER LIST" ] }, { "complexity": 50, "functionName": "window::init", "filePath": "fineract-provider/src/main/resources/static/legacy-docs/jquery-1.7.min.js", "linesOfCode": 1, "codeSmells": [ "COMPLEX CONDITIONAL", "LONG METHOD" ] } ], "commonCodeSmells": [ { "occurrences": 653, "smellType": "DATA CLASS", "affectedFiles": 653 }, { "occurrences": 337, "smellType": "LONG PARAMETER LIST", "affectedFiles": 337 }, { "occurrences": 244, "smellType": "LONG METHOD", "affectedFiles": 244 }, { "occurrences": 219, "smellType": "COMPLEX CONDITIONAL", "affectedFiles": 219 }, { "occurrences": 172, "smellType": "DUPLICATE CODE", "affectedFiles": 172 }, { "occurrences": 153, "smellType": "OTHER", "affectedFiles": 147 }, { "occurrences": 137, "smellType": "MAGIC NUMBERS", "affectedFiles": 137 }, { "occurrences": 124, "smellType": "TOO MANY METHODS", "affectedFiles": 124 }, { "occurrences": 110, "smellType": "LARGE FILE", "affectedFiles": 110 }, { "occurrences": 43, "smellType": "GOD CLASS", "affectedFiles": 43 }, { "occurrences": 42, "smellType": "INVALID", "affectedFiles": 42 }, { "occurrences": 32, "smellType": "DEEP NESTING", "affectedFiles": 32 }, { "occurrences": 28, "smellType": "FEATURE ENVY", "affectedFiles": 24 }, { "occurrences": 9, "smellType": "DEAD CODE", "affectedFiles": 9 } ], "overallStatistics": { "totalFunctions": 18149, "highComplexityCount": 203, "veryHighComplexityCount": 58, "longFunctionCount": 400, "averageComplexity": 1.66, "averageFunctionLength": 7.96 } }, "scheduledJobsSummary": { "jobs": [ { "jobName": "Database Initialization", "sourceFile": "fineract-db/docker/postgresql/01-init.sh", "trigger": "event-driven", "purpose": "Provisions the initial database user, creates required databases, and assigns privileges during the application or container startup phase.", "inputResources": [ "Environment Variable: POSTGRES_PASSWORD", "Environment Variable: POSTGRES_USER", "Environment Variable: POSTGRES_DB", "Environment Variable: FINERACT_DB_USER", "Environment Variable: FINERACT_DB_PASS", "Environment Variable: FINERACT_TENANTS_DB_NAME", "Environment Variable: FINERACT_TENANT_DEFAULT_DB_NAME" ], "outputResources": [ "PostgreSQL User", "PostgreSQL Database (Tenants)", "PostgreSQL Database (Default Tenant)" ], "dependencies": [ "PostgreSQL Server" ] }, { "jobName": "Fineract Kubernetes Deployment", "sourceFile": "kubernetes/kubectl-startup.sh", "trigger": "manual", "purpose": "Orchestrates the full deployment of the Fineract ecosystem (Database, Backend, UI) onto a Kubernetes cluster by applying YAML configurations and waiting for pod readiness.", "inputResources": [ "fineractmysql-configmap.yml", "fineractmysql-deployment.yml", "fineract-server-deployment.yml", "fineract-mifoscommunity-deployment.yml", "/dev/urandom" ], "outputResources": [ "Kubernetes Secret: fineract-tenants-db-secret", "Kubernetes ConfigMap", "Kubernetes Deployment: fineractmysql", "Kubernetes Deployment: fineract-server", "Kubernetes Deployment: fineract-mifoscommunity" ], "dependencies": [ "kubectl", "Kubernetes Cluster" ] }, { "jobName": "Fineract Kubernetes Teardown", "sourceFile": "kubernetes/kubectl-shutdown.sh", "trigger": "manual", "purpose": "To manually de-provision and delete the Apache Fineract application stack, including its database, server, and community interface deployments, along with associated secrets and configurations from the Kubernetes cluster.", "inputResources": [ "fineractmysql-configmap.yml", "fineractmysql-deployment.yml", "fineract-server-deployment.yml", "fineract-mifoscommunity-deployment.yml" ], "outputResources": [], "dependencies": [ "kubectl", "Kubernetes Cluster" ] }, { "jobName": "Gradle Wrapper Execution", "sourceFile": "gradlew.bat", "trigger": "manual", "purpose": "Executes the Gradle build system using the project-specific wrapper configuration. It bootstraps the download of the correct Gradle distribution (if missing) and runs the requested build tasks.", "inputResources": [ "gradle/wrapper/gradle-wrapper.jar", "Environment Variables (JAVA_HOME, JAVA_OPTS, GRADLE_OPTS)" ], "outputResources": [ "Build Artifacts (typically in build/ directory)", "Console Output" ], "dependencies": [ "Java Runtime Environment (java.exe)" ] } ], "totalJobs": 4, "triggerTypes": [ "event-driven", "manual" ], "jobFiles": [ "gradlew.bat", "kubernetes/kubectl-startup.sh", "fineract-db/docker/postgresql/01-init.sh", "kubernetes/kubectl-shutdown.sh" ] }, "moduleCoupling": { "couplings": [ { "fromModule": "fineract-provider/src", "toModule": "org.apache", "referenceCount": 17189, "couplingLevel": "Very High", "couplingLevelClass": "badge-danger" }, { "fromModule": "integration-tests/src", "toModule": "org.apache", "referenceCount": 2323, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "fineract-core/src", "toModule": "org.apache", "referenceCount": 1639, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "fineract-loan/src", "toModule": "org.apache", "referenceCount": 673, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "fineract-investor/src", "toModule": "org.apache", "referenceCount": 347, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "fineract-client/src", "toModule": "org.apache", "referenceCount": 134, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "custom/acme", "toModule": "org.apache", "referenceCount": 41, "couplingLevel": "Low", "couplingLevelClass": "badge-success" }, { "fromModule": "custom/acme", "toModule": "com.acme", "referenceCount": 5, "couplingLevel": "Low", "couplingLevelClass": "badge-success" } ], "totalModules": 9, "totalCouplings": 8, "highestCouplingCount": 17189, "moduleDepth": 2 } }