This section contains information on steps for integrating with the Persister Service and Kafka.

Steps to integrate Persister Service and Kafka:

Overview

Follow the steps detailed below to add the Kafka configurations.

Steps

Add the below code in application.properties to configure Kafka.

Overview

Follow the steps detailed below to implement & .

Producer

Producer classes help in pushing data from the application to Kafka topics. DIGIT has a custom implementation of KafkaTemplate class in the tracer library called CustomKafkaTemplate. This implementation of the Producer class does not change across services of DIGIT.

Steps

1. Access the producer implementation details here -

   The Codegen jar already has created a Producer class. We will continue using it.

2. Make sure the tracer dependency version in the pom.xml is 2.9.0-SNAPSHOT.

Consumer

For our guide, we will be implementing a notification consumer in the following section.

Once an application is created/requested or progresses further in the workflow, notifications can be triggered as each of these events is pushed onto Kafka topics which can be listened to and an sms/email/in-app notification can be sent to the concerned user(s).

For our guide, we will be implementing a notification consumer which will listen to the topic on which birth registration applications are created. Create a customised message and send it to the notification service (sms/email) to trigger notifications to the concerned users.

Steps

1. Open Kafka/NotificationConsumer.java and paste the following code:

1. Create a POJO by the name of SMSRequest in the web.models package and add the below content to it:

1. Create a class by the name of NotificationService under service folder to handle preparation of customised messages and pushing the notifications.

   Add the below content to it -

Overview

This page provides the steps on how to add persister configuration.

The persister configuration is written in a YAML format. The INSERT and UPDATE queries for each table are added in prepared statement format, followed by the jsonPaths of values that have to be inserted/updated.

For example, for a table named studentinfo with id, name, age, and marks fields, the following configuration will get the persister ready to insert data into studentinfo table -

Steps

Add Persister Configuration

1. Persister configurations for all modules are present under the egov-persister folder. Create a file by the name of btr-persister.yml (or any other name) under the egov-persister folder.

2. Add the below content to it -

Run Persister Locally

1. Import all the core-services projects as Maven projects into your IDE. It is assumed that you have already cloned the DIGIT code locally.

2. Modify the application.properties file in the egov-persister project and set the following property:

1. Make sure the Spring DB configurations and Flyway config reflect the same database as what has been set in the module itself. Otherwise, we will see failures in the persister code.

1. Make sure the Kafka is running locally. Now, go ahead and run the EgovPersistApplication from the IDE. Check the console to make sure it is listening to the right topics as configured in your module's application.properties file.

The persister is now ready for use.

Deploy Persister Configuration

1. Push the code to the appropriate branch from which your environment will read it.

2. Navigate to your fork of the DIGIT-DevOps repository. Under the deploy-as-code/helm/environments directory, find the deployment helm chart that was used to deploy DIGIT.

3. In the deployment helm chart (which was used to set up the DIGIT environment), find "egov-persister". Find the "persist-yml-path" property and add the path to your new persister file here.

   In the snippet below, file:///work-dir/configs/egov-persister/birth-module-developer-guide.yml

1. Raise a PR to the appropriate branch of the DevOps repo (master, in egov case) which was forked/used to create the deployment. Once that is merged, restart the indexer service in your environment so it will pick up this new config for the module.

Overview

Enabling signed audit for a module ensures that all transactions - creates, updates, deletes - are recorded in a digitally signed fashion. Learn more about the signed here.

Steps

Enable Signed Audit

1. Add the following lines of code to the birth registration persister after the fromTopic attribute under mappings:

Checklist

Before starting development on top of DIGIT make sure:

• To check out the Development Pre-requisites Training Resources page to learn how to deploy the required tools.

• DIGIT code from DIGIT-OSS, egov-mdms-data, configs etc.. has been forked from GitHub under your organization’s umbrella account.

• You have access to the forked repositories from your GitHub user account. Note that the user account is different from the organization's account.

• Access a DIGIT environment - FQDN, Access keys etc..The DIGIT environment can be a single VM setup for a development environment. Please refer to these docs for the installation of DIGIT.

• Install DIGIT in a development environment (Single VM setup) by following the quick setup guide.

• It is recommended to deploy the following services in the development environment -

  • User

  • MDMS

  • Localization

  • Id-Gen

  • URL-shortener

  • Workflow

Some of the above services can also be port-forwarded using Kubernetes to bypass user authentication.

• Make sure the following DIGIT services are running in the local environment:

  • Persister

  • Indexer (optional)

  • PDF Service

• CD/CI has been set up for DIGIT. This is a pre-requisite to deploying new DIGIT modules. CD/CI processes will be used to build and deploy the new module that will be developed.

• Design phase artefacts

• In addition, knowledge of the following technologies is required for developing on DIGIT: (Refer to the DIGIT Pre-requisites tutorials for help with installing and deploying these tools)

  • Java/J2EE

  • Spring Boot

  • REST APIs and related concepts like path parameters, headers, JSON etc.

  • Git

  • PostgreSQL

  • Kafka

This guide provides detailed steps for developers to create a new microservice on top of DIGIT. At the end of this guide, you will be able to run the sample module provided (code provided), test it out locally and also deploy it using CI/CD to your DIGIT environment.

Steps to create a microservice:

• Set up your development environment

• Develop the registries, services, and APIs for a voter registration module that were described in the Design Guide

• Integrate with an existing DIGIT environment and re-use a lot of the common services using Kubernetes port forwarding

• Test the new module and debug

• Build and deploy the new service in the DIGIT environment

The guide is divided into multiple sections for ease of use. Click on the section cards below to follow the development steps.

Access the sample module here. Download and run this in the local environment.

This section provides the complete details of the system pre-requisites, prepping and setting up the system for development.

Follow the steps in the docs resources below:

On this page:

• Backend pre-requisites training resources

• Frontend/UI pre-requisites training resources

Backend Pre-requisites Tutorials

Frontend/UI Pre-requisites Tutorials

Additional Reads

The outputs of the design phase are the inputs to the development phase.

The docs below provide the steps and the resources required to build and design the module.

Overview

This page provides detailed steps for generating projects using the given API specifications.

Steps

Build A Microservice

1. Prepare contracts that detail all the APIs that the service is going to expose for external consumption. eGov uses a customised tool.

2. Download the jar file and make sure it is available in the classpath. Use the to generate client SDKs using these Swagger contracts.

Generate API Skeleton

1. Use the generic command below to create an API skeleton for any Swagger contract:

The following sequence is used to generate the API skeleton using codegen jar:

1. Navigate to the folder where you have downloaded the codegen jar.

2. Execute the following command:

OR

1. Rename the output folder to birth-registration.

2. Import it in Eclipse or VS Code.

3. Update the spring-boot-starter-parent to 3.2.2 in pom.xml.

4. Perform a maven update once the spring boot version is updated.

5. Put a slash in front of server.contextPath and add this property to the application.properties file which helps request handlers to serve requests -

1. Add the below external dependencies to pom.xml:

Welcome to DIGIT Developer Guides!

For ease of use, we have divided our guides broadly into 2 sections:

For a practical orientation, these guides, together, will walk you through all the steps required to build a birth registration service module and a corresponding UI module.

Overview

Once PostgreSQL (v10) has been installed and the basic setup is done, we use Flyway to create the tables.

Steps

Enable Flyway Migration

1. Configure the below properties in the application.properties file to enable flyway migration:

1. Add the Flyway SQL scripts in the following structure under resources/db/migration/main:

1. Add the migration files to the main folder. Follow the specified nomenclature while naming the file. The file name should be in the following format:

Example: V20180920110535__tl_tradelicense_ddl.sql

For this sample service, use the following SQL script to create the required tables.

This section showcases how to create a basic Spring Boot project using an API spec and configure the database.

Follow the steps detailed below:

Overview

Follow the steps outlined on this page to setup the DIGIT development environment.

Steps

To setup the DIGIT development environment -

1. Run the Kafka and PostgreSQL on the development machine and re-use other services from the DIGIT development environment. The following tools are required for development:

   • Install Git

   • Install JDK17

   • Install IDE - To create SpringBoot/Java applications it is recommended to use IntelliJ IDE. IntelliJ can be downloaded from the following links -

   • Install the Lombok plugins for IntelliJ as we use Lombok annotations in this module.

   • Install Kafka (version 3.2.0 which is the latest version) - To install and run Kafka locally, follow the following links -

   • Install Postman - To install Postman, follow the following links -

   • Install Kubectl - Kubectl is the tool that we use to interact with services deployed on our sandbox environment -

   • Install aws-iam-authenticator - (if the DIGIT development environment is in AWS) -

   • Install PostgreSQL v14 locally

2. Add configuration - Post installation of Kubectl, add the following configuration in the Kubernetes config file to enable access to resources in our sandbox environment. Kubernetes config file is available in the user's home directory (which varies from OS to OS).

   For example, on a Mac, it is available at:/Users/xyz/.kube/config

   Once the config file is created, add the following content to it.

Once the configuration file is created, access the pods running in the environment by typing: kubectl get pods

This lists all the pods in the development environment.

DB Schema Diagram

The DB tables provide the registry maps as given below:

Overview

The application.properties file is already populated with default values. Read on to learn how to customise and add extra values for your application (if required).

Steps

Kafka topics for the module that need to be added are detailed .

Include all the necessary service host URLs and API endpoints in the "application.properties" file.

This guide specifically references the User, Localisation, HRMS, IDGen, MDMS, and Workflow services that are operational within the DIGIT development environment.

Configure Application Properties

1. Add the following properties to the application.properties file.

The following properties must be added for configuring the database and Kafka server. Make sure to use the default values to tune in the Kafka server that can be overwritten during deployment.

1. Include the following properties in the "application.properties" file to configure the database and Kafka for development purposes once you have completed adding the external dependencies to the "pom.xml" file and reloading the Maven changes.

Configure Kafka

Kafka Topics For Module

Create & Update Kafka Topics For The Module

1. Append Kafka configurations as per the specific requirements of the DIGIT services. Each module may use different configurations to manage its topics.

API Specs

Find below the Open API specifications defined for this guide:

Process Workflow Diagram

Registries

As a part of this guide, we are going to build a single birth registry. We will re-use the user registry from the DIGIT core. This will capture the mother and father details and store them in the user registry. The baby's details will remain in the birth registry.

Services

A single birth service will manage the registry.

System Architecture Diagram

Overview

The pom.xml typically includes most of the dependencies listed below at project generation time. Review and ensure that all of these dependencies are present. Update the pom.xml in case any are missing.

Steps

Models/POJOs of the dependent service can be imported from the digit-core-models library (work on creating the library is ongoing). These models are used to integrate with the dependent services.

<dependency>
      <groupId>org.egov.services</groupId>
      <artifactId>tracer</artifactId>
      <version>2.9.0-SNAPSHOT</version>
 </dependency>

These are pre-written libraries which contain tracer support, common models like MDMS, Auth and Auth and the capability to raise custom exceptions.

Once these core models are imported, it is safe to delete the RequestInfo, and ResponseInfo classes from the models folder and use the ones present in the common contract that is imported.

Import Core Models

Before starting development, create/update the following classes as given below.

1. Delete the following classes which have been generated from codegen - -Address -AuditDetails -Document -Error -ErrorResponse -RequestInfo -RequestInfoWrapper -ResponseInfo -Role -User -Workflow After this import the above classes from egov common-service library as follow-

   Copy

   import org.egov.common.contract.models.Address;
   import org.egov.common.contract.models.AuditDetails;
   import org.egov.common.contract.request.RequestInfo;
   import org.egov.common.contract.models.RequestInfoWrapper;
   import org.egov.common.contract.response.ResponseInfo;
   import org.egov.common.contract.request.Role;
   import org.egov.common.contract.request.User;
   import org.egov.common.contract.workflow.*;

2. Create the BirthApplicationSearchRequest POJO with the following content -

package digit.web.models;
import com.fasterxml.jackson.annotation.JsonProperty;

import org.egov.common.contract.request.RequestInfo;
import org.springframework.validation.annotation.Validated;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Data;
import lombok.Builder;

/**
 * BirthApplicationSearchCriteria
 */
@Validated
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class BirthApplicationSearchRequest {

    @JsonProperty("RequestInfo")
    @Valid
    private RequestInfo requestInfo = null;

    @JsonProperty("BirthApplicationSearchCriteria")
    @Valid
    private BirthApplicationSearchCriteria birthApplicationSearchCriteria = null;

}

1. Update BirthApplicationAddress pojo

package digit.web.models;

import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.UUID;

import org.egov.common.contract.models.Address;
import org.springframework.validation.annotation.Validated;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Data;
import lombok.Builder;

/**
 * BirthApplicationAddress
 */
@Validated
@jakarta.annotation.Generated(value = "org.egov.codegen.SpringBootCodegen", date = "2024-05-03T11:52:56.302336279+05:30[Asia/Kolkata]")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class BirthApplicationAddress   {
        @JsonProperty("id")

          @Valid
                private String id = null;

        @JsonProperty("tenantId")
          @NotNull

        @Size(min=2,max=64)         private String tenantId = null;

        @JsonProperty("applicationNumber")

                private String applicationNumber = null;

        @JsonProperty("applicantAddress")

          @Valid
                private Address applicantAddress = null;


}

1. Create the BTRConfiguration class within the configuration package. The MainConfiguration class should already exist inside the config package.

package digit.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.*;
import org.egov.tracer.config.TracerConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Component;

import jakarta.annotation.PostConstruct;
import java.util.TimeZone;

@Component
@Data
@Import({TracerConfiguration.class})
@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
public class BTRConfiguration {
    @Value("${app.timezone}")
    private String timeZone;

    @PostConstruct
    public void initialize() {
        TimeZone.setDefault(TimeZone.getTimeZone(timeZone));
    }

    @Bean
    @Autowired
    public MappingJackson2HttpMessageConverter jacksonConverter(ObjectMapper objectMapper) {
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        converter.setObjectMapper(objectMapper);
        return converter;
    }

    // User Config
    @Value("${egov.user.host}")
    private String userHost;

    @Value("${egov.user.context.path}")
    private String userContextPath;

    @Value("${egov.user.create.path}")
    private String userCreateEndpoint;

    @Value("${egov.user.search.path}")
    private String userSearchEndpoint;

    @Value("${egov.user.update.path}")
    private String userUpdateEndpoint;

    //Idgen Config
    @Value("${egov.idgen.host}")
    private String idGenHost;

    @Value("${egov.idgen.path}")
    private String idGenPath;

    //Workflow Config
    @Value("${egov.workflow.host}")
    private String wfHost;

    @Value("${egov.workflow.transition.path}")
    private String wfTransitionPath;

    @Value("${egov.workflow.businessservice.search.path}")
    private String wfBusinessServiceSearchPath;

    @Value("${egov.workflow.processinstance.search.path}")
    private String wfProcessInstanceSearchPath;

    @Value("${is.workflow.enabled}")
    private Boolean isWorkflowEnabled;


    // BTR Variables

    @Value("${btr.kafka.create.topic}")
    private String createTopic;

    @Value("${btr.kafka.update.topic}")
    private String updateTopic;

    @Value("${btr.default.offset}")
    private Integer defaultOffset;

    @Value("${btr.default.limit}")
    private Integer defaultLimit;

    @Value("${btr.search.max.limit}")
    private Integer maxLimit;


    //MDMS
    @Value("${egov.mdms.host}")
    private String mdmsHost;

    @Value("${egov.mdms.search.endpoint}")
    private String mdmsEndPoint;

    //HRMS
    @Value("${egov.hrms.host}")
    private String hrmsHost;

    @Value("${egov.hrms.search.endpoint}")
    private String hrmsEndPoint;

    @Value("${egov.url.shortner.host}")
    private String urlShortnerHost;

    @Value("${egov.url.shortner.endpoint}")
    private String urlShortnerEndpoint;

    @Value("${egov.sms.notification.topic}")
    private String smsNotificationTopic;
}

The core models are imported.

Overview

Methods in the service layer, upon performing all the business logic, call methods in the repository layer to persist or lookup data i.e. it interacts with the configured data store. For executing the queries, JdbcTemplate class is used. JdbcTemplate takes care of the creation and release of resources such as creating and closing the connection etc. All database operations namely insert, update, search and delete can be performed on the database using methods of JdbcTemplate class.

Steps

On DIGIT the create and update operations are handled asynchronously.

The persister service listens on the topic to which service applications are pushed for insertion and updation. Persister then takes care of executing insert and update operations on the database without clogging the application’s threads.

The execution of search queries on the database returns applications as per the search parameters provided by the user.

Implement Repository Layer

1. Create packages - Add thequerybuilder and rowmapper packages within the repository folder.

2. Create a class - by the name of BirthApplicationQueryBuilder in querybuilder folder and annotate it with @Component annotation.

   Insert the following content in BirthApplicationQueryBuilder class -

package digit.repository.querybuilder;

import digit.web.models.BirthApplicationSearchCriteria;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.util.List;

@Component
public class BirthApplicationQueryBuilder {

    private static final String BASE_BTR_QUERY = " SELECT btr.id as bid, btr.tenantid as btenantid, btr.applicationnumber as bapplicationnumber, btr.babyfirstname as bbabyfirstname, btr.babylastname as bbabylastname, btr.fatherid as bfatherid, btr.motherid as bmotherid, btr.doctorname as bdoctorname, btr.hospitalname as bhospitalname, btr.placeofbirth as bplaceofbirth, btr.timeofbirth as btimeofbirth, btr.createdby as bcreatedby, btr.lastmodifiedby as blastmodifiedby, btr.createdtime as bcreatedtime, btr.lastmodifiedtime as blastmodifiedtime, ";

    private static final String ADDRESS_SELECT_QUERY = " add.id as aid, add.tenantid as atenantid, add.type as atype, add.address as aaddress, add.city as acity, add.pincode as apincode, add.registrationid as aregistrationid ";

    private static final String FROM_TABLES = " FROM eg_bt_registration btr LEFT JOIN eg_bt_address add ON btr.id = add.registrationid ";

    private final String ORDERBY_CREATEDTIME = " ORDER BY btr.createdtime DESC ";

    public String getBirthApplicationSearchQuery(BirthApplicationSearchCriteria criteria, List<Object> preparedStmtList){
        StringBuilder query = new StringBuilder(BASE_BTR_QUERY);
        query.append(ADDRESS_SELECT_QUERY);
        query.append(FROM_TABLES);

        if(!ObjectUtils.isEmpty(criteria.getTenantId())){
            addClauseIfRequired(query, preparedStmtList);
            query.append(" btr.tenantid = ? ");
            preparedStmtList.add(criteria.getTenantId());
        }
        if(!ObjectUtils.isEmpty(criteria.getStatus())){
            addClauseIfRequired(query, preparedStmtList);
            query.append(" btr.status = ? ");
            preparedStmtList.add(criteria.getStatus());
        }
        if(!CollectionUtils.isEmpty(criteria.getIds())){
            addClauseIfRequired(query, preparedStmtList);
            query.append(" btr.id IN ( ").append(createQuery(criteria.getIds())).append(" ) ");
            addToPreparedStatement(preparedStmtList, criteria.getIds());
        }
        if(!ObjectUtils.isEmpty(criteria.getApplicationNumber())){
            addClauseIfRequired(query, preparedStmtList);
            query.append(" btr.applicationnumber = ? ");
            preparedStmtList.add(criteria.getApplicationNumber());
        }

        // order birth registration applications based on their createdtime in latest first manner
        query.append(ORDERBY_CREATEDTIME);

        return query.toString();
    }

    private void addClauseIfRequired(StringBuilder query, List<Object> preparedStmtList){
        if(preparedStmtList.isEmpty()){
            query.append(" WHERE ");
        }else{
            query.append(" AND ");
        }
    }

    private String createQuery(List<String> ids) {
        StringBuilder builder = new StringBuilder();
        int length = ids.size();
        for (int i = 0; i < length; i++) {
            builder.append(" ?");
            if (i != length - 1)
                builder.append(",");
        }
        return builder.toString();
    }

    private void addToPreparedStatement(List<Object> preparedStmtList, List<String> ids) {
        ids.forEach(id -> {
            preparedStmtList.add(id);
        });
    }
}

1. Create a class - by the name of BirthApplicationRowMapper within the rowmapper package and annotate it with @Component.

   Add the following content to the class.

   Copy

   package digit.repository.rowmapper;
   
   import digit.web.models.*;
   import org.egov.common.contract.models.Address;
   import org.egov.common.contract.models.AuditDetails;
   import org.egov.common.contract.request.User;
   import org.egov.common.contract.user.enums.AddressType;
   import org.springframework.dao.DataAccessException;
   import org.springframework.jdbc.core.ResultSetExtractor;
   import org.springframework.stereotype.Component;
   
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.util.*;
   
   @Component
   public class BirthApplicationRowMapper implements ResultSetExtractor<List<BirthRegistrationApplication>> {
       public List<BirthRegistrationApplication> extractData(ResultSet rs) throws SQLException, DataAccessException {
           Map<String,BirthRegistrationApplication> birthRegistrationApplicationMap = new LinkedHashMap<>();
   
           while (rs.next()){
               String uuid = rs.getString("bapplicationnumber");
               BirthRegistrationApplication birthRegistrationApplication = birthRegistrationApplicationMap.get(uuid);
   
               if(birthRegistrationApplication == null) {
   
                   Long lastModifiedTime = rs.getLong("blastModifiedTime");
                   if (rs.wasNull()) {
                       lastModifiedTime = null;
                   }
   
   
                   User father = User.builder().uuid(rs.getString("bfatherid")).build();
                   User mother = User.builder().uuid(rs.getString("bmotherid")).build();
   
                   AuditDetails auditdetails = AuditDetails.builder()
                           .createdBy(rs.getString("bcreatedBy"))
                           .createdTime(rs.getLong("bcreatedTime"))
                           .lastModifiedBy(rs.getString("blastModifiedBy"))
                           .lastModifiedTime(lastModifiedTime)
                           .build();
   
                   birthRegistrationApplication = BirthRegistrationApplication.builder()
                           .applicationNumber(rs.getString("bapplicationnumber"))
                           .tenantId(rs.getString("btenantid"))
                           .id(rs.getString("bid"))
                           .babyFirstName(rs.getString("bbabyfirstname"))
                           .babyLastName(rs.getString("bbabylastname"))
                           .father(father)
                           .mother(mother)
                           .doctorName(rs.getString("bdoctorname"))
                           .hospitalName(rs.getString("bhospitalname"))
                           .placeOfBirth(rs.getString("bplaceofbirth"))
                           .timeOfBirth(rs.getInt("btimeofbirth"))
                           .auditDetails(auditdetails)
                           .build();
               }
               addChildrenToProperty(rs, birthRegistrationApplication);
               birthRegistrationApplicationMap.put(uuid, birthRegistrationApplication);
           }
           return new ArrayList<>(birthRegistrationApplicationMap.values());
       }
   
       private void addChildrenToProperty(ResultSet rs, BirthRegistrationApplication birthRegistrationApplication)
               throws SQLException {
           addAddressToApplication(rs, birthRegistrationApplication);
       }
   
       private void addAddressToApplication(ResultSet rs, BirthRegistrationApplication birthRegistrationApplication) throws SQLException {
           Address address = Address.builder()
                   .tenantId(rs.getString("atenantid"))
                   .address(rs.getString("aaddress"))
                   .city(rs.getString("acity"))
                   .pinCode(rs.getString("apincode"))
                   .build();
   
           BirthApplicationAddress birthApplicationAddress= BirthApplicationAddress.builder()
                           .id(rs.getString("aid"))
                           .tenantId(rs.getString("atenantid"))
                           .applicantAddress(address)
                           .build();
   
           birthRegistrationApplication.setAddress(birthApplicationAddress);
   
       }
   
   }

1. Create a class - by the name of BirthRegistrationRepository within the repository folder and annotate it with @Repository annotation.

   Add the following content to the class.

package digit.repository;

import digit.repository.querybuilder.BirthApplicationQueryBuilder;
import digit.repository.rowmapper.BirthApplicationRowMapper;
import digit.web.models.BirthApplicationSearchCriteria;
import digit.web.models.BirthRegistrationApplication;
import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;


@Slf4j
@Repository
public class BirthRegistrationRepository {

    @Autowired
    private BirthApplicationQueryBuilder queryBuilder;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private BirthApplicationRowMapper rowMapper;

    public List<BirthRegistrationApplication>getApplications(BirthApplicationSearchCriteria searchCriteria){
        List<Object> preparedStmtList = new ArrayList<>();
        String query = queryBuilder.getBirthApplicationSearchQuery(searchCriteria, preparedStmtList);
        log.info("Final query: " + query);
        return jdbcTemplate.query(query, preparedStmtList.toArray(), rowMapper);
    }
}

The repository layer is implemented.

Overview

A separate class should be created for integrating with each dependent microservice. Only one method from that class should be called from the main service class for integration.

This guide showcases the steps to integrate our microservices with other microservices like

1. IdGen Service

2. User Service

3. MDMS Service

4. Workflow Service

5. URL Shortening Service

Common Resources

For interacting with other microservices, we can create and implement the following ServiceRequestRepository class under repository package -

package digit.repository;


import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.extern.slf4j.Slf4j;
import org.egov.tracer.model.ServiceCallException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import java.util.Map;


@Repository
@Slf4j
public class ServiceRequestRepository {

    private ObjectMapper mapper;

    private RestTemplate restTemplate;


    @Autowired
    public ServiceRequestRepository(ObjectMapper mapper, RestTemplate restTemplate) {
        this.mapper = mapper;
        this.restTemplate = restTemplate;
    }


    public Object fetchResult(StringBuilder uri, Object request) {
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        Object response = null;
        try {
            response = restTemplate.postForObject(uri.toString(), request, Map.class);
        }catch(HttpClientErrorException e) {
            log.error("External Service threw an Exception: ",e);
            throw new ServiceCallException(e.getResponseBodyAsString());
        }catch(Exception e) {
            log.error("Exception while fetching from searcher: ",e);
        }

        return response;
    }
}