fineract-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Aditya H <meta1...@gmail.com>
Subject GSoC (UPI Integration) progress
Date Thu, 19 May 2016 21:30:08 GMT
Hi all,

I have been doing a lot of mental gymnastics lately, trying to wrap my brains around Fineract,
stitching together a mental big picture by reading the source, API doc, log output.

I have learned the basics of Gradle, and Spring Framework. Now I can interpret the *.gradle
build files which define the high-level logistics. Dependency Injection/IoC, and Spring Framework
with all its numerous components was overwhelming at first, but after reading from Spring
Framework Reference[1] I feel quite comfortable. You provide the bean definitions to the container
and it creates those objects and manages their life cycles for you. It took some time to understand
the subtle differences between @Configuration, @Component, @Service, @Repository, @Controller
annotations.

[1] http://docs.spring.io/spring/docs/4.1.9.RELEASE/spring-framework-reference/htmlsingle/

I have multiple approaches:

I start with reading ServerApplication.java and try to reason about the control flow, reading
about the Spring annotations that are encountered along the way. The startup log output helps
in this. ServerApplication @imports DataSourceConfiguration (which uses @Autowired JDBCDriverConfig
instance) which sets up the network connection to the MySQL database.
ServerApplication also @imports EmbeddedTomcatWithSSLConfiguration which sets up the embedded
Tomcat ServletContainer instance. AbstractApplicationConfiguration pulls in all the XML bean
definitions. And so on..

Another approach is to start with any ApiResource class, say ClientsApiResource, and trace
the execution which happens in response to each of the supported requests.

Listing all the beans:
Pretty much all the classes annotated with @Component, @Service, @Repository, and methods
annotated with @Bean and definitions in (resources/META-INF/spring/) XML files are objects
managed by the Spring context. They are all the ApiResource's, RepositoryWrapper's, CommandHandler's,
ServiceImpl's. They get instantiated according to their inter-dependencies.

Spring Security is used for securing the API endpoints with (Oauth/Basic auth) authentication.
Flyway updates the schemas of the databases by sequentially applying all the SQL scripts in
resources/sql/migrations. It was nice to find out such a tool exists. This must eliminate
lot of headache involved in reproducing and debugging bugs connected with evolving database
schemas. Each class annotated with @Entity in the domain/ directories represents a table in
the relational database.

We should have a product requirement page for Unified Payment Interface, where developers/users
who already know UPI can add specific requirements. Should the page be created at
https://mifosforge.jira.com/wiki/display/MIFOSX/Product+requirements
or on Confluence wiki?

I was wondering whether Mobile Money Integration or Credit Bureau Integration is a similar/related
task to UPI integration.

Soon I'll begin working on the UPI Java SDK.

Regards,
Aditya

Mime
View raw message