Overview

A core application which provides location details of the tenant for which the services are being provided.

Pre-requisites

Before you proceed with the documentation, make sure the following pre-requisites are met -

• Java 8

• PSQL server is running and a database is created

• Knowledge of egov-mdms service

• egov-mdms service is running and all the required mdms master are loaded in it

Key Functionalities

• The location information is also known as boundary data of ULB

• Boundary data can be of different hierarchies ADMIN, ELECTION hierarchy which is defined by the Administrators, Revenue hierarchy defined by the Revenue department.

• The election hierarchy has the locations divided into several types like zone, election ward, block, street and locality. The Revenue hierarchy has the locations divided into a zone, ward, block and locality.

• The model which defines the localities like zone, ward and etc is a boundary object which contains information like name, lat, long, parent or children boundary if any. The boundaries come under each other in a hierarchy - a zone contains wards, a ward contains blocks, and a block contains locality. The order in which the boundaries are contained in each other will differ based on the tenants.

Deployment Details

1. Add/Update the mdms master file which contains boundary data of ULB’s.

2. Add Role-Action mapping for egov-location APIs.

3. Deploy/Redeploy the latest version of egov-mdms service.

4. Fill the above environment variables in egov-location with proper values.

5. Deploy the latest version of egov-location service.

Configuration Details

The boundary data has been moved to mdms from the master tables in DB. The location service fetches the JSON from mdms and parses it to the structure of boundary object as mentioned above. A sample master would look like below.

{
  "tenantId": "pg.cityA",
   "moduleName": "egov-location",
  "TenantBoundary": [
  {
      "hierarchyType": {
              "code": "ADMIN",
              "name": "ADMIN"
      },
       "boundary": {
                "id": 1,
                "boundaryNum": 1,
                "name": "CityA",
                "localname": "CityA",
                "longitude": null,
                "latitude": null,
                "label": "City",
                "code": "pg.cityA",
                "children": []
        }

    }
 ]
}

Integration

Integration Scope

The egov-location API’s can be used by any module which needs to store the location details of the tenant.

Integration Benefits

• Get the boundary details based on boundary type and hierarchy type within the tenant boundary structure.

• Get the geographical boundaries by providing appropriate GeoJson.

• Get the tenant list in the given latitude and longitude.

Steps to Integration

1. To integrate, host of egov-location should be overwritten in helm chart.

2. /boundarys/_search should be added as the search endpoint for searching boundary details based on tenant Id, Boundary Type, Hierarchy Type etc.

3. /geography/_search should be added as the search endpoint .This method handles all requests related to geographical boundaries by providing appropriate GeoJson and other associated data based on tenantId or lat/long etc.

4. /tenant/_search should be added as the search endpoint. This method tries to resolve a given lat, long to a corresponding tenant, provided there exists a mapping between the reverse geocoded city to tenant.

5. The MDMS Tenant boundary master file should be loaded in MDMS service.

Reference Docs

Doc Links

API List

Please refer to the Swagger API contract for egov-location service to understand the structure of APIs and to have a visualisation of all internal APIs.

Core Services is one of the key DIGIT components. Browse through this section to learn more about the key configuration and integration details of these core services.

Overview

Workflows are a series of steps that moves a process from one state to another state by actions performed by different kind of Actors - Humans, Machines, Time based events etc. to achieve a goal like onboarding an employee, or approve an application or grant a resource etc. The egov-workflow-v2 is a workflow engine which helps in performing these operations seamlessly using a predefined configuration.

Pre-requisites

Before you proceed with the documentation, make sure the following pre-requisites are met -

• Java 8

• Kafka server is up and running

• egov-persister service is running and has workflow persister config path added in it

• PSQL server is running and a database is created to store workflow configuration and data

Key Functionalities

• Always allow anyone with a role in the workflow state machine to view the workflow instances and comment on it

• On the creation of workflow, it will appear in the inbox of all employees that have roles that can perform any state transitioning actions in this state.

• Once an instance is marked to an individual employee it will appear only in that employee's inbox although point 1 will still hold true and all others participating in the workflow can still search it and act if they have necessary action available to them

• If the instance is marked to a person who cannot perform any state transitioning action, they can still comment/upload and mark to anyone else.

• Overall SLA: SLA for the complete processing of the application/Entity

• State-level SLA: SLA for a particular state in the workflow

Interaction Diagram

Deployment Details

1. Deploy the latest version of egov-workflow-v2 service

2. Add businessService persister yaml path in persister configuration

3. Add Role-Action mapping for BusinessService APIs

4. Overwrite the egov.wf.statelevel flag ( true for state level and false for tenant level)

5. Create businessService (workflow configuration) according to product requirements

6. Add Role-Action mapping for /processInstance/_search API

7. Add workflow persister yaml path in persister configuration

Configuration Details

For Configuration details please refer to the links in Reference Docs

Integration Details

Integration Scope

The workflow configuration can be used by any module which performs a sequence of operations on an application/Entity. It can be used to simulate and track processes in organisations to make it more efficient too and increase accountability.

Integration Benefits

• Role-based workflow

• An easy way of writing rule

• File movement within workflow roles

Steps to Integration

1. To integrate, host of egov-workflow-v2 should be overwritten in helm chart

2. /process/_search should be added as the search endpoint for searching workflow process Instance object.

3. /process/_transition should be added to perform an action on an application. (It’s for internal use in modules and should not be added in Role-Action mapping)

4. The workflow configuration can be fetched by calling _search API to check if data can be updated or not in the current state

Reference Docs

Doc Links

API List

(Note: All the APIs are in the same postman collection, therefore, the same link is added in each row)

Overview

One of the applications in the DIGIT core group of services aims to reduce the time spent by developers on writing codes to store and fetch master data ( primary data needed for module functionality ) which doesn’t have any business logic associated with them. Instead of writing APIs, and creating tables in every different service to store and retrieve data that is seldom changed MDMS service keeps them at a single location for all modules and provides data on will with the help of no more than three lines of configuration.

Pre-requisites

1. Prior Knowledge of Java/J2EE.

2. Prior Knowledge of Spring Boot.

3. Prior Knowledge of REST APIs and related concepts like path parameters, headers, JSON etc.

4. Prior knowledge of Git.

5. Advanced knowledge of how to operate JSON data would be an added advantage to understanding the service.

Key Functionalities

• Adds master data for usage without the need to create master data APIs in every module.

• Reads data from GIT directly with no dependency on any database services.

Deployment Details

1. Deploy the latest version of Mdms-service

2. Add conf path for the file location

3. Add master config JSON path

Integration Details

Integration Scope

The MDMS service provides ease of access to master data for any service.

Integration Benefits

• No time spent writing repetitive codes with no business logic.

Steps to Integration

1. To integrate, host of egov-mdms-service should be overwritten in the helm chart

2. egov-mdms-service/v1/_search should be added as the search endpoint for searching master data.

3. Mdms client from eGov snapshots should be added as mvn entity in pom.xml for ease of access since it provides mdms request pojos.

Reference Docs

Docs

API List

Overview

The objective of the PDF generation service is to bulk generate pdf as per requirement.

Pre-requisites

Before you proceed with the documentation, make sure the following pre-requisites are met -

• Install npm.

• Kafka server is up and running.

• egov-persister service is running and has pdf generation persister config path added to it.

• PSQL server is running and the database is created to store the filestore id and job id of generated pdf.

Key Functionalities

• Provide a common framework to generate PDFs.

• Provide flexibility to customise the PDF as per the requirement.

• Provide functionality to add an image, Qr Code in PDF.

• Provide functionality to generate pdf in bulk.

• Provide functionality to specify the maximum number of records to be written in one PDF.

External Libraries:

Interaction Diagram

Deployment Details

1. Create data config and format config for a PDF according to product requirements.

2. Add data config and format config files in PDF configuration

3. Add the file path of data and format config in the environment .yml file

4. Deploy the latest version of pdf-service in a particular environment.

Configuration Details

Integration Details

Integration Scope

The PDF configuration can be used by any module which needs to show particular information in PDF format that can be printed/downloaded by the user.

Integration Benefits

• Functionality to generate PDFs in bulk.

• Avoid regeneration.

• Support QR codes and Images.

• Functionality to specify the maximum number of records to be written in one PDF.

• Uploading generated PDF to filestore and return filestore id for easy access.

Steps to Integration

• To download and print the required PDF _create API has to be called with the required key (For integration with UI, please refer to the links in Reference Docs)

Reference Docs

Doc Links

API List

(Note: All the APIs are in the same postman collection, therefore, the same link is added in each row)

Overview

DIGIT is an API-based platform where each API denotes a DIGIT resource. Access Control Service's (ACS) primary job is to authorise end-user based on their roles and provide access to the DIGIT platform resources. Access control functionality basically works based on the below points:

Actions: Actions are events which are performed by a user. This can be an API end-point or a Frontend event. This is the MDMS master.

Roles: Roles are assigned to the user, a user can hold multiple roles. Roles are defined in MDMS masters.

Role-Action: Role action is the mapping between actions and roles. Based on the role, the action mapping access control service identifies applicable actions for the role.

Pre-requisites

Before you proceed with the configuration, make sure the following pre-requisites are met -

• Java 8

• MDMS service is up and running

Key Functionalities

• Serve the applicable actions for a user based on user role (To print menu three).

• On each action which is performed by a user, access control looks at the roles for the user and validates actions mapping with the role.

• Support tenant-level role-action. For instance, an employee from Amritsar can have the role of APPROVER for other ULBs like Jalandhar and hence will be authorised to act as APPROVER in Jalandhar.

Deployment Details

1. Deploy the latest version of the Access Control Service

2. Deploy MDMS service to fetch the Role Action Mappings

Configuration Details

Define the roles

Add the Actions (URL)

Add the role action mapping

(The details about the fields in the configuration can be found in the swagger contract)

Integration Details

Integration Scope

Any microservice which requires authorisation can leverage the functionalities provided by the access control service.

Integration Benefits

Any new microservice that is to be added to the platform won’t have to worry about authorisation. It can just add its role action mapping in the master data and Access Control Service will perform authorisation whenever API for the microservice is called.

Steps to Integration

1. To integrate with Access Control Service the role action mapping has to be configured(added) in the MDMS service.

2. The service needs to call /actions/_authorize API of Access Control Service to check for authorisation of any request

Interaction Diagram

Reference Docs

Doc Links

API List

Overview

Indexer service runs as a separate service. This service is designed to perform all the indexing tasks of the digit platform. The service reads records posted on specific Kafka topics and picks the corresponding index configuration from the yaml file provided by the respective module. The objective of the Indexer Service is listed below.

• To provide a one-stop framework for indexing the data to elasticsearch.

• To create a provision for indexing live data, reindexing from one index to the other and indexing legacy data from the data store.

Pre-requisites

Before you proceed with the configuration, make sure the following pre-requisites are met -

1. Prior Knowledge of Java/J2EE

2. Prior Knowledge of SpringBoot

3. Prior Knowledge of Elasticsearch

4. Prior Knowledge of REST APIs and related concepts like path parameters, headers, JSON etc.

5. Prior Knowledge of Kafka and related concepts like Producer, Consumer, Topic etc.

Key Functionalities

• Performs three major tasks namely: LiveIndex, Reindex and LegacyIndex.

• LiveIndex: Task of indexing the live transaction data on the platform. This keeps the es data in sync with the database.

• Reindex: Task of indexing data from one index to the other. ES already provides this feature, indexer does the same but with data transformation.

• LegacyIndex: Task of indexing legacy data from the tables to ES.

• Provides flexibility to index the entire object, a part of the object or an entirely different custom object all using one input json from modules.

• Provides features for customizing index json by field mapping, field masking, data enrichment through external APIs and data denormalization using MDMS.

• One-stop shop for all the es index requirements with easy-to-write and easy-to-maintain configuration files.

• Designed as a consumer to save API overhead. The consumer configs are written from scratch to have complete control over consumer behaviour.

Deployment Details

• Step 1: Write the configuration as per your requirement. The structure of the config file is explained later in the same doc.

• Step 3: Provide the absolute path of the checked-in file to DevOps. This file path is added to the file-read path of the egov-indexer. The file is added to the egov-indexer's environment manifest file for it to be read at the start-up of the application.

• Step 4: Run the egov-indexer app, Since it is a consumer, it starts listening to the configured topics and indexes the data.

Interaction Diagram

Configuration Details

For Indexer Configuration, please refer to the document in the reference docs table given below.

API Details

a) POST /{key}/_index

Receive data and index. There should be a mapping with the topic as {key} in index config files.

b) POST /_reindex

This is used to migrate data from one index to another index

c) POST /_legacyindex

This is to run the LegacyIndex job to index data from the database. In the request body, the URL of the service that will be called by the indexer service to pick the data must be mentioned.

Reference Docs

Doc Links

Overview

User service is responsible for user data management and providing functionality to login and logout into the DIGIT system

Pre-requisites

Before you proceed with the configuration, make sure the following pre-requisites are met -

• Java 8

• Kafka server is up and running

• Encryption and MDMS services are running

• PSQL server is running and a database

• Redis is running

Key Functionalities

• Store, update and search user data

• Provide authentication

• Provide login and logout functionality into the DIGIT platform

• Store user data PIIs in encrypted form

Interaction Diagram

Deployment Details

1. Setup latest version of egov-enc-service and egov-mdms- service

2. Deploy the latest version of egov-user service

3. Add Role-Action mapping for APIs

Configuration Details

The following application properties file in user service are configurable.

Integration Details

Integration Scope

User data management and functionality to login and logout into Digit system using OTP and password.

Integration Benefits

Providing the following functionality to citizen and employee-type users

• Employee:

  • User registration

  • Search user

  • Update user details

  • Forgot password

  • Change password

  • User role mapping(Single ULB to multiple roles)

  • Enable employees to login into the DIGIT system based on a password.

• Citizen:

  • Create user

  • Update user

  • Search user

  • User registration using OTP

  • OTP based login

Steps to Integration

• To integrate, the host of egov-user should be overwritten in the helm chart.

• Use /citizen/_create and /users/_createnovalidate endpoints for creating users into the system

• Use /v1/_search and /_search endpoints to search users in the system depending on various search parameters

• Use /profile/_update for partial update and /users/_updatenovalidate for update

• Use /password/nologin/_update for otp based password reset and /password/_update for logged in user password reset

• Use /user/oauth/token for generating token, /_logoutfor logout and /_details for getting user information from his token

Reference Docs

Doc Links

API List

Overview

eGov Payment Gateway acts as a liaison between eGov apps and external payment gateways facilitating payments, reconciliation of payments and lookup of transactions status.

Pre-requisites

Before you proceed with the documentation, make sure the following pre-requisites are met -

• Java 8

• Kafka server is up and running

• egov-persister service is running and has pg service persister config path added in it

• PSQL server is running and the database is created to store transaction data.

Key Functionalities

• Create or initiate a transaction, to make a payment against a bill.

• Make payment for multiple bill details [multi module] for a single consumer code at once.

• Transactions are initiated with a call to the transaction/_create API - various validations are carried out to ensure the sanctity of the request.

• The response includes a generated transaction id and a redirect URL to the payment gateway itself.

• Various validations are carried out to verify the authenticity of the request and the status is updated accordingly. If the transaction is successful, a receipt is generated for the same.

Payment Flow

Reconciliation

• Reconciliation is carried out by two jobs scheduled via a Quartz clustered scheduler.

• The early reconciliation job is set to run every 15 minutes [configurable via app properties] and aims at reconciling transactions created 15 - 30 minutes ago and are in a PENDING state.

• The daily reconciliation job is set to run once every day and aims at reconciling all transactions that are in the PENDING state, except for the ones created 30 minutes ago.

Extensions

• Axis, Phonepe and Paytm payment gateways are implemented.

Configuration Details

The following properties in the application.properties file in egov-pg-service have to be added and set to default value after integrating with the new payment gateway. In the below table properties for AXIS bank, payment gateway is shown the same relevant property needs to be added for other payment gateways.

Deployment Details

1. Deploy the latest version of egov-pg-service

2. Add pg service persister yaml path in persister configuration

Integration Details

Integration Scope

The egov-pg-service acts as communication/contact between eGov apps and external payment gateways.

Integration Benefits

• Record of every transaction against a bill.

• Record of payment for multiple bill details for a single consumer code at once.

Steps to Integration

1. To integrate, host of egov-pg-service should be overwritten in helm chart

2. /pg-service/transaction/v1/_create should be added in the module to initiate a new payment transaction, on successful validation

3. /pg-service/transaction/v1/_update should be added as the update endpoint to updates an existing payment transaction. This endpoint is issued only by payment gateways to update the status of payments. It verifies the authenticity of the request with the payment gateway and forwards all query params received from a payment gateway

4. /pg-service/transaction/v1/_search should be added as the search endpoint for retrieving the current status of a payment in our system.

Reference Docs

Doc Links

API List

(Note: All the APIs are in the same postman collection, therefore, the same link is added in each row)

Overview

Whenever any user logs an authorization token and a refresh token is generated for him. Using the auth token the client can make the rest API calls to the server to fetch data. The auth token has an expiry period. Once the auth token is expired it cannot be used to make API calls. The client will have to generate a new authorization token. This is done by authenticating the refresh token with the server which then generates and sends a new authorization token to the client. The refresh token avoids the need for the client to again login whenever Auth token expires.

Refresh token also has an expiry period and once it gets expired it cannot be used to generate a new authorization token and the user will have to log in again to get a new pair of authorization tokens and refresh tokens. Generally, the duration before the expiry of the refresh token is much longer compared to that of auth token. If the user logs out of the account both Auth token and the refresh token will become invalid.

Variable List

Environment variables to configure expiry time

API Details

`

Overview

Goal: To onboard developers onto the XState-Chatbot code base so that they can modify existing flows or create new ones.

This document sticks to explaining the chatbot's core features and does not dive into the use cases implemented by the chatbot.

Chatbot Fundamentals

This chatbot solves the basic form-filling aspect of a chat flow. By collecting the information from the user, an API call is made to the rainmaker backend services to fulfil the user requirements. It uses the concept of (similar to State Machines) to maintain the state of the user in a chat flow and store the information provided by the user. is a JavaScript implementation of StateCharts. All chat flows are coded inside the XState framework.

This chatbot does not have any Natural Language Processing component. In the future, we can extend the chatbot to add such features.

Basic Introduction to XState

XState is a JavaScript implementation of StateCharts. There is detailed documentation available to study XState. Some concepts of XState used in the Chatbot are listed below. Basic knowledge of these concepts is necessary. It can also be learned while going through the chat flow implementation of pilot use cases in PGR and Bills.

2. Actions

   • onEntry

Few tips about using XState. These have been followed throughout the pilot chat flows.

1. To move to any state which is not at the same hierarchical level, assign a unique ID value. If it has an ID value, address it using the # qualifier in the target attribute.

2. Since the ID should be unique, make sure there are no multiple states having the same ID value. If there is a duplicate, the application will not function as expected.

3. Any actions (like onEntry) should be surrounded by assign.

This includes almost all functions except the guard condition code snippets.

Pre-requisites

• NodeJS

• PostgreSQL

• Kafka_(optional)_

Key Functionalities

• Build a chat flow to facilitate a user to interact with rainmaker modules

• Link a chat flow with backend services

Deployment Details

1. Deploy the latest version of xstate-chatbot

2. Configure /xstate-chatbot to be a whitelisted open endpoint in zuul

Chat Flow

All the interactions with the user - sending a message to the user and processing an incoming message from the user are coded as a state in the State Machine. It would be a nice start to test any chat flow with the supplementary react-app provided for the developers to execute the state machine locally. (Please follow the guidelines in the README of the react-app.)

We have applied some standard patterns to code any chat interaction. Please try to follow these patterns to code any new chat flow. These patterns are explained below. You can also study those by browsing through the code of the pilot use cases of PGR and Bills.

1. The chat states would only include dialogue-specific code. Any code related to the backend service should be written as a part of a separate …-service.js file.

2. Any code that does not include any asynchronous API call can be written as a part of the onEntry function or action.

3. If the function needs to make an API call, that would have to be written with the invoke-on Done pattern. The asynchronous function should be written as a part of the service file. The consolidated data returned by it can be processed in the state of the dialogue file.

4. Helper functions are written indialog.jsfile. It is advised to use those functions as much as possible rather than writing any custom logic in dialogue files.

Scaffolding

Apart from the chat flow and its backend service API calls, a few other components are present in the project. These components do NOT need to be modified to code any new chat flow or changed for an existing chat flow. These components with a short description for each are listed below:

1. Session Manager: It manages the sessions of all the users on a server. It will store the user’s state in a datastore, update it, and read it when any new message is received on the server. Based on the state of the user, it creates a state machine and sends the incoming message event to the state machine. It sanctifies the state (any sensitive data like the name and mobile number of a user are removed) before storing the state in the datastore.

2. Repository: It is the datastore where the states of the users get stored. To reduce dependency, an in-memory repository is also provided, which can be used by configuring an environment variable. So to run the chatbot service, PostgreSQL isn’t a hard dependency, but it is advisable to use the PostgreSQL repo provider.

3. Channel Provider: There can be many different WhatsApp Providers. Any one of the providers will be configured to be used. A separate console WhatsApp Provider is present for the developer to test the chatbot server locally. Postman collection to mimic receiving messages from a user to the server is present in the project directory.

4. Localization: Every message to be sent to the user is stored within the chatbot. Localization service is not being used. These messages are present near the bottom of the dialogue files. A separate localization-service.js is provided to get the messages for the localization codes for the messages that are not owned by the chatbot. For example, the PGR complaint types data is under the ownership of the PGR module, and the messages for such can be fetched from the egov-localization-service using the functions provided in the localization-service.js.

5. Service Provider: To ease the initial dialogue development, instead of coding API calls to the backend services, we can configure the chat flow to use a dummy service. This can be configured using an environment variable and modifying the service-loader.js file.

6. Telemetry: Chatbot logs telemetry events to a Kafka topic. (Any sensitive data will get masked before indexing the events onto ElasticSearch by egov-indexer.) The following events get logged:

   1. Incoming message

   2. Outgoing message

   3. Transition of state

Overview

In the existing version of the chatbot, for the PGR complaint creation feature, the user has to select the city from a drop-down menu by visiting the mSeva website. This significantly reduces user convenience as the user is required to constantly switch pages. To overcome the above inconvenience, the nlp-engine service is used. The service has an algorithm that uses fuzzy matching and pattern recognition to recognise the city provided by the user as input. Based on the user input, the cities having the highest match ratio with the input are being returned as the output list. A list comprising all the city names in English, Punjabi and Hindi was used as a reference tool for this service.

Pre-requisites

Before you proceed with the documentation, make sure the following pre-requisites are met -

• Python.

• egov-mdms service is running and all the data related to the service are added to the MDMS repository.

• egov-running service is running.

Key Functionalities

• Provides city fuzzy search feature which returns the list of cities having the highest match ratio with the input.

• City fuzzy search can support input data in English, Hindi and Punjabi language.

• Provides locality fuzzy search feature which returns the list of localities having the highest match ratio with the input.

Interaction Diagram

Deployment Details

2. Deploy the latest version of nlp-engine service.

3. Whitelist the city and locality fuzzy search APIs.

Integration

Integration Scope

The nlp-engine service is used to locate user city and locality by using fuzzy string matching and pattern recognition.

Integration Benefits

• Currently integrated into the chatbots for locating user city and locality for complaint creation use case.

• This feature functionality can be extended for the other entities and can be used for a fuzzy search of those different entities.

Steps to Integration

1. To integrate, the host of nlp-engine service module should be overwritten in the helm chart.

2. /nlp-engine/fuzzy/city should be added as the fuzzy search endpoint for a city search.

3. /nlp-engine/fuzzy/locality should be added as the fuzzy search endpoint for locality search.

Reference Docs

Doc Links

API List

(Note: All the APIs are in the same postman collection therefore the same link is added in each row)

Overview

The URL shortening service is used to shorten long URLs. There are scenarios when we want to avoid sending very long URLs to the user via SMS, Whatsapp etc. This service compresses the URL.

Pre-requisites

Before you proceed with the configuration, make sure the following pre-requisites are met -

1. Prior Knowledge of Java/J2EE

2. Prior Knowledge of SpringBoot

3. Prior Knowledge of REST APIs and related concepts like path parameters, headers, JSON etc.

Key Functionalities

1. Compress long URLs.

2. Converted short URLs contain id, which is used by this service to identify and get longer URLs.

Deployment Details

• Deploy the latest version of the URL Shortening service.

API Details

a) POST /egov-url-shortening/shortener

Receive long URLs and converts them to shorter URLs. Shortened URLs contain URLs to the endpoint mentioned next. When a user clicks on shortened URL, the user is redirected to a long URL.

b) GET /{id}

The shortened URLs contain the path to this endpoint. The service uses the id used in the last endpoint to get a long URL. In response, the user is redirected to the long URL.

Reference Docs

Doc Links

Objective: This document aims to facilitate communication between the software developers and whoever is localising the chatbot messages. The goal is to make it clear and unambiguous.

Click on the link to the google sheet below to access all the messages with the codes:

to download the file.

Message Localisation Details

Project Structure

The project is organised such that all the messages are contained within the files present inside the /machine directory. /service directory, which is present inside it, also includes files that could contain localization messages.

Guidelines to be followed by developers:

(According to the standard pattern followed in the project, all the localization messages will be present near the end of the file in a JavaScript object named “messages”.)

Developers will be the ones first filling up the sheet with codes (and the English version of the messages). Below are the guidelines to be followed when writing the codes in the sheet:

1. The standard separator to be used is .(dot)

2. The first part is the filename—Eg: “pgr.”, when the filename is pgr.js.

3. Use “service.” as a prefix when the file is present inside the /service directory.

   • In the /service directory, filenames are like egov-pgr.js

   • For localization messages contained in those files, instead of writing “egov-pgr” just write “pgr”

   • So the prefix for such files would be “service.pgr.”

4. All the message bundles would be present in the “messages” object near the end of the file. They have been organized in a pattern in the JS object like fileComplaint.complaintType2Step.category.question

   • The corresponding localization code for such a message bundle in the sheet would be “pgr.fileComplaint.complaintType2Step.category.question”, where the first “pgr.” is added as the prefix for the file name.

Message Writing Guidelines

Once the localization codes have been written correctly (and the English version of the messages) in the sheet, it is easy to add the new message in the corresponding new column.

Some guidelines to follow when adding new messages:

1. The parameter names are written within {{}} (double curly brackets).

2. The content inside these curly brackets should be written in English even when writing messages for any new language.

Overview

The is a revamped version of the , which provides functionality to the user to access PGR module services like file complaints, track complaints, notifications from whats app, It allows the user to view receipts and pay the bills for Property, Trade Licence, FireNOC, Water and Sewerage and BPA service module.

Key Functionalities

• File PGR complaint

• Track PGR complaint

• Support images when filing complaints

• Notifications to citizens when an employee performs any action on the complaint

• Allow users to search and pay bills of different modules.

• Allow users to search and view receipts of different modules.

• Allow users to change the language of their choice to have a better experience.

• Put user interactions on an elastic search for Telemetry.

Integration Details

Integration Scope

The XState chatbot can be integrated with any other module to improve the ease of search and view bills/past payment receipts and to improve speed and convenience for bill payment. It can be integrated with the PGR module for easiness of creation and tracking of the complaint.

Integration Benefits

• Increase in convenience and ease of making the bill payment.

• Increase in no. of users opting for online payment.

• Improvement in demand collection efficiency

• Creating an additional channel for payment.

• Remove dependency on mobile/web apps or counters.

Integration Approach

Integration of New Whatsapp Provider

Whatsapp provider is a third-party service that works in the middle of a user's WhatsApp client and XState-Chatbot server. All messages coming/going to/from the user pass through the WhatsApp provider. Chatbot calls WhatsApp provider to send messages to the user. When a user responds with any WhatsApp message the WhatsApp provider calls Chatbot service’s configured endpoint with details ex:- the user sent message, sender’s number etc.

If any new WhatsApp provider is to be used with a chatbot, code must be written to convert the provider’s incoming messages to the format that the chatbot understands and also final output from the chatbot should be converted to the WhatsApp provider’s API request format.

Currently, the XState-Chatbot service is using ValueFirst as the WhatsApp Provider. This will require provider-specific environment variables to be configured. If the provider changes then, all these environment variables will also change. A few of those environment variables are stored as secrets, so these values need to be configured in env-secrets.yaml.

As this is a revamped version of the chatbot service, all of the secrets should already be present. There is no need to create new secrets.

Integration of PGR complaint feature in XState-Chatbot

Configuration Details

Configuration of PGR version in chatbot

• pgrVersion

• pgrUpdateTopic

To configure PGR v2 in XState chatbot then pgrVersion should be ‘v2' and pgrUpdateTopic should be 'update-pgr-request’.

Configuration of city and locality search with nlp-search engine

Adding Information Image in PGR complaint creation and Open search information image

To configure the filestoreid for an informational image follow the steps mentioned below

1. Download the images from the section Information Images for PGR and Open Search

For example:

a) if supportedLocales: process.env.SUPPORTED_LOCALES || 'en_IN,hi_IN'

then valuefirst-notification-resolved-templateid: "12345,6789"

b) if supportedLocales: process.env.SUPPORTED_LOCALES || 'hi_IN,en_IN'

then valuefirst-notification-resolved-templateid: "6789,12345"

(Note: Both lists should not be empty - they must contain at least one element)

Configuration of push notification template messages with a button

Template messages with buttons are maintained in the same way as described in the previous section (Configuration of push notification template messages)

There are two types of button message

• Quick Reply

• Call To Action

The Value First document below provides more details.

Integration of Bill Payment and Receipt Search feature in Xstate-Chatbot

Configuration of module for Bill payment and Receipt search

For example: If the applicable modules are defined in the variable - bill-supported-modules: "WS, PT, TL" -the defined modules will appear in the bill payment and receipt search. In the given example, the modules Water and Sewerage, Property Tax, and Trade license will appear for bill payment and receipt search.

Configuration of Telemetry File

Searcher config file:

Cron job mdms entry:

Localisation for PGR service

Information Images for PGR and Open Search

Reference Docs

Doc Links

API List