A basic knowledge of AWS is required before setting up an AWS account. Below are the key pre-requisites:-

Refer to the details here.

Follow the steps in this doc to setup the AWS account.

Currently, we are using the LetEncrypt SSL certificate which is free. However, there is a catch here. The LetsEncrypt certificate is valid only for 3 months (90 days). Post 90 days this has be renewed manually. There are few paid ones available globally.

Overview

Follow the steps provided on this page to configure domains or subdomains registry and mapping CNAME.

Steps

Create a CNAME (Canonical Name) entry in your domain's DNS settings and point it to the AWS load balancer or gateway URL. The external IP for the domain is provided by the AWS load balancer or gateway.

Introduction

The domain name is the address through which the internet users can access the website rather than entering the whole IP address in the search bar of the browser.

This domain name is ideally chosen by the state/client since it is a product that has to be used for/by them.

Data Table

Following is the table through which the information can be shared.

Note: The data given in the table is sample data.

Process

Since all state governments/clients prefer to host the websites on their servers, this activity is ideally done by them.

Data Definition

Steps To Fill Data

Following are the steps which are to be followed:

1. Download the data template attached to this page.

2. Get a good understanding of all the headers in the template sheet, their data type, size, and definitions by referring to the ‘Data Definition’ section of this document.

3. In case of any doubt, please reach out to the person who has shared this template with you to discuss and clear your doubts.

4. If the state agrees to host the website on their server, provide them with the 2 columns mentioned in the attached template.

5. If the state disagrees to host on their server, then a domain name has to be purchased by any of the external vendors and the EXTERNAL-IP address has to be mapped with them.

6. Verify the data once again by going through the checklist and making sure that each point mentioned in the checklist is covered.

Checklist

This checklist covers all the activities that are common across the entities.

Attachments

Following is the attached configurable data template in case the state is doing the required activities.

1. Configurable Data Template - Domain Name Configuration

1. Sample Configurable Data - Domain Name Configuration

Overview

Follow the steps provided on this page to create and add users on the mGramSeva platform once the installation is complete.

Pre-requisites

Ensure the Postman utility is installed to run the following scripts. If not, on the local machine.

Create Users - Steps

There are two methods to create users - either through API or through port-forwarding. To create users through port-forwarding refer .

Follow the steps given below to create different types of users through the API.

There are primarily three different types of users as listed below:

• Super User

• Anonymous User

• System User

Super User - A superuser is a privileged user account with elevated access rights in a computer system or application. It is typically reserved for administrators or trusted personnel and grants them full control and unrestricted access to all system resources. Superusers are necessary to manage and maintain the system, perform critical tasks, and troubleshoot issues efficiently.

A Superuser is created using the createnovaildate API. Below is the curl given for creating a superuser.

Steps to follow:

1. Import the curl given below in Postman.

2. Refresh the authorisation token.

3. Provide User data as per requirements. This API will create a Super User in production. To add users in any other environment change the URL.

The parameters - userName , name , gender, mobileNumber , tenantId , and password can be changed as per requirements.

Anonymous User -An anonymous user is a generic or unauthenticated user account that does not require login credentials to access certain parts of a system or website. These accounts are essential for providing basic access to public information or services without requiring user registration. They are commonly used to ensure accessibility for a wide audience and encourage user interaction while preserving user privacy. These are used when the system is accessing non-authentication links such as bills and payment receipts.

Creating an anonymous user is the same as creating a superuser. The only difference is to change the name and code in roles. The API below is used to create an Anonymous User in production.

System User - Creating a system user is the same as creating a superuser and anonymous user. The only difference is to change the name and code in roles.

Overview

This page provides step-by-step details on setting up a git repo for code, configs, V1 MDMS, and Infra As Code.

Steps

Fork the following repos that contain the master data and default configurations. Customize the data (master data, ULB, Tenant details, Users, etc) as per specific implementation requirements in the respective GitHub organization accounts.

Follow the steps given below to setup the git repository,

• ​ both the , and repos into your GitHub organization account.

• Create a , and generate an ssh authentication key (and .

• Enable new GitHub users to access the forked repos.

• Add the ssh private key generated in the previous step to the within the git-sync section.

• Update the services in the git-sync repository by specifying the forked repository and branch in the file.

• Update the deployment configuration details for the below as per your specifications:

  1. Number of replicas/scale of each service (depending on whether dev or prod load)

  2. You must update the SMS gateway, email gateway, and payment gateway details for the notification and payment gateway services, etc.

  3. Update the config and MDMS GitHub repos wherever marked.

  4. Update GMap key (In case you are using Google Map services in your PGR, PT, TL, etc)

  5. Create one private S3 bucket for Filestore and one public bucket for logos. Add the bucket details respectively and create an IAM user with the s3 bucket access. Add IAM user details to .

  6. URL/DNS on which DIGIT will be exposed.

  7. SSL certificate for the above URL.

  8. Any specific endpoint configurations (Internal/external).

Overview

To enable any municipal service in a fresh environment and for the first time, we require a basic idea of what DIGIT does and the generic services required to set it up.

DIGIT is an open-source, customizable platform that lends itself to extensibility. New modules can be built on top of the platform to suit new use-cases or existing modules can be modified or replaced. To enable this, in addition to deploying DIGIT, a CD/CI pipeline has to be set up. CD/CI pipelines enable the end users to automate & simplify the build/deploy process.

Find more details on DIGIT and platform deployment here.

Core Services

DIGIT platform comprises several core services that serve as the platform backbone. Some of the key core services are listed below:

1. Workflow Service

2. Location Service

3. User Service

4. Access Control Service

5. PDF Service

6. Payment Service

7. MDMS Service

8. Indexer Service

9. Persister Service

10. ..among multiple others

Each microservice has a distinct function explained in the provided documentation links.

Developers can activate specific municipal services easily once the platform and its terminologies are well understood.

Overview

Localization is the process of adapting a software application, website, or content to different languages and regions, making it accessible and user-friendly for diverse audiences. It involves translating text, adapting graphics, and configuring settings to suit the cultural and linguistic preferences of a specific locale.

Search API For Localization In mGramSeva

To retrieve localization messages in mGramSeva, use the Search API given below. This API allows you to search for messages based on parameters like locale, tenantId, and apiId. Here is an example using cURL:

You can customize the parameters such as locale (en_IN, hi_IN, pn_IN) and tenantId to search for messages in different languages and environments. Change the URL to search in any other environment. The current API is specific for UAT environment.

curl --location 'https://mgramseva-uat.psegs.in/localization/messages/v1/_search?locale=en_IN&tenantId=pb' \
--header 'authority: mgramseva-dwss.punjab.gov.in' \
--header 'accept: */*' \
--header 'accept-language: en-GB,en;q=0.9' \
--header 'content-type: application/json; charset=utf-8' \
--header 'cookie: _ga=GA1.1.748766720.1676369982; _ga_DDHVQCKC6W=GS1.1.1676369981.1.0.1676369984.0.0.0' \
--header 'origin: https://mgramseva-dwss.punjab.gov.in' \
--header 'referer: https://mgramseva-dwss.punjab.gov.in/mgramseva/selectLanguage' \
--header 'sec-ch-ua: "Not_A Brand";v="99", "Google Chrome";v="109", "Chromium";v="109"' \
--header 'sec-ch-ua-mobile: ?1' \
--header 'sec-ch-ua-platform: "Android"' \
--header 'sec-fetch-dest: empty' \
--header 'sec-fetch-mode: cors' \
--header 'sec-fetch-site: same-origin' \
--header 'user-agent: Mozilla/5.0 (Linux; Android 10; SM-G981B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.162 Mobile Safari/537.36' \
--data '{
    "apiId": "mgramseva",
    "ver": 1,
    "ts": "",
    "action": "_search",
    "did": 1,
    "key": "",
    "msgId": "20170310130900|en_IN",
    "authToken": "",
    "userInfo": null
}'

Upsert API For Localization In mGramSeva

The Upsert API allows users to update or insert new localization messages into mGramSeva. This involves refreshing the authentication token and providing details like code, message, module, and locale. Here is an example using cURL:

In this example, you can customize the "code," "message," "module," and "locale" parameters to specify the localization details you want to upsert. Make sure to update the authentication token for security purposes.

curl --location 'https://mgramseva-uat.psegs.in/localization/messages/v1/_upsert' \
--header 'Content-Type: application/json' \
--data '{
    "RequestInfo": {
        "apiId": "Mihy",
        "ver": "1.0",
        "ts": "",
        "action": "create",
        "did": "1",
        "key": "abcdkey",
        "msgId": "20170310130900",
        "requesterId": "",
        "authToken": "7d569ce1-4b5c-4f4c-be93-4af7265890f3"
    },
    "tenantId": "pb",
    "messages": [
         {
            "code": "CORE_DOWNLOAD",
            "message": "Download",
            "module": "mgramseva-common",
            "locale": "en_IN"
        }
    ]
}'

Overview

This page provides the steps to follow to create a Git account in the client name.

Steps

To create a Git account in the client name, follow the steps below:

1. Register the client on a Git hosting platform such as GitHub, GitLab, or Bitbucket by providing their email address, choosing a username, and setting a secure password.

2. Once the account is set up, they can start using Git to manage their code repositories and collaborate on software development projects with ease.

Overview

This page provides a clear and concise guide for automating user creation in mGramSeva. It allows you to efficiently create users and manage their roles in the system.

Follow the steps provided on this page to create users for mGramSeva using a Python script. The process involves preparing an Excel sheet with user information, configuring the Python script, and executing it.

Pre-requisites

1. Python script for creating users for mGramSeva.The sample format of the Python script is attached below.

2. Excel sheet containing user data. The sample format of the Excel sheet is attached below. Make sure to populate the data in the same format.

   • Columns: tenant name, mobile no, father name, gender, date of birth (dd/mm/yyyy), type, and ward (fixed to "ward 1").

   • Types: Sarpanch, Secretory, Revenue Collector, Division User or State User

   • Roles for Sarpanch: COLLECTION_OPERATOR, EXPENSE_PROCESSING, BULK_DEMAND_PROCESSING, DASHBOARD_VIEWER, GP_ADMIN.

   • Roles for Secretory: EXPENSE_PROCESSING, BULK_DEMAND_PROCESSING, DASHBOARD_VIEWER, GP_ADMIN, COLLECTION_OPERATOR.

   • Roles for Revenue Collector: COLLECTION_OPERATOR, DASHBOARD_VIEWER.

   • Roles for Division User: HRMS_ADMIN, DIVISION_ADMIN

   • Roles for State User: HRMS_ADMIN, STATE_ADMIN

Steps

1. Prepare the Excel Sheet:

   Create an Excel sheet with the following columns and data in the given format:

   • Tenant Name (in lowercase)

   For State User tenant name will be pb

   • Mobile Number

   • Father's Name (Mandatory, use "NA" if not available)

   • Gender (M/F - this data is mandatory)

   • Date of Birth (in the format dd/mm/yyyy)

   • Type (Sarpanch, Secretory, Revenue Collector, Division User or State User)

   • Roles

     Based on the User Type, set corresponding roles:

     • Sarpanch: COLLECTION_OPERATOR, EXPENSE_PROCESSING, BULK_DEMAND_PROCESSING, DASHBOARD_VIEWER, GP_ADMIN

     • Secretary: EXPENSE_PROCESSING, BULK_DEMAND_PROCESSING, DASHBOARD_VIEWER, GP_ADMIN, COLLECTION_OPERATOR

     • Revenue Collector: COLLECTION_OPERATOR, DASHBOARD_VIEWER

     • Division User: HRMS_ADMIN, DIVISION_ADMIN

     • State User: HRMS_ADMIN, STATE_ADMIN

   • The 'Boundary' should be set to "Ward 1" as per mGramSeva standards.

2. Run the Python Script:

   • Open the Python script.

   • Provide the following information within the script:

     • Host URL: Specify the target environment (prod, qa, or uat).

     • Username and Password: As per your host URL.

     • Path to the Excel file: Ensure the Excel file is in the same location as the script.

   • Execute the script.

3. Post-Execution:

   • Do not open the Excel file until the script has completed its task.

   • After the script finishes, open the Excel file to review the results.

   • The Excel file will contain two columns:

     • User ID: If successful, the ID will be present.

     • Status: Will indicate either "Success" or "Failure." If failed, the reason for failure will be provided.

Overview

This page provides step-by-step instructions for using a Python script to create consumers for mGramSeva. Follow these guidelines to load consumer data into the system using the Python script provided.

Steps

Step 1: Prepare Excel Sheet

Before running the script, ensure you have a properly formatted Excel sheet. The sheet should include the following columns:

• Consumer Name (Mandatory, use "NA" if not available)

• Gender (Male/Female)

• Father Name (Mandatory, use "NA" if not available)

• Mobile Number (Mandatory)

• Old Connection Number

• Property Type

• Service Type (till now in we have Non-metered only for data loading)

• Ward (Always set to "Ward 1")

• Meter Reading (If available, use provided date; otherwise, default to "12/01/2022")

• GPWSC Name

• Arrears

• Previous Reading ((if arrears and previous reading are not given, write '0')

Ensure the format of the meter reading matches the provided sample format given in excel file below, as incorrect formatting may lead to loading failures.

2. Python Script Configuration

Edit the Python script with the following details:

• Set the host URL based on whether it's for production, QA, or UAT.

• Provide the username and password corresponding to your host URL.

• Specify the path where your Excel file is stored. It is recommended to store the Excel file in the same location as your Python script.

3. Running the Script

Execute the Python script after configuring the host URL, username, password, and file path. The script will load data into mGramSeva based on the information provided in the Excel sheet.

4. Post-Execution Steps

Do not open the Excel file until the script completes its task. After completion, open the Excel file to check the status. The status will indicate whether the operation was successful or if there was a failure. If there's a failure, refer to the provided reason for further investigation and resolution.

Introduction

This page provides step-by-step instructions for creating a consumer in the mGramSeva system using two API calls. The first API call is for creating a property, and the second API call is for making a connection for the consumer.

Pre-requisites

Before proceeding with the given tasks, ensure the following prerequisites are met:

1. Authentication Token (authToken): Obtain a valid authentication token for the desired environment. This token is necessary to authenticate and authorize your requests.

2. API Endpoints: Ensure you have access to both APIs required for creating a property and a consumer. Make sure you have the correct API documentation or information about the endpoints, request payloads, and any required headers.

3. Postman: If you don't have Postman installed, download and install it. Import collection in Postman. Make sure you change the URL as per your requirements.

Steps

Follow the steps given below to create consumers using either Property Create API or Consumer Create API.

1. Property Creation API

Here's a step-by-step guide:

1. Locate the Property Creation API:

   • Open the Postman collection you imported.

   • Find the request corresponding to the Property Creation API. It might be named something like "Create Property" or similar.

2. Set Request Parameters:

   • Review the request parameters for creating a property.

   • For metered connections, provide values for initialMeterReading, meterReading, meterId, and previousReading. Set them to null if not applicable.

   • Set ConnectionType to "Metered" for metered connections and "Non_Metered" for non-metered connections.

   • Ensure that oldConnectionNo is unique every time you create a property.

3. Execute the Request:

   • Click on the "Send" button to execute the request.

   • Review the response to confirm that the property has been created successfully.

4. Copy Property ID:

   • In the response, you should find the propertyId field. Copy the value of propertyId as this will be needed for subsequent steps.

Now, you have successfully created a property, and you have the propertyId copied for future use. Ensure to follow any additional instructions provided in the Postman collection or the API documentation.

2. Consumer Creation API

Follow the steps below to create a consumer using the Consumer Creation API from the Postman collection:

1. Locate the Consumer Creation API:

   • Open the Postman collection.

   • Find the request corresponding to the Consumer Creation API. It may be named "Create Consumer - Metered" for metered connections or "Create Consumer - Non-Metered" for non-metered connections.

2. Set Request Parameters:

   • Review the request parameters for creating a consumer.

   • For metered connections, provide values for initialMeterReading, meterReading, meterId, and previousReading. Set them to null if not applicable.

   • Set ConnectionType to "Metered" for metered connections and "Non_Metered" for non-metered connections.

   • Ensure that oldConnectionNo is unique every time you create a consumer.

   • Use the propertyId obtained from creating the property as instructed in the previous step.

3. Execute the Request:

   • Click on the "Send" button to execute the request.

   • Review the response to ensure that the consumer has been created successfully.

By following these instructions and providing the necessary details, you should be able to successfully create a consumer with a property and connection in the mGramSeva system. Ensure that you follow any additional guidelines or instructions provided in the Postman collection or API documentation.

Overview

This page provides a comprehensive guide on using the CreateNovaildate API to create users with specific roles based on their responsibilities within the system. Adjust the parameters and roles as needed for your specific requirements.

Steps

The API allows users to create a new user with specified details that include username, name, gender, mobile number, activation status, user type, tenant ID, and password. Refer to the details available below.

Additionally, users can be assigned specific roles based on their responsibilities.

Request Parameters

1. username (string): User's unique username.

2. name (string): Full name of the user.

3. gender (string): Gender of the user.

4. mobileno (string): User's mobile number.

5. active (boolean): User's account status (true for active, false for inactive).

6. type (string): It will be EMPLOYEE only.

7. tenantid (string): User's tenant ID.

8. password (string): User's password.

9. Roles: Roles determine the permissions and responsibilities assigned to a user.

The available roles are as follows:

Roles for Sarpanch

• COLLECTION_OPERATOR

• EXPENSE_PROCESSING

• BULK_DEMAND_PROCESSING

• DASHBOARD_VIEWER

• GP_ADMIN

Roles for Secretary

• EXPENSE_PROCESSING

• BULK_DEMAND_PROCESSING

• DASHBOARD_VIEWER

• GP_ADMIN

• COLLECTION_OPERATOR

Roles for Revenue Collector

• COLLECTION_OPERATOR

• DASHBOARD_VIEWER

Roles for Division User

• HRMS_ADMIN

• DIVISION_ADMIN

Roles for State User

• HRMS_ADMIN

• STATE_ADMIN

To assign roles to a user, include the desired roles in the roles section of the request.

PROFILE_UPDATE role is available for every user to update existing roles.

Overview

mGramSeva's Master Data Management System () is organized into several folders, each containing essential JSON files that define various aspects of the application's configuration. This documentation provides an overview of the key folders and their respective files, along with a description of the data contained within each file.

Steps

1.

This folder contains the actions-test.json file, which defines various API endpoints along with their configurations.

• id: Unique identifier for the API endpoint. Increase id with respect to id present in action-test.json file.

• name: Name of the endpoint.

• url: URL of the API endpoint.

• Other things : As per your specific requirements.

This folder contains the roleactions.json file, which associates roles with action IDs.

• rolecode: Code representing the role.

• actionid: Action ID associated with the role, linking to entries in actions-test.json.

• actioncode: Additional code for the action if needed.

• tenantId: Tenant ID associated with the role.

This folder contains the roles.json file, defining roles in the system.

• code: Code representing the role.

• name: Name of the role.

• description: Description of the role.

This folder contains various JSON files related to billing services.

4.1 BusinessService.json

Defines business services, such as expenses like electricity bills and salaries.

• businessService: Identifier for the business service.

• code: Code representing the business service.

• collectionModesNotAllowed: Collection modes not allowed for the service.

• partPaymentAllowed: Indicates whether part payment is allowed.

• isAdvanceAllowed: Indicates whether advance payment is allowed.

• isVoucherCreationEnabled: Indicates whether voucher creation is enabled.

• isActive: Indicates whether the service is active.

• type: Type of the service.

4.2 PaymentService.json

This file, located in the billingservice folder, provides configurations for payment services within the Billing Service module.

• tenantId: The identifier for the tenant associated with the configuration.

• moduleName: The name of the module, in this case, "BillingService."

• PaymentService: An array containing configurations for different payment services.

Payment Service Configuration:

• businessService: Identifier for the business service.

• code: Code representing the payment service.

• collectionModesNotAllowed: Array specifying modes of payment not allowed for this service.

  • "DD": Demand Draft

  • "CHEQUE": Cheque

  • "CARD": Card

  • "OFFLINE_NEFT": Offline NEFT

  • "OFFLINE_RTGS": Offline RTGS

  • "POSTAL_ORDER": Postal Order

  • "ONLINE": Online

• partPaymentAllowed: Indicates whether part payment is allowed for this service.

• isAdvanceAllowed: Indicates whether advance payment is allowed for this service.

• demandUpdateTime: Time interval (in milliseconds) for updating demands.

• isVoucherCreationEnabled: Indicates whether voucher creation is enabled for this service.

• billGineiURL: URL for generating bills using Bill Genie.

• isBillAmendmentEnabled: Indicates whether bill amendment is enabled for this service.

This configuration specifies the payment modes not allowed for the "ws-services-calculation" business service, whether part payment and advance payment are allowed, the demand update time, voucher creation status, Bill Genie URL, and bill amendment status.

4.3 TaxHeadMaster.json

This file is responsible for defining the various charges and taxes which are going to be configured in the application.

4.4 TaxPeriod.json

This file is used to define the number of financial years which are supported in each tax head.

This folder contains various JSON files related to ws-services-masters.

This folder contains various JSON files related to property tax.

This folder contains expense type in JSON format.

All (1 to 8 points) are state-level changes.

For each tenant, there is a unique folder containing three subfolders, each with its specific configuration files.

1. businessservice.json - Billing Service Configuration

This file, located in the billing service folder, provides tenant-specific configurations for the Billing Service module. It is similar to the global BusinessService.json configuration but is specific to the tenant.

2. boundary-data.json - Location Boundary Data Configuration

This file, located in the egov-location folder contains boundary data specific to the tenant.

Details of the structure and content of this file would be specific to the actual data in the system. Please refer to the specific boundary-data.json file for detailed information.

3. WCBillingSlab.json - Water Connection Billing Slab Configuration

This file, found in the ws-services-calculation folder defines billing slabs for water connection based on building type and connection type.

• id: Unique identifier for the billing slab.

• buildingType: Type of the building (e.g., RESIDENTIAL).

• connectionType: Type of connection (e.g., Metered).

• calculationAttribute: Attribute used for calculation (e.g., Water consumption).

• minimumCharge: Minimum charge for the billing slab.

• slabs: Array defining the billing slabs, including from, to, charge, and meterCharge.

This configuration is used to determine rates for water consumption based on the specified billing slab criteria.

Overview

This page provides details on how to register the SMS templates with the specified TEMPLATE ID for each Localization key and append the TEMPLATE ID at the end of the message in the Localization system.

Steps

To register the provided SMS templates with a specific TEMPLATE ID for each Localization key and append the TEMPLATE ID at the end of the message

The sample SMS messages in the table below have to be registered with a specific TEMPLATE ID (Eg.'100700746377980') for each Localization key.

Append the TEMPLATE ID at the end of the message.

Push the SMS templates in Localisation.

Overview

This page provides the steps to follow to create a workflow in mGramSeva.

Here is the reference to workflow service of DIGIT. You can refer here and understand more.

For creating workflow in mgramseva below are the steps-

Steps

Workflow Creation in mGramSeva

Follow these steps to create a workflow in mGramSeva:

1. Check Existing Workflow:

   • Utilize the provided Postman collection that includes workflow create and search APIs.

   • Use the search API to check if the workflow for the specified state already exists.

2. Workflow Creation:

   • If the workflow is not present, proceed to create it using the create API.

   • Ensure to provide the necessary details in the userInfo section, give superuser information.

   • Adjust parameters like tenantId and roles according to your specific requirements.

3. Port Forwarding:

   • Execute port forwarding to the workflow service using the following kubectl command:

     Copy

     kubectl port-forward <pod-name> -n mgramseva

     Replace <pod-name> with the appropriate pod name.

4. Create Workflow:

   • After port forwarding, initiate the workflow creation process.

5. Search Through API:

   • Use the search API to verify that the workflow has been successfully created.

   • Adjust the search parameters as needed.

These steps ensure a smooth workflow creation process in mGramSeva. Make sure to follow each step in sequence for a seamless experience.

Overview

This page outlines the step-by-step process for using a Python script to change master rates for mGramSeva in bulk. The script reads data from an Excel file, updates the master rates, and generates a new CSV file containing the modified information. Once the script is successfully executed, changes can be pushed to the local MDMS repository on GitHub.

Pre-requisites

• Python script

• MDMS repository cloned on the local system

• Excel file with tenant names, old master rates, and new master rates

Steps

1. Prepare Excel File:

• Ensure the Excel file contains three columns: Tenant Name (in lowercase), Old Master Rate, and New Master Rate.

• If the columns are not present, add them to the Excel file.

2. Clone and Create Branch:

• Clone the MDMS repository to your local system.

• Create a new branch from the branch where you intend to make changes.

3. Update Python Script:

• Open the Python script and locate the variables:

  • updatedfile: Provide the path to your Excel sheet.

  • localFilePath: Specify the path where your MDMS repository is cloned.

  • Identify the columns in the Excel file where the Tenant Name, Old Master Rate, and New Master Rate are stored. Update the script accordingly:

uniqueVillageName = row[2].value
oldMasterRate = row[7].value
newMasterRate = row[8].value

• Run the script.

4. Script Execution:

• Do not open the Excel file during script execution.

• The script will generate a new file named new_updated_file4.csv containing information about whether rates were updated or not.

5. Verification:

• Check new_updated_file4.csv to verify if all rates were updated successfully.

6. Push Changes to Git:

• If all rates are updated, the local changes will affect the MDMS repository.

• Raise a pull request and merge changes from the Git repository.

Note:

• It is crucial not to open the Excel file while the script is running to avoid data inconsistencies.

• Ensure that the Python environment and dependencies are properly set up.

By following the steps above, you can efficiently update master rates for mGramSeva in bulk, ensuring accurate and streamlined changes to the MDMS repository.

Overview

This documentation outlines the process of setting up a new tenant in MDMS (Master Data Management System). To achieve this, it involves cloning the MDMS repository locally and utilizing a Python script that interacts with an Excel file containing essential information for the new tenant setup.

Pre-requisites

1. Clone the MDMS repository to your local machine.

2. Have the Excel file ready for reference. The structure of the Excel file is critical, and any changes must align with the specified columns. The reference to the Excel file is given below.

Steps

Python Script Configuration

1. Locate the Python script for adding a new tenant. The script can either be placed in the "tenants" folder locally or specify the full path where your "tenants.json" folder is present within the script.

2. Open the script and edit the following lines to match your requirements:

   Copy

   dataframe = openpyxl.load_workbook("Book2.xlsx")

   Replace "Book2.xlsx" with the name of your Excel file containing tenant information.

3. Specify the sheet name in your Excel file where the required data is stored.

   Copy

   dataframe1 = dataframe["Sheet1"]

Excel File Preparation

1. Ensure your Excel file adheres to the specified format. The columns must match the template provided, and any deviation may result in script failure.

2. Do not modify the column structure in the Excel sheet, as the script relies on a consistent format.

Running the Script

Execute the Python script after configuring it according to your needs. The script will process the Excel file, and upon completion, a new file named "tenants_new.json" will be generated.

Deploying to MDMS:

• Copy the generated tenants_new.json file to the MDMS repository or select and apply the updated data within MDMS as needed.

After creating a tenant in the tenants.json file we need to make a separate folder in MDMS for each tenant.