Backend Modules

The backend of the OpenIMIS system consists of several essential modules that work together to provide comprehensive functionality. Each module serves a specific purpose and contributes to the overall operation of the system. Below is the list of backend modules:

openimis-be-individual_py
openimis-be-social_protection_py
The openimis-be-social_protection_py module focuses on managing social protection-related information within the OpenIMIS system. It handles various aspects of social protection data, ensuring proper data management and processing.
openimis-be-tasks_management_py
The openimis-be-tasks_management_py module is responsible for managing tasks and activities within the OpenIMIS system. It helps streamline workflow by handling task assignment, tracking, and completion.
openimis-be-opensearch_reports_py
The openimis-be-opensearch_reports_py module provides functionalities for generating and accessing reports in the OpenIMIS system. It allows users to search and retrieve relevant reports based on specific criteria.
openimis-be-workflow_py
The openimis-be-workflow_py module is dedicated to managing data upload.
openimis-be-payment_cycle_py
The openimis-be-payment_cycle_py module is responsible for managing payment cycles within the OpenIMIS system. It handles payment-related processes, including scheduling, calculations, and disbursements.
openimis-be-calcrule_social_protection_py
The openimis-be-calcrule_social_protection_py module is specialized in managing calculation rules for social protection data within the OpenIMIS system. It ensures accurate and consistent calculation of benefits and entitlements.
openimis-be-payroll_py
Module created for payroll management. It serves as a main point for management of the benefit disbursement.
openimis-be-deduplication_py
Module created as an extension to the Individual module which allow users to remove duplication in the individuals registry based on the flexible criteria.
openimis-be-grievance_social_protection_py
Module introducing flexible grievances to the OpenIMIS. The types of the grievances as well as channels or flags can be configured by the administration.

These modules work in tandem to create a robust backend infrastructure for the OpenIMIS system, enabling efficient data management, task handling, and reporting capabilities.

Please note that the list above provides an overview of the backend modules in the OpenIMIS system. Each module may have its own set of functionalities, services, and configurations, which can be further explored through specific documentation and resources.

OpenIMIS Backend Individual Reference Module Documentation

The openimis-be-individual_py module is dedicated to handling individual references within the OpenIMIS system. It provides services and functionalities for managing individual records, including creating, updating, and deleting individual data.

Introduction

The OpenIMIS Backend Individual Reference Module is a crucial component of the OpenIMIS system. This module is dedicated to handling individual references within the system. It provides services, functionalities, and GraphQL queries related to individual and group management. The Individual Reference Module is designed to be deployed as a module of openimis-be_py, the OpenIMIS backend application.

This documentation aims to provide a comprehensive guide on how to utilize, configure, and interact with the Individual Reference Module effectively.

ORM Mapping

The module uses Object-Relational Mapping (ORM) to map data from the database to Python objects. The following ORM mappings are used:

individual_individual, individual_historicalindividual -> Individual: Represents an individual entity.
individual_individualdataSource, individual_historicalindividualdataSource -> IndividualDataSource: Represents the data source associated with an individual.
individual_individualdatasourceupload, individual_historicalindividualdatasourceupload -> IndividualDataSourceUpload: Represents data uploads associated with an individual data source.
individual_group, individual_historicalgroup -> Group: Represents a group entity.
individual_groupindividual, individual_historicalgroupindividual -> GroupIndividual: Represents the association between a group and an individual.

Developers can access and manipulate individual and group-related data using these mapped objects, which abstract away the underlying database complexities.

GraphQL Queries

The module provides several GraphQL queries to retrieve individual and group-related information:

individual: Retrieves individual data based on specified criteria.
individualDataSource: Retrieves individual data source information based on specified criteria.
individualDataSourceUpload: Retrieves individual data source upload information based on specified criteria.
group: Retrieves group data based on specified criteria.
groupIndividual: Retrieves group-individual association data based on specified criteria.

These GraphQL queries provide a flexible and efficient way to retrieve relevant individual and group data.

GraphQL Mutations

The Individual Reference Module offers GraphQL mutations to manage individual and group data. Each mutation emits default signals and returns standard error lists following the conventions of openimis-be-core_py.

List of available mutations:

createIndividual: Creates a new individual record.
updateIndividual: Updates an existing individual record.
deleteIndividual: Deletes an individual record.
createGroup: Creates a new group record.
updateGroup: Updates an existing group record.
deleteGroup: Deletes a group record.
addIndividualToGroup: Adds an individual to a group.
editIndividualInGroup: Edits an individual in a group.
removeIndividualFromGroup: Removes an individual from a group.
createGroupIndividuals: Creates multiple group-individual associations.

These mutations enable seamless management of individual and group data within the OpenIMIS system.

Services

The module provides the following services:

IndividualService: Offers methods to create, update, and delete individual records.
IndividualDataSourceService: Provides methods to create, update, and delete individual data sources.
IndividualDataSourceUploadService: Offers methods to create, update, and delete individual data source uploads.
GroupService: Provides methods to create, update, and delete group records.
GroupIndividualService: Offers methods to create, update, and delete group-individual associations.

Developers can interact with these services to perform various operations related to individual and group management.

Configuration Options

The behavior of the Individual Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

gql_individual_search_perms: Specifies the required rights to call the individual GraphQL query. (Default: ["159001"])
gql_individual_create_perms: Specifies the required rights to call the createIndividual GraphQL mutation. (Default: ["159002"])
gql_individual_update_perms: Specifies the required rights to call the updateIndividual GraphQL mutation. (Default: ["159003"])
gql_individual_delete_perms: Specifies the required rights to call the deleteIndividual GraphQL mutation. (Default: ["159004"])
gql_group_search_perms: Specifies the required rights to call the group GraphQL query. (Default: ["180001"])
gql_group_create_perms: Specifies the required rights to call the createGroup, addIndividualToGroup, and createGroupIndividuals GraphQL mutations. (Default: ["180002"])
gql_group_update_perms: Specifies the required rights to call the updateGroup and editIndividualInGroup GraphQL mutations. (Default: ["180003"])
gql_group_delete_perms: Specifies the required rights to call the deleteGroup and removeIndividualFromGroup GraphQL mutations. (Default: ["180004"])

Developers can adjust these options to control access and permissions related to individual and group management operations.

OpenIMIS Modules Dependencies

The Individual Reference Module relies on the following module:

core: Provides core functionality and utilities for the OpenIMIS system.

Ensure that the core module is correctly installed and configured for the Individual Reference Module to function properly.

OpenIMIS Backend Social Protection Reference Module Documentation

The OpenIMIS Backend Social Protection Reference Module is an integral part of the OpenIMIS system. This module is dedicated to handling social protection-related information, including benefit plans, beneficiaries, and group beneficiaries. It is designed to be deployed as a module of openimis-be_py, the OpenIMIS backend application.

This documentation aims to provide a comprehensive guide on how to utilize, configure, and interact with the Social Protection Reference Module effectively.

ORM Mapping

The module uses Object-Relational Mapping (ORM) to map data from the database to Python objects. The following ORM mappings are used:

social_protection_benefitplan, social_protection_historicalbenefitplan -> BenefitPlan: Represents a social protection benefit plan entity.
social_protection_beneficiary, social_protection_historicalbeneficiary -> Beneficiary: Represents a social protection beneficiary entity.
social_protection_benefitplandatauploadsrecords, social_protection_historicalbenefitplandatauploadsrecords -> BenefitPlanDataUploadRecords: Represents data upload records associated with a benefit plan.
social_protection_groupbeneficiary, social_protection_historicalgroupbeneficiary -> GroupBeneficiary: Represents a group beneficiary entity.

Developers can access and manipulate social protection data using these mapped objects, which abstract away the underlying database complexities.

GraphQL Queries

The module provides several GraphQL queries to retrieve social protection-related information:

benefitPlan: Retrieves benefit plan data based on specified criteria.
beneficiary: Retrieves beneficiary data based on specified criteria.
groupBeneficiary: Retrieves group beneficiary data based on specified criteria.
beneficiaryDataUploadHistory: Retrieves the data upload history of beneficiaries.
bfCodeValidity: Validates the beneficiary code.
bfNameValidity: Validates the beneficiary name.
bfSchemaValidity: Validates the beneficiary schema.
beneficiaryExport: Exports beneficiary data.
groupBeneficiaryExport: Exports group beneficiary data.

These GraphQL queries provide a flexible and efficient way to retrieve relevant social protection data.

GraphQL Mutations

The Social Protection Reference Module offers GraphQL mutations to manage social protection data. Each mutation emits default signals and returns standard error lists following the conventions of openimis-be-core_py.

List of available mutations:

createBenefitPlan: Creates a new benefit plan record.
updateBenefitPlan: Updates an existing benefit plan record.
deleteBenefitPlan: Deletes a benefit plan record.
createBeneficiary: Creates a new beneficiary record.
updateBeneficiary: Updates an existing beneficiary record.
deleteBeneficiary: Deletes a beneficiary record.
createGroupBeneficiary: Creates a new group beneficiary record.
updateGroupBeneficiary: Updates an existing group beneficiary record.
deleteGroupBeneficiary: Deletes a group beneficiary record.

These mutations enable seamless management of social protection data within the OpenIMIS system.

Services

The module provides the following services:

BenefitPlanService: Offers methods to create, update, and delete benefit plan records.
BeneficiaryService: Provides methods to create, update, and delete beneficiary records.
GroupBeneficiaryService: Offers methods to create, update, and delete group beneficiary records.
BeneficiaryImportService: Provides methods to import beneficiaries.

Developers can interact with these services to perform CRUD (Create, Read, Update, Delete) operations and handle beneficiary imports.

Configuration Options

The behavior of the Social Protection Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

gql_benefit_plan_search_perms: Specifies the required rights to call the benefitPlan GraphQL query. (Default: ["160001"])
gql_benefit_plan_create_perms: Specifies the required rights to call the createBenefitPlan GraphQL mutation. (Default: ["160002"])
gql_benefit_plan_update_perms: Specifies the required rights to call the updateBenefitPlan GraphQL mutation. (Default: ["160003"])
gql_benefit_plan_delete_perms: Specifies the required rights to call the deleteBenefitPlan GraphQL mutation. (Default: ["160004"])
gql_beneficiary_search_perms: Specifies the required rights to call the beneficiary and groupBeneficiary GraphQL queries. (Default: ["170001"])
gql_beneficiary_create_perms: Specifies the required rights to call the createBeneficiary and createGroupBeneficiary GraphQL mutations. (Default: ["160002"])
gql_beneficiary_update_perms: Specifies the required rights to call the updateBeneficiary and updateGroupBeneficiary GraphQL mutations. (Default: ["160003"])
gql_beneficiary_delete_perms: Specifies the required rights to call the deleteBeneficiary and deleteGroupBeneficiary GraphQL mutations. (Default: ["170004"])
check_benefit_plan_update: Specifies whether the update of a Benefit Plan should be approved. (Default: True)

Developers can adjust these options to control access, permissions, and behavior related to social protection data.

OpenIMIS Modules Dependencies

The Social Protection Reference Module relies on the following modules:

core: Provides core functionality and utilities for the OpenIMIS system.
policyholder: Handles policyholder-related information.
individual: Manages individual references within the OpenIMIS system.

Ensure that these modules are correctly installed and configured for the Social Protection Reference Module to function properly.

OpenIMIS Backend Task Management Reference Module Documentation

Introduction

The OpenIMIS Backend Task Management Reference Module is a crucial component of the OpenIMIS system. This module is dedicated to managing tasks and activities within the system. It provides services, functionalities, and GraphQL queries related to task handling. The Task Management Reference Module is designed to be deployed as a module of openimis-be_py, the OpenIMIS backend application.

This documentation aims to provide a comprehensive guide on how to utilize, configure, and interact with the Task Management Reference Module effectively.

ORM Mapping

The module uses Object-Relational Mapping (ORM) to map data from the database to Python objects. The following ORM mappings are used:

task_management_task, task_management_historicaltask -> Task: Represents a task entity.
task_management_taskgroup, task_management_historicaltaskgroup -> TaskGroup: Represents a group of tasks.
task_management_taskexecutor, task_management_historicaltaskexecutor -> TaskExecutor: Represents a task executor.

Developers can access and manipulate task-related data using these mapped objects, which abstract away the underlying database complexities.

GraphQL Queries

The module provides several GraphQL queries to retrieve task-related information:

task: Retrieves task data based on specified criteria.
taskGroup: Retrieves task group data based on specified criteria.
taskExecutor: Retrieves task executor data based on specified criteria.

These GraphQL queries provide a flexible and efficient way to retrieve relevant task data.

Services

The module provides the following services:

TaskService: Offers methods to create, update, and delete tasks, execute tasks, and mark tasks as completed or resolved.
TaskGroupService: Provides methods to create, update, and delete task groups.
TaskExecutorService: Offers methods to create, update, and delete task executors.

Developers can interact with these services to perform various operations related to task management.

Configuration Options

The behavior of the Task Management Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

gql_task_group_search_perms: Specifies the required rights to call the taskGroup GraphQL query. (Default: 190001)
gql_task_group_create_perms: Specifies the required rights to call the createTaskGroup GraphQL mutation. (Default: 190002)
gql_task_group_update_perms: Specifies the required rights to call the updateTaskGroup GraphQL mutation. (Default: 190003)
gql_task_group_delete_perms: Specifies the required rights to call the deleteTaskGroup GraphQL mutation. (Default: 190004)
gql_task_search_perms: Specifies the required rights to call the task GraphQL query. (Default: 191001)
gql_task_create_perms: Specifies the required rights to call the createTask GraphQL mutation. (Default: 191002)
gql_task_update_perms: Specifies the required rights to call the updateTask GraphQL mutation. (Default: 191003)
gql_task_delete_perms: Specifies the required rights to call the deleteTask GraphQL mutation. (Default: 191004)

Developers can adjust these options to control access and permissions related to task management operations.

OpenIMIS Modules Dependencies

The Task Management Reference Module relies on the following modules:

core: Provides core functionality and utilities for the OpenIMIS system.

Ensure that the core module is correctly installed and configured for the Task Management Reference Module to function properly.

Creating Execution Action Handlers and Business Event Handlers

The module allows the creation of execution action handlers and business event handlers for tasks. To implement custom handling of task execution or completion, developers need to bind to specific signals.

Binding to Task Execution Signal

To create an execution action handler, bind to the task_service.resolve_task signal using the handler_hook function. The handler should check the specific executor_action_event of the task.

Example:

# In signals.py of any module
def bind_service_signals():
    bind_service_signal(
        'task_service.resolve_task',
        handler_hook,
        bind_type=ServiceSignalBindType.AFTER
    )

def handler_hook(**kwargs):
    # Custom handling logic for task execution action
    pass

Binding to Task Completion Signal

To create a business event handler for task completion, bind to the task_service.complete_task signal using the handler_hook function.

Example:

# In signals.py of any module
def bind_service_signals():
    bind_service_signal(
        'task_service.complete_task',
        handler_hook,
        bind_type=ServiceSignalBindType.AFTER
    )

def handler_hook(**kwargs):
    # Custom handling logic for task completion business event
    pass

openIMIS Backend opensearch_reports reference module

OpenIMIS Backend Workflow Reference Module Documentation

The OpenIMIS Backend Workflow Reference Module is a crucial component of the OpenIMIS system. This module is dedicated to managing workflows and integrating with various workflow systems. It provides services and functionalities to register workflow systems, query available workflows, and execute workflows. The Workflow Reference Module is designed to be deployed as a module of openimis-be_py, the OpenIMIS backend application.

This documentation aims to provide a comprehensive guide on how to utilize and interact with the Workflow Reference Module effectively.

Services

The Workflow Reference Module provides the following service:

WorkflowService: Offers methods to register workflow systems, query available workflows, and execute workflows.

Developers can interact with this service to perform various operations related to workflows.

Registering Workflow Systems

The Workflow Service can be extended with custom adaptors to integrate with new workflow systems. Any adaptor must extend workflow.systems.base.WorkflowAdaptor and return triggers as implementations of workflow.systems.base.WorkflowHandler.

Example:

# Example of extending WorkflowAdaptor
class CustomWorkflowAdaptor(WorkflowAdaptor):
    def get_triggers(self):
        # Implement logic to retrieve triggers from the custom workflow system
        return [CustomWorkflowHandler1(), CustomWorkflowHandler2(), ...]

# Register the custom workflow adaptor
WorkflowService.register_system_adaptor(CustomWorkflowAdaptor)

Querying Workflows

Querying available workflows can be done using the WorkflowService.get_workflows service. All registered workflow systems must implement filtering workflows by group and name.

Example:

# Querying available workflows with group and name filter
workflows_result = WorkflowService.get_workflows(group='default', name='example')
if workflows_result['success']:
    workflow_handlers = workflows_result['data']['workflows']

Executing Workflows

Workflow handlers are self-contained triggers for a specific workflow in a given system. The WorkflowHandler.run method allows performing a workflow run with a given payload. Depending on the system, workflow runs can be synchronous and return the result of the workflow or asynchronous and return necessary information to check the workflow status in a given workflow system.

Example:

# Executing a workflow with a payload
payload = { ... }
result = handler.run(payload)

OpenIMIS Backend Payment Cycle Reference Module Documentation

The OpenIMIS Backend Payment Cycle Reference Module is a crucial component of the OpenIMIS system. This module is designed to handle payment cycles and facilitate periodical payments for various business objects connected to payment plans. It offers services and functionalities to perform payment cycle calculations, including a specific service customized for Benefit Plan payment cycle calculation.

ORM Mapping

The Payment Cycle Reference Module utilizes ORM mapping to interact with the underlying database. The following mappings are used:

payment_cycle_paymentcycle, payment_cycle_historicalpaymentcycle -> Individual: Represents the payment cycle entity.

Developers can use this mapping to access payment cycle data efficiently.

GraphQL Queries

The module provides a GraphQL query to retrieve payment cycle information:

paymentCycle: Retrieves payment cycle data based on specified criteria.

GraphQL queries offer a flexible and efficient way to fetch relevant payment cycle information.

GraphQL Mutations

The module offers a GraphQL mutation to trigger the calculation of payment cycles:

processBenefitPlanPaymentCycle: Initiates the calculation process for Benefit Plan payment cycles.

GraphQL mutations allow seamless execution of payment cycle calculations within the OpenIMIS system.

Services

The Payment Cycle Reference Module provides the following services:

PaymentCycleService: A generic service containing the workflow for payment cycle calculation.
BenefitPlanPaymentCycleService: A service customized for Benefit Plan payment cycle calculation.

Developers can utilize these services to perform payment cycle calculations and retrieve the results efficiently.

Configuration Options

The behavior of the Payment Cycle Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

gql_query_payment_cycle_perms: Specifies the required rights to query PaymentCycle. (Default: ["200001"])
gql_create_payment_cycle_perms: Specifies the required rights to create PaymentCycle. (Default: ["200002"])
gql_update_payment_cycle_perms: Specifies the required rights to update PaymentCycle. (Default: ["200003"])
gql_delete_payment_cycle_perms: Specifies the required rights to delete PaymentCycle. (Default: ["200004"])
gql_mutation_process_payment_cycle_perms: Specifies the required rights to call the processBenefitPlanPaymentCycle GraphQL Mutation. (Default: ["200005"])

These options allow administrators to control access and permissions related to payment cycle data and calculations.

Dependencies

The Payment Cycle Reference Module relies on the following modules:

core: Provides core functionality and utilities for the OpenIMIS system.
social_protection: Manages social protection-related information within the OpenIMIS system.
contribution_plan: Handles contribution plan data.
calculation: Facilitates calculation-related functionalities within the OpenIMIS system.

Ensure that these modules are correctly installed and configured for the Payment Cycle Reference Module to function correctly.

Payment Cycle Service

The Payment Cycle Service specifies a generic workflow for performing payment cycle calculations for various business objects connected to payment plans. It includes a specialized service for Benefit Plan objects. To trigger a calculation, the service requires a user reference, year, and month. Additional keyword arguments can be passed to the process() method to be used in calculations.

Example usage:

result = BenefitPlanPaymentCycleService(user).process(year=year, month=month)

The result is a dictionary containing the status of the operation, indicating whether it completed successfully or encountered errors. It also includes messages and details of any errors that occurred during the calculation. Additional data returned from specific implementations of services and calculation rules are grouped by the ID of the main queryset entry (BenefitPlan ID in this case).

Please note that this documentation provides an overview of the features and components of the Payment Cycle Reference Module. For detailed information on how to set up, configure, and use the module, refer to the specific documentation and guidelines provided in the codebase and related resources. Additionally, the documentation is subject to updates and improvements as the module evolves, so make sure to keep it up-to-date with any changes you make.

OpenIMIS Backend Calcrule_Social_Protection Reference Module Documentation

The OpenIMIS Backend Calcrule_Social_Protection Reference Module is a critical component of the OpenIMIS system. This module is responsible for performing calculations to determine the amount of payment for beneficiaries based on specific criteria specified in custom filters of payment plans. It allows for flexible and customized payment calculations tailored to the needs of social protection programs.

Calculation Process

The calculation process in the Calcrule_Social_Protection module is crucial in determining the payment amount for beneficiaries. The calculation is performed based on the specific criteria defined in the custom filters associated with the payment plan.

Custom Filters

Custom filters play a pivotal role in the calculation process. They are user-defined criteria that determine how the payment amount is calculated for each beneficiary. The custom filters are configured within the payment plan and are tailored to the requirements of the social protection program

OpenIMIS Backend Payroll Reference Module Documentation

ORM Mapping

The module uses Object-Relational Mapping (ORM) to map data from the database to Python objects. The following ORM mappings are used:

payroll_payroll, payroll_historicalpayroll -> Payroll: Represents a payroll entity.
payroll_paymentpoint, payroll_historicalpaymentpoint -> PaymentPoint: Represents the payment point. Associated with payment point manager user and location.
payroll_payrollbill, payroll_historicalpayrollbill → PayrollBill: Represents the relation between invoice and the payroll.
payroll_benefitconsumption, payroll_historicalbenefitconsumption-> BenefitConsumption: Represents the consumption of the benefit.
payroll_benefitattachment, payroll_historicalbenefitattachment → BenefitAttachment: Represents association between Bill and BenefitConsumption
payroll_benefitconsumption, payroll_historicalbenefitconsumption → PayrollBenefitConsumption: Represents the relation between Payroll and the BenefitConsumption
payroll_csvreconciliationupload, payroll_historicalcsvreconciliationupload → CsvReconciliationUpload: Represents the reconciliation of the payroll based on the csv file upload.

Developers can access and payroll data using these mapped objects, which abstract away the underlying database complexities.

GraphQL Queries

The module provides several GraphQL queries to retrieve payroll related information:

paymentPoint: Retrieves payment points.
payroll Retrieves payroll information based on specified criteria.
billByPayroll: Retrieves bills information based on specified criteria.
benefitConsumption: Retrieves benefit consumption based on specified criteria.
paymentMethods: Retrieves payment methods based on specified criteria.
paymentGatewayConfig: Retrieves payment gateway config based on specified criteria.
benefitAttachmentByPayroll: Retrieves consumption attachments based on specified criteria.
csvReconciliationUpload: Retrieves CSV Reconciliation uploads based on specified criteria.
payrollBenefitConsumption: Retrieves benefit consumptions based on specified criteria.
benefitsSummary: Retrieves benefit summary based on the specified criteria.

These GraphQL queries provide a flexible and efficient way to retrieve relevant payroll data.

GraphQL Mutations

The Payroll Reference Module offers GraphQL mutations to manage Payroll and Payment Points data. Each mutation emits default signals and returns standard error lists following the conventions of openimis-be-core_py.

List of available mutations:

create_payment_point
update_payment_point
delete_payment_point
create_payroll
delete_payroll
close_payroll
reject_payroll
make_payment_for_payroll
delete_benefit_consumption

These mutations enable seamless management of payrolls data within the OpenIMIS system.

Services

The module provides the following services:

PaymentPointService: Provides create, update, delete operations for the Payment Point
PayrollService: Provides methods to create, update, delete, create attachments, approve and reject Payrolls.
BenefitConsumptionService: Offers methods to create, update, and delete BenefitConsumptions and it’s attachments.
CsvReconciliationService: Provides methods to download and upload of the Reconciliation files.

Developers can interact with these services to perform various operations related to payroll management.

Configuration Options

The behavior of the Payroll Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

Role Rights
gql_payment_point_search_perms, default: ["201001"],
gql_payment_point_create_perms, default: ["201002"],
gql_payment_point_update_perms, default: ["201003"],
gql_payment_point_delete_perms, default: ["201004"],
gql_payroll_search_perms, default: ["202001"],
gql_payroll_create_perms, default: ["202002"],
gql_payroll_delete_perms, default: ["202004"],
gql_csv_reconciliation_search_perms, default: ["206001"],
gql_csv_reconciliation_create_perms, default: ["206002"],

Specify the required rights to call graphQL operations.
Events
payroll_accept_event, default: "payroll.accept_payroll",
payroll_reconciliation_event, default: "payroll.payroll_reconciliation",
payroll_delete_event, default: "payroll.payroll_delete",
benefit_delete_event, default: "payroll.benefit_delete",
payroll_reject_event, default: "payroll.payroll_reject",

Specify the name of the event that will be sent to the signal orchestration on certain operations.
csv_reconciliation_field_mapping: Specified the mapping between the reconciliation fields and ORM.
Default:
"csv_reconciliation_field_mapping": { 'payrollbenefitconsumption__payroll__name': 'Payroll Name', 'payrollbenefitconsumption__payroll__status': 'Payroll Status', 'individual__first_name': 'First Name', 'individual__last_name': 'Last Name', 'individual__dob': 'Date of Birth', 'code': 'Code', 'status': 'Status', 'amount': 'Amount', 'type': 'Type', 'receipt': 'Receipt', },
Reconciliation Field Names:
"csv_reconciliation_status_column": "Status", "csv_reconciliation_paid_extra_field": "Paid", "csv_reconciliation_receipt_column": "receipt", "csv_reconciliation_errors_column": "errors", "csv_reconciliation_code_column": "code", "csv_reconciliation_paid_yes": "Yes", "csv_reconciliation_paid_no": "No",
Specifies the names of columns in the Reconcilaition CSV files.
Payment Gateway Config
Specifies the details for the payment gateway client.
gateway_base_url, default: "http://41.175.18.170:8070/api/mobile/v1/",
endpoint_payment, default: "mock/payment",
endpoint_reconciliation, default: "mock/reconciliation",
payment_gateway_api_key, default: os.getenv('PAYMENT_GATEWAY_API_KEY'),
payment_gateway_basic_auth_username, default: os.getenv('PAYMENT_GATEWAY_BASIC_AUTH_USERNAME'),
payment_gateway_basic_auth_password, default: os.getenv('PAYMENT_GATEWAY_BASIC_AUTH_PASSWORD'),
payment_gateway_timeout, default: 5,
payment_gateway_auth_type, default: "basic", # can be 'token' or 'basic'
payment_gateway_class, default: "payroll.payment_gateway.MockedPaymentGatewayConnector",
receipt_length, default: 8

Specifies the configuration for the gateway connection.

OpenIMIS Modules Dependencies

The Payrol Reference Module relies on the following module:

core: Provides core functionality and utilities for the OpenIMIS system.
social_protection: Provides functionality and utilities for the General Social Protection models
individual: Base functionality for Individual/Group management.
contribution_plan: Functionality for the Payment Plan Definitions.
location: Provide locations handling.

Ensure that the core module is correctly installed and configured for the Payroll Reference Module to function properly.

OpenIMIS Backend Calcrule_Social_Protection Reference Module Documentation

The openimis-be-deduplication_py module is dedicated to detection and removal of the duplication in the beneficiary uploads to OpenIMIS system.

Introduction

It provides services, functionalities, and GraphQL queries related to duplication. It’s is designed to be deployed as a module of openimis-be_py, the OpenIMIS backend application.

This documentation aims to provide a comprehensive guide on how to utilize, configure, and interact with the Deduplication Reference Module effectively.

ORM Mapping

N/A

GraphQL Queries

The module provides several GraphQL queries to retrieve tasks information:

beneficiaryDeduplicationSummary: Retrieves summary of the deduplication operations on the individuals level.
benefityDeduplicationSummary: Retrieves summary of the deduplication operations on the benefit plan level.

GraphQL Mutations

The Deduplication Reference Module offers GraphQL mutations to manage it’s Each mutation emits default signals and returns standard error lists following the conventions of openimis-be-core_py.

List of available mutations:

create_deduplication_tasks: Creates a new task for individual deduplication record.
create_deduplication_payment_tasks: Create a new task for payments deduplication.

Services

The module provides the following services:

CreateDeduplicationReviewTasksService: Create individual deduplication tasks.
CreateDeduplicationPaymentReviewTasksService: Create payment deduplication tasks.
IndividualDataSourceUploadService: Offers methods to create, update, and delete individual data source uploads.
GroupService: Provides methods to create, update, and delete group records.
GroupIndividualService: Offers methods to create, update, and delete group-individual associations.

Developers can interact with these services to perform various operations related to individual and group management.

Configuration Options

The behavior of the Reference Module can be customized through configuration options, which can be modified via core.ModuleConfiguration. The available configuration options are:

gql_create_deduplication_review_perms: Specifies the required rights to create individual deduplication task.
gql_create_deduplication_payment_review_perms: Specifies the required rights to create payment deduplication task.

OpenIMIS Modules Dependencies

The Reference Module relies on the following module:

core: Provides core functionality and utilities for the OpenIMIS system.
individuial: Provide base for individuals and groups management.
tasks: Task management and queirying functionality. Deduplication operations are handled as tasks.
payment_cycle: for payment deduplication.

OpenIMIS Backend Grievance Reference Module Documentation

Frontend Modules

This documentation provides a brief overview of the JavaScript modules/packages found in the OpenIMIS Frontend (openimis-fe) project. These modules are integral components of the user interface and handle various functionalities related to managing social health insurance and social protection schemes.

openimis-fe-individual_js
- Short Description: This module is responsible for managing individual member data in the OpenIMIS system. It facilitates tasks such as adding, editing, and deleting beneficiary information, ensuring accurate and up-to-date records.
openimis-fe-social_protection_js
- Short Description: Focused on social protection features, this module handles functionalities related to social protection programs in the OpenIMIS frontend. It enables administrators to manage programs, assess eligibility, and associate beneficiaries with relevant social protection initiatives.
openimis-fe-tasks_management_js
- Short Description: The tasks management module allows users to manage tasks within the OpenIMIS system. It provides functionality for task assignment, tracking, and completion, streamlining administrative processes.
openimis-fe-opensearch_reports_js
- Short Description: This module enables the generation and display of comprehensive reports based on the data stored in the OpenIMIS system. Reports may cover aspects such as the health insurance scheme's performance, financial status, and member statistics, aiding decision-making processes.
openimis-fe-payment_cycle_js
- Short Description: Responsible for managing payment cycles, this module handles payment calculations, processing payments to healthcare providers, beneficiaries, and maintaining a payment history. It ensures smooth financial transactions within the OpenIMIS ecosystem.
openimis-fe-coremis_language_pack_js
- Short Description: The language pack module provides essential translations and localization support for the coreMIS naming in OpenIMIS frontend.
openimis-be-payroll_py
- Short Description: Module created for payroll management. It serves as a main point for management of the benefit disbursement.
openimis-be-deduplication_py
- Short Description: Module created as an extension to the Individual module which allow users to remove duplication in the individuals registry based on the flexible criteria.
openimis-be-grievance_social_protection_py
- Short Description: Module introducing flexible grievances to the OpenIMIS. The types of the grievances as well as channels or flags can be configured by the administration.

Developers documentation:

Backend Modules

OpenIMIS Backend Individual Reference Module Documentation

Introduction

ORM Mapping

GraphQL Queries

GraphQL Mutations

Services

Configuration Options

OpenIMIS Modules Dependencies

OpenIMIS Backend Social Protection Reference Module Documentation

ORM Mapping

GraphQL Queries

GraphQL Mutations

Services

Configuration Options

OpenIMIS Modules Dependencies

OpenIMIS Backend Task Management Reference Module Documentation

Introduction

ORM Mapping

GraphQL Queries

Services

Configuration Options

OpenIMIS Modules Dependencies

Creating Execution Action Handlers and Business Event Handlers

Binding to Task Execution Signal

Binding to Task Completion Signal

openIMIS Backend opensearch_reports reference module

OpenIMIS Backend Workflow Reference Module Documentation

Services

Registering Workflow Systems

Querying Workflows

Executing Workflows

OpenIMIS Backend Payment Cycle Reference Module Documentation

ORM Mapping

GraphQL Queries

GraphQL Mutations

Services

Configuration Options

Dependencies

Payment Cycle Service

OpenIMIS Backend Calcrule_Social_Protection Reference Module Documentation

Calculation Process

Custom Filters

OpenIMIS Backend Payroll Reference Module Documentation

ORM Mapping

GraphQL Queries

GraphQL Mutations

Services

Configuration Options

OpenIMIS Modules Dependencies

OpenIMIS Backend Calcrule_Social_Protection Reference Module Documentation

Introduction

ORM Mapping

GraphQL Queries

GraphQL Mutations

Services

Configuration Options

OpenIMIS Modules Dependencies

OpenIMIS Backend Grievance Reference Module Documentation

Frontend Modules

Did you encounter a problem or do you have a suggestion?

Please contact our Service Desk