From 63269690859ae9455321287b7b347db82bc7213a Mon Sep 17 00:00:00 2001 From: Jeremi Joslin Date: Tue, 20 Aug 2024 23:57:45 +0700 Subject: [PATCH] improve module pages and add missing ones. --- docs/modules/g2p_auth_id_oidc.md | 48 +++++++++++++++++++ docs/modules/g2p_bank.md | 2 +- docs/modules/g2p_bank_rest_api.md | 34 +++++++++++++ docs/modules/g2p_connect_demo.md | 44 +++++++++++++++++ docs/modules/g2p_encryption.md | 2 +- docs/modules/g2p_encryption_keymanager.md | 40 ++++++++++++++++ docs/modules/g2p_encryption_rest_api.md | 2 +- docs/modules/g2p_entitlement_in_kind.md | 27 +++++++++++ docs/modules/g2p_entitlement_voucher.md | 38 +++++++++++++++ docs/modules/g2p_openid_vci.md | 2 +- docs/modules/g2p_openid_vci_programs.md | 32 +++++++++++++ docs/modules/g2p_payment_cash.md | 34 +++++++++++++ docs/modules/g2p_payment_files.md | 45 +++++++++++++++++ docs/modules/g2p_payment_interop_layer.md | 38 +++++++++++++++ docs/modules/g2p_payment_phee.md | 44 +++++++++++++++++ docs/modules/g2p_payment_simple_mpesa.md | 39 +++++++++++++++ docs/modules/g2p_program_approval.md | 36 ++++++++++++++ docs/modules/g2p_program_assessment.md | 38 +++++++++++++++ docs/modules/g2p_program_autoenrol.md | 47 ++++++++++++++++++ docs/modules/g2p_program_cycleless.md | 42 ++++++++++++++++ docs/modules/g2p_program_documents.md | 40 ++++++++++++++++ docs/modules/g2p_program_registrant_info.md | 43 +++++++++++++++++ .../g2p_program_registrant_info_rest_api.md | 30 ++++++++++++ docs/modules/g2p_program_reimbursement.md | 44 +++++++++++++++++ docs/modules/g2p_programs.md | 3 +- docs/modules/g2p_programs_rest_api.md | 35 ++++++++++++++ docs/modules/g2p_proxy_means_test.md | 30 ++++++++++++ docs/modules/g2p_registry_addl_info.md | 38 +++++++++++++++ .../g2p_registry_addl_info_rest_api.md | 30 ++++++++++++ docs/modules/g2p_registry_base.md | 3 +- docs/modules/g2p_registry_encryption.md | 40 ++++++++++++++++ docs/modules/g2p_registry_group.md | 2 +- docs/modules/g2p_registry_individual.md | 2 +- docs/modules/g2p_registry_membership.md | 2 +- docs/modules/g2p_registry_rest_api.md | 44 +++++++++++++++++ .../g2p_registry_rest_api_extension_demo.md | 28 +++++++++++ docs/modules/index.md | 6 ++- docs/modules/spp_api.md | 4 +- docs/modules/spp_api_records.md | 2 +- docs/modules/spp_area.md | 3 +- docs/modules/spp_area_gis.md | 2 +- docs/modules/spp_audit_config.md | 2 +- docs/modules/spp_audit_log.md | 5 ++ docs/modules/spp_audit_post.md | 2 +- docs/modules/spp_auto_update_entitlements.md | 2 +- docs/modules/spp_base.md | 3 +- docs/modules/spp_base_api.md | 2 +- docs/modules/spp_base_demo.md | 2 +- docs/modules/spp_base_gis.md | 2 +- docs/modules/spp_base_gis_demo.md | 2 +- docs/modules/spp_base_gis_rest.md | 2 +- docs/modules/spp_base_setting.md | 2 +- .../spp_basic_cash_entitlement_spent.md | 2 +- docs/modules/spp_change_request.md | 2 +- .../spp_change_request_add_children_demo.md | 2 +- docs/modules/spp_change_request_add_farmer.md | 8 ++-- docs/modules/spp_consent.md | 36 ++++++++++++++ docs/modules/spp_custom_field.md | 2 +- .../modules/spp_custom_field_custom_filter.md | 2 +- .../spp_custom_field_recompute_daily.md | 2 +- docs/modules/spp_custom_fields_ui.md | 2 +- docs/modules/spp_custom_filter.md | 2 +- docs/modules/spp_custom_filter_ui.md | 2 +- docs/modules/spp_data_export.md | 2 +- docs/modules/spp_dci_api_server.md | 10 ++-- docs/modules/spp_demo.md | 2 +- docs/modules/spp_dms.md | 2 +- docs/modules/spp_eligibility_sql.md | 2 +- docs/modules/spp_eligibility_tags.md | 2 +- docs/modules/spp_encryption.md | 8 ++-- docs/modules/spp_ent_trans.md | 4 +- docs/modules/spp_entitlement_basket.md | 2 +- docs/modules/spp_entitlement_cash.md | 2 +- docs/modules/spp_entitlement_in_kind.md | 2 +- docs/modules/spp_event_data.md | 2 +- .../spp_event_data_program_membership.md | 3 +- docs/modules/spp_event_demo.md | 2 +- docs/modules/spp_exclusion_filter.md | 2 +- docs/modules/spp_farmer_registry_base.md | 2 +- docs/modules/spp_farmer_registry_dashboard.md | 8 ++-- docs/modules/spp_farmer_registry_demo.md | 2 +- docs/modules/spp_idqueue.md | 3 +- docs/modules/spp_import_dci_api.md | 33 +++++++------ docs/modules/spp_import_match.md | 2 +- docs/modules/spp_irrigation.md | 2 +- docs/modules/spp_land_record.md | 2 +- docs/modules/spp_manual_entitlement.md | 2 +- docs/modules/spp_oauth.md | 2 +- docs/modules/spp_openid_vci.md | 24 +++++----- docs/modules/spp_openid_vci_group.md | 2 +- docs/modules/spp_openid_vci_individual.md | 2 +- docs/modules/spp_pmt.md | 2 +- docs/modules/spp_pos.md | 2 +- docs/modules/spp_program_id.md | 2 +- docs/modules/spp_programs.md | 2 +- .../spp_programs_compliance_criteria.md | 2 +- docs/modules/spp_programs_sp.md | 2 +- docs/modules/spp_registrant_import.md | 2 +- docs/modules/spp_registrant_tag.md | 2 +- docs/modules/spp_registry_data_source.md | 2 +- docs/modules/spp_registry_group_hierarchy.md | 2 +- docs/modules/spp_scan_id_document.md | 2 +- docs/modules/spp_service_point_device.md | 2 +- docs/modules/spp_service_points.md | 2 +- docs/modules/spp_starter.md | 30 ++++++++++++ docs/modules/spp_user_roles.md | 16 +++---- 106 files changed, 1227 insertions(+), 131 deletions(-) create mode 100644 docs/modules/g2p_auth_id_oidc.md create mode 100644 docs/modules/g2p_bank_rest_api.md create mode 100644 docs/modules/g2p_connect_demo.md create mode 100644 docs/modules/g2p_encryption_keymanager.md create mode 100644 docs/modules/g2p_entitlement_in_kind.md create mode 100644 docs/modules/g2p_entitlement_voucher.md create mode 100644 docs/modules/g2p_openid_vci_programs.md create mode 100644 docs/modules/g2p_payment_cash.md create mode 100644 docs/modules/g2p_payment_files.md create mode 100644 docs/modules/g2p_payment_interop_layer.md create mode 100644 docs/modules/g2p_payment_phee.md create mode 100644 docs/modules/g2p_payment_simple_mpesa.md create mode 100644 docs/modules/g2p_program_approval.md create mode 100644 docs/modules/g2p_program_assessment.md create mode 100644 docs/modules/g2p_program_autoenrol.md create mode 100644 docs/modules/g2p_program_cycleless.md create mode 100644 docs/modules/g2p_program_documents.md create mode 100644 docs/modules/g2p_program_registrant_info.md create mode 100644 docs/modules/g2p_program_registrant_info_rest_api.md create mode 100644 docs/modules/g2p_program_reimbursement.md create mode 100644 docs/modules/g2p_programs_rest_api.md create mode 100644 docs/modules/g2p_proxy_means_test.md create mode 100644 docs/modules/g2p_registry_addl_info.md create mode 100644 docs/modules/g2p_registry_addl_info_rest_api.md create mode 100644 docs/modules/g2p_registry_encryption.md create mode 100644 docs/modules/g2p_registry_rest_api.md create mode 100644 docs/modules/g2p_registry_rest_api_extension_demo.md create mode 100644 docs/modules/spp_consent.md create mode 100644 docs/modules/spp_starter.md diff --git a/docs/modules/g2p_auth_id_oidc.md b/docs/modules/g2p_auth_id_oidc.md new file mode 100644 index 00000000..ee3b3801 --- /dev/null +++ b/docs/modules/g2p_auth_id_oidc.md @@ -0,0 +1,48 @@ +# g2p_auth_id_oidc Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the OpenG2P Auth module to allow user authentication and registration using OIDC (OpenID Connect) while linking them to their existing G2P Registrant IDs. + +**Purpose:** + +The primary goal of this module is to streamline the user registration and login process by leveraging existing G2P Registrant IDs within the OpenG2P system. Instead of creating new user accounts from scratch, this module allows users to authenticate using their OIDC credentials and then links them to their pre-existing G2P registration data. + +**Key Features:** + +* **OIDC Integration for Authentication:** Users can authenticate using their credentials from an OIDC provider. +* **G2P Registrant ID Mapping:** The module maps the authenticated OIDC user to their corresponding G2P Registrant ID stored in the [g2p_registry_base](g2p_registry_base) module. +* **Automated Partner/User Creation:** If a matching G2P Registrant ID is found, the module automatically creates a linked Partner and User in DCI, pulling relevant data from the registration record. +* **Customizable Data Mapping:** Administrators can configure how data from the OIDC provider and the G2P registry is mapped to DCI Partner and User fields. + +**How it Works:** + +1. **OIDC Authentication:** A user initiates the login process via an OIDC provider. +2. **G2P ID Lookup:** The module extracts the user's ID from the OIDC response and attempts to find a matching G2P Registrant ID. +3. **Account Creation/Linking:** + * **Match Found:** If a match is found, the module retrieves the registration data and creates/updates the corresponding Partner and User records in DCI. + * **No Match:** The module can be configured to either deny access or initiate a more detailed registration process, potentially pulling additional data from the OIDC provider. +4. **User Login:** Upon successful authentication and account linking, the user is logged into the OpenG2P system. + +**Dependencies:** + +* **[g2p_registry_base](g2p_registry_base):** This module depends on the base registry module for accessing and retrieving G2P Registrant data. + +**Benefits:** + +* **Simplified User Experience:** Easier registration and login process for beneficiaries already registered within the OpenG2P system. +* **Improved Data Accuracy:** Leveraging existing G2P Registrant data ensures consistency and reduces the risk of duplicate records. +* **Enhanced Security:** Integration with trusted OIDC providers enhances the security of the OpenG2P platform. + +**Notes:** + +* The module relies on a consistent and accurate mapping between OIDC user identifiers and G2P Registrant IDs. +* Proper configuration of OIDC settings and data mapping is crucial for the module's functionality. + +**TODOs:** + +* The original module references an `auth_oidc` module that has been removed. A suitable replacement needs to be integrated into the codebase for the OIDC functionality. +* The code comments highlight areas that require further improvement, such as refining the data mapping logic and enhancing error handling. diff --git a/docs/modules/g2p_bank.md b/docs/modules/g2p_bank.md index a259ff03..c47c819b 100644 --- a/docs/modules/g2p_bank.md +++ b/docs/modules/g2p_bank.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **G2P Bank** module within the OpenSPP framework. This module extends the functionality of individual and group registries to manage their bank details. diff --git a/docs/modules/g2p_bank_rest_api.md b/docs/modules/g2p_bank_rest_api.md new file mode 100644 index 00000000..fafc3f8e --- /dev/null +++ b/docs/modules/g2p_bank_rest_api.md @@ -0,0 +1,34 @@ +# g2p_bank_rest_api Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the REST API functionalities of the OpenSPP system by providing endpoints specifically for managing bank details related to beneficiaries and/or programs. + +**Purpose:** + +The primary purpose of the [g2p_bank_rest_api](g2p_bank_rest_api) module is to expose bank-related data and operations through a standardized RESTful interface. This allows external systems, such as financial institutions or payment gateways, to interact with the OpenSPP platform and access or modify bank information. + +**Integration and Functionality:** + +This module builds upon the core functionalities provided by the following modules: + +- **[g2p_registry_rest_api](g2p_registry_rest_api):** It leverages the base REST API infrastructure and authentication mechanisms provided by this module. +- **[g2p_bank](g2p_bank):** This module depends on the data models and business logic related to bank details, which are defined and managed by the [g2p_bank](g2p_bank) module. + +**Additional Functionality:** + +The [g2p_bank_rest_api](g2p_bank_rest_api) module introduces the following specific functionalities: + +- **API Endpoints:** It defines and implements REST API endpoints for operations such as: + - Retrieving bank details for a specific beneficiary or program. + - Updating bank information. + - Potentially, verifying bank account details through integration with external services (depending on implementation). + +**Example Use Case:** + +Consider a scenario where a payment gateway needs to access the bank account details of a beneficiary to process a payment. The [g2p_bank_rest_api](g2p_bank_rest_api) module enables this by providing a secure and standardized API endpoint. The payment gateway can send a request to this endpoint with the necessary authentication and beneficiary identifiers, and the module would return the required bank information in a structured format (e.g., JSON). + +**Note:** This documentation provides a general overview. Specific API endpoints, request/response formats, and authentication mechanisms are detailed in the API documentation generated by the [g2p_registry_rest_api](g2p_registry_rest_api) module. diff --git a/docs/modules/g2p_connect_demo.md b/docs/modules/g2p_connect_demo.md new file mode 100644 index 00000000..eb9335d6 --- /dev/null +++ b/docs/modules/g2p_connect_demo.md @@ -0,0 +1,44 @@ +# Module: g2p_connect_demo + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The `g2p_connect_demo` module serves as a demonstration and testing ground for the OpenSPP system, particularly showcasing the capabilities of the G2P Connect system. This module is not intended for production use but rather for development, testing, and demonstration purposes. + +## Purpose + +The primary purpose of `g2p_connect_demo` is to: + +- **Generate Sample Data:** Provide a mechanism to create realistic but anonymized sample data for registries, individuals, groups, and change requests. This data can be used to populate the OpenSPP system for testing, training, and demonstration purposes. +- **Showcase System Functionality:** Demonstrate the integration and interaction between different OpenSPP modules in a realistic scenario. This includes modules related to registry management ([g2p_registry_base](g2p_registry_base)), individual and group registration ([g2p_registry_individual](g2p_registry_individual), [g2p_registry_group](g2p_registry_group), [g2p_registry_membership](g2p_registry_membership)), programs ([g2p_programs](g2p_programs)), and custom fields ([spp_custom_field](spp_custom_field)). +- **Facilitate Testing and Development:** Provide a controlled environment with pre-populated data to facilitate the testing and development of new features and modifications to the OpenSPP system. + +## Key Features + +- Generates a configurable number of groups and individuals with realistic demographic data. +- Creates various relationships between individuals within groups, simulating households or families. +- Populates custom fields with relevant data to illustrate the flexibility of the system. +- Includes functionalities to generate change requests, mimicking real-world scenarios like adding children to a household. + +## Integration with other modules + +`g2p_connect_demo` builds upon the foundation laid by several other OpenSPP modules: + +- **[spp_base_demo](spp_base_demo):** Utilizes the base demo module for generating localized sample data. +- **Registry Modules:** Leverages the functionality of [g2p_registry_base](g2p_registry_base), [g2p_registry_individual](g2p_registry_individual), [g2p_registry_group](g2p_registry_group), and [g2p_registry_membership](g2p_registry_membership) to create and manage individuals, groups, and their relationships. +- **[g2p_programs](g2p_programs):** Integrates with program definitions to simulate the enrollment of generated individuals and groups into social protection programs. +- **[spp_custom_field](spp_custom_field):** Utilizes the custom field framework to demonstrate how additional data points can be captured and managed within the registry. + +## Usage + +The `g2p_connect_demo` module is primarily intended for developers and implementers working with the OpenSPP system. + +By using the provided interface, users can generate a specified number of groups and individuals. The module takes care of creating realistic relationships, assigning custom field values, and populating other relevant data. + +## Disclaimer + +It is important to reiterate that this module is for **demonstration and development purposes only**. The generated data, while designed to appear realistic, should not be used in a production environment or for any real-world social protection programs. diff --git a/docs/modules/g2p_encryption.md b/docs/modules/g2p_encryption.md index ed1cffa2..6fc96170 100644 --- a/docs/modules/g2p_encryption.md +++ b/docs/modules/g2p_encryption.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/g2p_encryption_keymanager.md b/docs/modules/g2p_encryption_keymanager.md new file mode 100644 index 00000000..e027b6ba --- /dev/null +++ b/docs/modules/g2p_encryption_keymanager.md @@ -0,0 +1,40 @@ +# g2p_encryption_keymanager Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the functionality of the [g2p_encryption](g2p_encryption) module by providing integration with a Keymanager service for encryption and signing operations. This allows OpenSPP to leverage external key management systems for enhanced security and compliance. + +### Purpose + +The primary purpose of this module is to: + +* **Delegate encryption and signing operations to an external Keymanager service:** This offloads the burden of key management from the OpenSPP application to a dedicated, potentially more secure, external service. +* **Provide a configurable interface:** System administrators can configure various parameters of the Keymanager integration, such as API endpoints, authentication credentials, and application-specific identifiers. +* **Seamlessly integrate with the existing encryption framework:** The module extends the existing encryption provider mechanism in OpenSPP, allowing for easy switching between different encryption providers, including the Keymanager-based provider. + +### Functionality + +The [g2p_encryption_keymanager](g2p_encryption_keymanager) module provides the following features: + +* **Encryption and Decryption using Keymanager:** The module allows OpenSPP to encrypt and decrypt data using encryption keys managed by the Keymanager service. +* **JWT Signing and Verification with Keymanager:** The module enables OpenSPP to digitally sign and verify JSON Web Tokens (JWTs) using the Keymanager service, ensuring authenticity and integrity of sensitive data. +* **Keymanager Authentication and Authorization:** The module implements secure communication with the Keymanager service using OAuth 2.0 client credentials grant type for authentication and authorization. +* **Configuration Options for Keymanager Integration:** The module provides a user-friendly interface within the OpenSPP settings to configure various aspects of the Keymanager integration, including API endpoints, authentication credentials, and application-specific identifiers for encryption and signing. + +### Integration with Other Modules + +This module directly interacts with the [g2p_encryption](g2p_encryption) module: + +* It inherits and extends the `g2p.encryption.provider` model to include Keymanager-specific configuration fields and methods. +* It provides a new "Keymanager" option for the encryption provider type. +* It overrides the default encryption and signing methods to utilize the Keymanager API when selected. + +### Benefits of Using Keymanager Integration + +* **Enhanced Security:** Key management is handled by a dedicated service, potentially with stronger security measures than what might be feasible within the OpenSPP application itself. +* **Centralized Key Management:** Provides a central location for managing encryption keys across different parts of the OpenSPP system or even across multiple applications. +* **Compliance and Auditing:** Using a dedicated Keymanager service can simplify compliance with data security regulations and facilitate auditing of cryptographic operations. +* **Scalability and Performance:** Offloading cryptographic operations to a dedicated service can potentially improve the performance and scalability of the OpenSPP application. diff --git a/docs/modules/g2p_encryption_rest_api.md b/docs/modules/g2p_encryption_rest_api.md index 42e77574..ac73ffd6 100644 --- a/docs/modules/g2p_encryption_rest_api.md +++ b/docs/modules/g2p_encryption_rest_api.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document provides an overview of the `g2p_encryption_rest_api` module within the OpenSPP ecosystem. diff --git a/docs/modules/g2p_entitlement_in_kind.md b/docs/modules/g2p_entitlement_in_kind.md new file mode 100644 index 00000000..5fdb568d --- /dev/null +++ b/docs/modules/g2p_entitlement_in_kind.md @@ -0,0 +1,27 @@ +# OpenG2P Entitlement: In-Kind Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the functionality of the OpenSPP platform specifically for managing **in-kind** entitlements within social protection programs. + +**Purpose:** + +The primary purpose of the [g2p_entitlement_in_kind](g2p_entitlement_in_kind) module is to adapt the existing OpenSPP framework for programs that distribute benefits in the form of goods or services rather than cash transfers. + +**Key Features & Functionality:** + +* **Modified Program Views:** The module customizes program views inherited from the [spp_programs](spp_programs) module to accommodate in-kind distribution workflows. This includes: + * Hiding the "Import Eligible Registrants" button as it might not be directly applicable to in-kind programs. + * Adjusting access rights for the "Enroll Eligible Registrants" button. Enrollment in in-kind programs might follow a different process requiring involvement from specific user roles like Program Validators, Cycle Approvers, and Program Managers (as defined by the [g2p_programs](g2p_programs) module). + +**Integration with other Modules:** + +* **[spp_programs](spp_programs):** This module builds upon the core program management features provided by [spp_programs](spp_programs), adapting them for in-kind distribution. +* **[spp_entitlement_in_kind](spp_entitlement_in_kind):** This module likely provides the foundational data models and logic specific to in-kind entitlements, which this module then extends with user interface elements and program-level integration. + +**Note:** + +This module is part of a larger ecosystem aimed at providing flexible and configurable tools for managing diverse social protection programs. The specific configurations and adaptations offered by this module highlight its focus on supporting programs with in-kind benefit delivery mechanisms. diff --git a/docs/modules/g2p_entitlement_voucher.md b/docs/modules/g2p_entitlement_voucher.md new file mode 100644 index 00000000..67d0d38b --- /dev/null +++ b/docs/modules/g2p_entitlement_voucher.md @@ -0,0 +1,38 @@ +# OpenG2P Entitlement: Voucher Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_entitlement_voucher](g2p_entitlement_voucher) module extends the OpenG2P Entitlement functionality by providing a mechanism to generate and manage vouchers associated with entitlements. This module is particularly useful for social protection programs that utilize vouchers as a means of delivering benefits to beneficiaries. + +## Features + +* **Voucher Generation:** The module enables the generation of vouchers for approved entitlements. This process can be automated to trigger upon entitlement approval or manually initiated by authorized users. +* **Voucher Configuration:** Program administrators can define voucher templates and configure various aspects of voucher generation, such as the file format, content, and storage location. +* **Voucher Printing:** The module provides a convenient way to print generated vouchers directly from the entitlement record. +* **Integration with Payment Files:** Leverages the [g2p_payment_files](g2p_payment_files) module to facilitate voucher creation using predefined templates and configurations. +* **Encryption Support:** Integrates with the [g2p_encryption](g2p_encryption) module to allow for the secure encryption of sensitive data within the vouchers. + +## Dependencies + +- **[g2p_encryption](g2p_encryption):** This dependency is used for encrypting sensitive data included in the vouchers. +- **[g2p_programs](g2p_programs):** This module provides the core functionality for managing social protection programs and entitlements, upon which this module builds. +- **[g2p_payment_files](g2p_payment_files):** This module provides the framework for defining and managing payment file configurations, which are utilized for voucher generation. + +## Workflow + +1. **Configuration:** Program administrators configure voucher generation settings within the [Entitlement Manager]([g2p_programs](g2p_programs)#entitlement-manager) associated with the program. This includes selecting a voucher file configuration, storage location for generated vouchers, and optional encryption settings. + +2. **Entitlement Approval:** When an entitlement is approved, the system can automatically generate a voucher based on the predefined configurations. +3. **Voucher Access:** Users can access and print the generated voucher directly from the entitlement record. + +## Benefits + +* **Streamlined Benefit Delivery:** Automating voucher generation reduces manual effort and ensures timely delivery of benefits to beneficiaries. +* **Enhanced Security:** Integration with encryption capabilities protects sensitive data stored within the vouchers. +* **Improved Accountability:** The module maintains a record of generated vouchers, providing an audit trail for tracking and accountability purposes. +* **Flexibility and Customization:** Administrators have the flexibility to tailor voucher generation and content according to program-specific requirements. diff --git a/docs/modules/g2p_openid_vci.md b/docs/modules/g2p_openid_vci.md index 097acf46..41dada36 100644 --- a/docs/modules/g2p_openid_vci.md +++ b/docs/modules/g2p_openid_vci.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/g2p_openid_vci_programs.md b/docs/modules/g2p_openid_vci_programs.md new file mode 100644 index 00000000..ca991814 --- /dev/null +++ b/docs/modules/g2p_openid_vci_programs.md @@ -0,0 +1,32 @@ +# g2p_openid_vci_programs Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The `g2p_openid_vci_programs` module extends the OpenG2P platform's OpenID Connect Verifiable Credentials Issuer functionality to generate and issue verifiable credentials specifically designed for program beneficiaries. This module builds upon the core functionalities provided by the [g2p_openid_vci](g2p_openid_vci) and [g2p_programs](g2p_programs) modules. + +## Purpose and Functionality + +This module focuses on providing a streamlined way to issue verifiable credentials that attest to a beneficiary's enrollment and status within a specific social protection program. This allows beneficiaries to possess digitally verifiable proof of their program participation, which can be beneficial for various purposes like accessing program benefits or proving eligibility. + +Here's a breakdown of the key features: + +* **Program-Specific Verifiable Credentials:** The module defines a new type of verifiable credential, "OpenG2PBeneficiaryVerifiableCredential", specifically structured to include relevant program-related information. +* **Issuance based on Program Enrollment:** It leverages the existing program enrollment data from the [g2p_programs](g2p_programs) module. Only enrolled beneficiaries can receive these verifiable credentials. +* **Integration with OpenID Connect Issuer:** This module seamlessly integrates with the OpenID Connect issuer framework established in the [g2p_openid_vci](g2p_openid_vci) module. This ensures that the issuance process adheres to OpenID Connect standards for security and interoperability. +* **Data Rich Credentials:** The issued verifiable credentials can include comprehensive information about the beneficiary, their program membership details, and other relevant data, making them valuable for various verification purposes. + +## Integration and Dependencies + +* **[g2p_openid_vci](g2p_openid_vci):** This module depends on the core OpenID Connect Verifiable Credentials Issuer functionality to manage the technical aspects of credential issuance and signing. +* **[g2p_programs](g2p_programs):** This module relies on the program enrollment data and beneficiary information managed by the [g2p_programs](g2p_programs) module. + +## Benefits + +* **Enhanced Trust and Transparency:** Verifiable credentials provide a tamper-proof and verifiable way to prove program participation, fostering trust between beneficiaries and service providers. +* **Improved Efficiency:** Digital credentials streamline verification processes, potentially reducing administrative burden and improving the efficiency of benefit delivery. +* **Empowerment of Beneficiaries:** Providing beneficiaries with verifiable credentials gives them control over their data and empowers them to prove their eligibility securely and conveniently. diff --git a/docs/modules/g2p_payment_cash.md b/docs/modules/g2p_payment_cash.md new file mode 100644 index 00000000..00df4377 --- /dev/null +++ b/docs/modules/g2p_payment_cash.md @@ -0,0 +1,34 @@ +# OpenG2P Program Payment: Cash + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the OpenG2P platform to handle cash disbursements for social protection programs. + +## Overview + +The [g2p_payment_cash](g2p_payment_cash) module provides a streamlined approach to managing and recording cash payments for entitlements within the OpenG2P system. It integrates seamlessly with the core program management functionalities offered by the [g2p_programs](g2p_programs) module and builds upon the file-based payment management system provided by the [g2p_payment_files](g2p_payment_files) module. + +## Functionality + +This module introduces: + +- **Cash Payment Manager:** A specialized payment manager dedicated to handling cash disbursements. This manager allows users to prepare payment batches, but instead of generating payment files, it directly marks the payments as "reconciled" and "paid" within the system, simulating the act of distributing cash directly to beneficiaries. + +- **Simplified Payment Workflow:** Beneficiaries with approved entitlements can have their payments processed and recorded as "paid" directly within the system. This eliminates the need for generating intermediary payment files, simplifying the workflow for cash-based programs. + +- **Integration with Entitlements:** The module extends the functionality of the `g2p.entitlement` model. A new button, "Record Cash Payment", appears on approved entitlements when the program is configured to use the Cash Payment Manager. Clicking this button initiates the cash payment process. + +## Integration + +- **[g2p_programs](g2p_programs):** This module relies on the core program management features provided by [g2p_programs](g2p_programs) for managing beneficiaries, programs, and entitlements. + +- **[g2p_payment_files](g2p_payment_files):** While this module doesn't generate payment files, it inherits the base functionality and structure of the file-based payment manager from [g2p_payment_files](g2p_payment_files). + +## Benefits + +- **Streamlined Cash Disbursements:** Simplifies the payment process for programs using cash disbursements. +- **Enhanced Record Keeping:** Ensures accurate and transparent recording of cash payments within the system. +- **Improved Efficiency:** Reduces manual processes and potential errors associated with cash handling. diff --git a/docs/modules/g2p_payment_files.md b/docs/modules/g2p_payment_files.md new file mode 100644 index 00000000..c4a83f92 --- /dev/null +++ b/docs/modules/g2p_payment_files.md @@ -0,0 +1,45 @@ +# g2p_payment_files Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_payment_files](g2p_payment_files) module extends the OpenSPP system to enable the generation and management of payment files for social protection programs. This module is particularly useful for programs that disburse payments through digital channels or require physical vouchers with QR codes or barcodes for secure and traceable transactions. + +## Purpose + +The primary purpose of this module is to: + +* **Configure Payment File Templates:** Define the structure and format of payment files (e.g., PDF, CSV) using customizable templates. +* **Generate Payment Files:** Automatically generate payment files based on configured templates and payment data from the [g2p_programs](g2p_programs) module. +* **Integrate QR Codes and Barcodes:** Embed QR codes and barcodes in payment files using configurable settings, allowing for efficient payment processing and reconciliation. +* **Manage Payment Files:** Store, organize, and access generated payment files within the OpenSPP platform. + +## Key Features + +* **Flexible File Format Support:** Supports various file formats, including PDF and CSV, to accommodate different payment channels and requirements. +* **Customizable Templates:** Allows users to define and customize payment file templates using a user-friendly interface. +* **QR Code and Barcode Generation:** Facilitates the generation and embedding of QR codes and barcodes in payment files for enhanced security and tracking. +* **Encryption Support:** Integrates with the [g2p_encryption](g2p_encryption) module to enable the encryption of sensitive data within QR codes or barcodes. +* **Batch Tag Integration:** Leverages payment batch tags from the [g2p_programs](g2p_programs) module to generate payment files for specific recipient groups or payment cycles. +* **Document Storage Integration:** Seamlessly integrates with the OpenSPP document storage system to securely store and manage generated payment files. + +## Integration with Other Modules + +* **[g2p_programs](g2p_programs):** Relies on the `g2p_programs` module for payment data, including beneficiary information, payment amounts, and payment cycles. +* **[g2p_program_documents](g2p_program_documents):** Utilizes the document storage capabilities of the `g2p_program_documents` module to manage payment file storage and retrieval. +* **[g2p_encryption](g2p_encryption):** Integrates with the `g2p_encryption` module to provide encryption options for securing sensitive payment data within QR codes and barcodes. + +## Benefits + +* **Increased Efficiency:** Automates the process of generating payment files, reducing manual effort and potential errors. +* **Enhanced Security:** Incorporates QR codes and barcodes for secure payment processing and reconciliation, minimizing fraud risks. +* **Improved Transparency:** Provides a centralized platform for managing payment files, improving transparency and accountability in payment disbursement. +* **Flexibility and Customization:** Offers flexibility in configuring payment file formats and templates to meet specific program requirements. + +## Conclusion + +The [g2p_payment_files](g2p_payment_files) module enhances the OpenSPP system by providing a robust and flexible framework for generating, managing, and securing payment files. This module streamlines payment processes, strengthens security measures, and improves the overall efficiency and transparency of social protection programs. diff --git a/docs/modules/g2p_payment_interop_layer.md b/docs/modules/g2p_payment_interop_layer.md new file mode 100644 index 00000000..85d858e5 --- /dev/null +++ b/docs/modules/g2p_payment_interop_layer.md @@ -0,0 +1,38 @@ +# OpenG2P Program Payment (Payment Interoperability Layer) Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_payment_interop_layer](g2p_payment_interop_layer) module extends the OpenG2P platform by providing a generic interoperability layer for integrating with various Digital Financial Service Providers (DFSPs) for disbursement of program payments. It offers a configurable framework to connect with DFSPs through APIs, enabling seamless and automated payment processes. + +## Features + +- **Centralized Payment Management:** Provides a unified interface within OpenG2P to manage payments across different DFSPs. +- **DFSP Agnostic:** Designed to be adaptable to various DFSPs, reducing the need for DFSP-specific integrations. +- **Automated Payment Processing:** Automates the sending of payment instructions to DFSPs, streamlining the disbursement workflow. +- **Configurable Payment Routing:** Allows administrators to configure payment rules and routing logic based on factors like payment amount, recipient location, and DFSP availability. +- **Payment Tracking and Reconciliation:** Enables real-time tracking of payment statuses and facilitates reconciliation of transactions with DFSPs. +- **Enhanced Security:** Implements security measures to ensure secure communication and protect sensitive payment data during transmission to DFSPs. + +## Dependencies + +- [g2p_registry_base](g2p_registry_base): Provides core registry functionalities and data structures used for managing beneficiary information. +- [g2p_programs](g2p_programs): Handles program management, including payment cycles and beneficiary entitlements. + +## Functionality and Integration + +This module builds upon the core OpenG2P modules by adding a dedicated layer specifically for payment interoperability. It interacts with the [g2p_programs](g2p_programs) module to retrieve payment instructions generated for program beneficiaries. It then leverages the defined configuration to translate these instructions into API requests compatible with the target DFSP. + +The module also handles the reception of payment statuses and updates the corresponding payment records within OpenG2P, ensuring synchronization between the platform and the DFSP. + +## Configuration + +The [g2p_payment_interop_layer](g2p_payment_interop_layer) module provides a user-friendly interface for configuring connections with DFSPs. This includes specifying API endpoints, authentication credentials, and any required data mapping or transformation rules. + +## Usage + +Once configured, the module seamlessly integrates into the existing OpenG2P payment workflow. When a payment cycle is triggered, the module automatically handles the communication with the appropriate DFSP, simplifying the disbursement process for program administrators. diff --git a/docs/modules/g2p_payment_phee.md b/docs/modules/g2p_payment_phee.md new file mode 100644 index 00000000..c56337ae --- /dev/null +++ b/docs/modules/g2p_payment_phee.md @@ -0,0 +1,44 @@ +# g2p_payment_phee Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the OpenG2P platform to integrate with the **Payment Hub Enterprise Edition (PHEE)** for disbursing payments to beneficiaries. + +### Overview + +The [g2p_payment_phee](g2p_payment_phee) module provides a dedicated payment manager for interacting with the PHEE API. This manager enables automated batch creation, payment preparation, and secure transmission of payment instructions to the PHEE system. + +### Key Features + +* **PHEE Integration:** Enables seamless integration with the PHEE platform for efficient payment processing. +* **Payment Manager:** Introduces a specialized `G2PPaymentHubEEManager` model that handles PHEE-specific payment operations. +* **Automated Batch Creation:** Supports automatic creation of payment batches, streamlining the disbursement process. +* **CSV File Generation:** Generates CSV files containing payment instructions in the format required by PHEE. +* **Configuration Settings:** Allows administrators to configure PHEE API endpoints, authentication credentials, and other payment-related parameters. + +### Dependencies + +* **[g2p_registry_base](g2p_registry_base):** Provides core registry functionality. +* **[g2p_programs](g2p_programs):** Manages social protection programs, cycles, entitlements, and payments. + +### Functionality and Integration + +This module extends the functionality of the [g2p_programs](g2p_programs) module by adding a PHEE-specific payment manager. It leverages existing data structures for programs, cycles, entitlements, and payments to generate payment instructions. + +The module's payment manager automates the process of: + +1. **Preparing Payments:** Creating payment records associated with approved entitlements. +2. **Batching Payments:** Grouping payments into batches based on configurable parameters. +3. **Generating CSV Files:** Creating CSV files containing payment details in the PHEE-compliant format. +4. **Sending Payments:** Transmitting payment batches to the PHEE API for processing. + +### Configuration + +The module provides configuration settings for specifying PHEE API endpoints, authentication credentials, and other parameters. This allows administrators to tailor the integration to their specific PHEE environment. + +### Usage + +Once configured, the PHEE payment manager can be used to prepare, batch, and send payments to beneficiaries. The module's automated features streamline the disbursement process, enhancing efficiency and reducing manual intervention. diff --git a/docs/modules/g2p_payment_simple_mpesa.md b/docs/modules/g2p_payment_simple_mpesa.md new file mode 100644 index 00000000..c39655ed --- /dev/null +++ b/docs/modules/g2p_payment_simple_mpesa.md @@ -0,0 +1,39 @@ +# g2p_payment_simple_mpesa + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The `g2p_payment_simple_mpesa` module provides a simple interface to manage payments for social protection programs using the Mpesa mobile money platform. + +This module builds upon the existing payment manager framework provided by the [g2p_programs](g2p_programs) module and extends it with Mpesa specific functionality. + +## Functionality + +The module allows program managers to: + +* Configure connection details to an Mpesa payment gateway, including authentication and payment endpoint URLs, API timeout, username, and password. +* Select the appropriate payee identification field (e.g., phone number, email, bank account number) from available options. +* Automatically create payment batches for efficient processing. +* Trigger the payment process to transfer funds to beneficiaries via Mpesa. +* Monitor the status of individual payments and batches. + +## Integration + +* **[g2p_programs](g2p_programs):** This module inherits and extends the base payment manager model (`g2p.program.payment.manager`) provided by the `g2p_programs` module, integrating seamlessly with the existing program and payment batch management functionalities. +* **[g2p_registry_base](g2p_registry_base):** Leverages the registry system for accessing beneficiary information such as phone numbers or other chosen identifiers for payment disbursement. + +## Key Features: + +* **Simplified Mpesa Integration:** Provides a straightforward configuration process for connecting to an Mpesa payment gateway. +* **Automated Batch Processing:** Automates the creation and processing of payment batches, reducing manual effort. +* **Flexible Payee Identification:** Supports various payee identification methods, enabling flexibility in program design. +* **Real-time Status Tracking:** Allows monitoring of payment status at both the individual and batch level. + +## Limitations: + +* **Simple Integration:** This module is designed for basic Mpesa integrations. More complex workflows or specific API requirements might necessitate customization. +* **Limited Error Handling:** While the module provides basic error handling, a more robust error logging and recovery mechanism could be beneficial for mission-critical implementations. diff --git a/docs/modules/g2p_program_approval.md b/docs/modules/g2p_program_approval.md new file mode 100644 index 00000000..fea35309 --- /dev/null +++ b/docs/modules/g2p_program_approval.md @@ -0,0 +1,36 @@ +# OpenG2P Program Approval Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_program_approval](g2p_program_approval) module enhances the OpenG2P [g2p_programs](g2p_programs) module by introducing an approval workflow for entitlements. This module enables program managers to define multi-stage approval processes, assign approval rights to user groups, and track the approval status of individual entitlements. + +## Features + +* **Multi-stage Approval Workflow:** Define custom approval stages with specific states and responsible user groups. +* **Granular Approval Rights:** Assign approval permissions to different user groups at each stage of the workflow. +* **Approval Status Tracking:** Monitor the approval status of individual entitlements throughout the approval process. +* **Seamless Integration:** Integrates directly with the [g2p_programs](g2p_programs) module, extending its functionality. + +## Functionality and Integration + +The [g2p_program_approval](g2p_program_approval) module extends the functionality of the [g2p_programs](g2p_programs) module by adding the following features: + +* **Approval Mapping:** Program managers can define a sequence of approval stages for entitlements using the `ProgramApprovalMapping` model. Each stage is associated with a state, a responsible user group, and an optional sequence number. +* **Entitlement Manager Approval:** The `DefaultEntitlementManagerApproval` model is extended to manage the approval process. It uses the defined approval mapping to determine the next stage and responsible group for each entitlement. +* **Entitlement Approval Status:** The `G2PApprovalEntitlement` model, which inherits from the `g2p.entitlement` model in [g2p_programs](g2p_programs), now includes an `approval_state` field to track the current approval status of the entitlement. +* **User Interface Enhancements:** The module modifies the user interface to display the approval status of entitlements and provide buttons for approving or rejecting them. + +## Benefits + +* **Enhanced Accountability:** The approval workflow enforces accountability by clearly defining roles and responsibilities for approving entitlements. +* **Improved Transparency:** Tracking the approval status of entitlements provides transparency into the decision-making process. +* **Streamlined Workflow:** Automating the approval process reduces manual effort and improves the efficiency of entitlement management. + +## Conclusion + +The [g2p_program_approval](g2p_program_approval) module enhances the OpenG2P platform by providing a robust and customizable approval workflow for managing entitlements. By integrating seamlessly with the [g2p_programs](g2p_programs) module, it strengthens the platform's capabilities for managing social protection programs effectively. diff --git a/docs/modules/g2p_program_assessment.md b/docs/modules/g2p_program_assessment.md new file mode 100644 index 00000000..577d57ca --- /dev/null +++ b/docs/modules/g2p_program_assessment.md @@ -0,0 +1,38 @@ +# g2p_program_assessment Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module enhances the OpenSPP system by adding assessment functionality to the [g2p_programs](g2p_programs) module. + +## Purpose + +The primary purpose of this module is to facilitate the assessment process within social protection programs. It allows program managers to record assessments for individual beneficiaries at various stages of program participation. + +## Functionality + +The [g2p_program_assessment](g2p_program_assessment) module provides the following key features: + +* **Assessment Recording:** Program staff can record assessments associated with a beneficiary's program membership. +* **Assessment History:** Maintains a history of all assessments conducted for a beneficiary, including the date, author, and content of each assessment. +* **Integration with Entitlements:** Assessments are linked to beneficiary entitlements, providing valuable context for entitlement decisions. +* **Rejection Workflow:** Offers a streamlined process to reject beneficiary applications based on assessments. +* **Comments and Notes:** Enables program staff to add comments and notes to both assessments and beneficiary entitlements. + +## Integration with other Modules + +* **[g2p_programs](g2p_programs):** This module directly extends the functionality of [g2p_programs](g2p_programs) by adding assessment capabilities to program memberships. +* **mail:** Leverages the **mail** module to facilitate communication, allowing users to post assessments as messages and add comments. + +## Workflow + +1. **Assessment Preparation:** Program staff can initiate the assessment process for beneficiaries, recording their findings and observations. +2. **Assessment Review:** The module provides a centralized location to review all assessments associated with a beneficiary's program participation. +3. **Entitlement Decisions:** Assessments provide valuable input for making informed decisions regarding beneficiary entitlements. +4. **Application Rejection:** If necessary, program staff can reject a beneficiary's application based on the assessment outcomes. +5. **Communication and Collaboration:** The module facilitates communication and collaboration among program staff through comments and messaging features. + +By integrating assessments into the beneficiary management process, this module promotes transparency, accountability, and data-driven decision-making within DCI social protection programs. + diff --git a/docs/modules/g2p_program_autoenrol.md b/docs/modules/g2p_program_autoenrol.md new file mode 100644 index 00000000..c35142d7 --- /dev/null +++ b/docs/modules/g2p_program_autoenrol.md @@ -0,0 +1,47 @@ +# g2p_program_autoenrol Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the functionality of the [g2p_programs](g2p_programs) module to enable automatic enrollment of registrants into social protection programs based on predefined criteria. This feature simplifies program management by automating the enrollment process for eligible individuals. + +### Purpose + +The main purpose of the `g2p_program_autoenrol` module is to streamline and automate the process of enrolling beneficiaries into social protection programs. It achieves this by providing the following capabilities: + +- **Automatic Enrollment:** When a new registrant is created in the system, the module automatically checks for programs configured with auto-enrollment rules. +- **Eligibility Criteria:** Program administrators can define specific eligibility criteria using Odoo's domain syntax. This allows them to target specific demographics or groups based on pre-defined attributes stored in registrant profiles. +- **Program-Specific Enrollment:** Auto-enrollment can be enabled or disabled on a per-program basis, providing flexibility in managing different types of programs. +- **Optional Removal of Ineligible Registrants:** Administrators have the option to automatically remove registrants from a program's membership list if they do not meet the defined eligibility criteria. This ensures that only eligible individuals are considered beneficiaries. + +### Functionality + +The module introduces the following key features: + +- **New Fields in Program Configuration:** + - **Auto Enrol Partners:** A boolean field to enable or disable auto-enrollment for the specific program. + - **Filter for Partners:** A text field utilizing Odoo's domain syntax to define the criteria for automatic enrollment. This allows administrators to specify which registrants should be automatically enrolled based on their profile attributes. + - **Keep only Eligible Partners:** A boolean field that, when checked, will automatically remove registrants from the program's membership if they do not meet the defined eligibility criteria. + +- **Automatic Enrollment upon Registrant Creation:** + - When a new registrant is created in the system, the module automatically checks for programs that have auto-enrollment enabled. + - If the registrant meets the defined criteria for a specific program, they are automatically enrolled. + - An automatic check for eligibility is performed, and if the "Keep only Eligible Partners" option is activated, ineligible registrants are removed from the program membership. + +- **Impact on Program Statistics:** + - The module ensures that program statistics, such as the count of eligible and total beneficiaries, are updated dynamically to reflect the results of the automatic enrollment process. + +### Integration + +The [g2p_program_autoenrol](g2p_program_autoenrol) module works seamlessly with the [g2p_programs](g2p_programs) module. It leverages the existing program and registrant data structures and extends their functionality. + +### Benefits + +- **Reduced Administrative Burden:** Automating the enrollment process significantly reduces the manual effort required by program administrators. +- **Improved Accuracy:** By automating enrollment based on pre-defined criteria, the module minimizes the risk of human error and ensures consistent application of eligibility rules. +- **Enhanced Targeting:** The ability to define specific eligibility criteria allows programs to effectively target the intended beneficiaries, maximizing impact and resource utilization. +- **Increased Efficiency:** Automatic enrollment accelerates the process of onboarding eligible individuals into social protection programs. + +By automating a crucial aspect of program management, the [g2p_program_autoenrol](g2p_program_autoenrol) module contributes to the overall efficiency and effectiveness of social protection initiatives. It empowers organizations to deliver timely and targeted support to those in need. diff --git a/docs/modules/g2p_program_cycleless.md b/docs/modules/g2p_program_cycleless.md new file mode 100644 index 00000000..1ffbbfaa --- /dev/null +++ b/docs/modules/g2p_program_cycleless.md @@ -0,0 +1,42 @@ +# OpenG2P Programs: Cycleless Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_program_cycleless](g2p_program_cycleless) module extends the functionality of the [g2p_programs](g2p_programs) module to support **cycleless** social protection programs. + +Traditional social protection programs often operate in cycles, with distinct periods for enrollment, payment preparation, and disbursement. However, some programs, especially those focused on **continuous or on-demand support**, may benefit from a cycleless approach. + +This module allows program managers to designate a program as **cycleless**, eliminating the need to manage distinct program cycles. This simplifies program administration and provides greater flexibility in managing beneficiary entitlements and payments. + +## Key Features + +* **Cycleless Program Designation:** The module adds a new field to the `g2p.program` model, allowing administrators to mark a program as cycleless. +* **Simplified Interface:** For cycleless programs, the user interface is adapted to hide cycle-related elements, presenting a more streamlined experience. +* **Automatic Cycle Management:** When a program is marked as cycleless, the module automatically manages a single, always-active cycle in the background. This simplifies program operations without sacrificing the underlying data structure. +* **Unified Entitlement Management:** Beneficiary entitlements are managed within the context of the always-active cycle, providing a unified view for administrators. +* **Streamlined Payment Processing:** Payment preparation and disbursement processes are adapted for the cycleless model. + +## Integration with Other Modules + +This module directly extends the [g2p_programs](g2p_programs) module. It leverages existing data structures and functionalities from this module, such as: + +* **Program Model:** Utilizes the `g2p.program` model to manage program configurations and settings. +* **Cycle Model:** Leverages the `g2p.cycle` model to represent the always-active cycle in the background. +* **Entitlement Management:** Integrates with the entitlement management functionalities provided by the [g2p_programs](g2p_programs) module. + +## Benefits of Using the Cycleless Module + +* **Simplified Program Administration:** Reduced complexity for programs that do not require distinct operational cycles. +* **Increased Flexibility:** Enables more dynamic and responsive program delivery, particularly for on-demand or continuous support programs. +* **Streamlined User Experience:** Provides a more intuitive interface for managing cycleless programs. + +## Use Cases + +* **Emergency Cash Transfers:** Rapidly provide assistance to beneficiaries in response to unforeseen events without the need for pre-defined cycles. +* **Conditional Cash Transfers with Rolling Enrollment:** Allow beneficiaries to enroll and become eligible for benefits on an ongoing basis, rather than within fixed enrollment periods. +* **Continuous Social Assistance:** Support programs that provide ongoing assistance based on evolving needs and circumstances, such as disability benefits. diff --git a/docs/modules/g2p_program_documents.md b/docs/modules/g2p_program_documents.md new file mode 100644 index 00000000..e2f14b48 --- /dev/null +++ b/docs/modules/g2p_program_documents.md @@ -0,0 +1,40 @@ +# g2p_program_documents Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_program_documents](g2p_program_documents) module extends the OpenG2P framework to incorporate document management capabilities within social protection programs. This module builds upon the functionalities provided by the [g2p_documents](g2p_documents) and [g2p_programs](g2p_programs) modules. + +## Purpose + +This module aims to streamline the handling of supporting documents throughout the lifecycle of a social protection program. It enables the association of documents with various program elements, including: + +* **Programs:** Defining a designated document storage backend for each program. +* **Program Memberships:** Uploading and managing supporting documents for individual beneficiary program memberships. +* **Entitlements:** Linking relevant documents to specific entitlements within a program. + +## Functionality + +* **Program-Level Document Storage:** + * Administrators can configure a specific storage backend for each program to centrally manage supporting documents. +* **Document Attachment to Program Memberships:** + * Beneficiaries or program staff can upload supporting documents during the program enrollment process or at any point during their membership. + * Documents associated with a program membership are accessible from the beneficiary's profile. +* **Document Linking to Entitlements:** + * Relevant documents can be linked to individual entitlements, providing evidence or context for approval processes. + * When new entitlements are created, the module attempts to automatically copy relevant documents from the beneficiary's program membership or previous entitlements. +* **Document Preview:** + * The module provides a built-in document preview mechanism for supported file types, allowing users to view documents directly within the OpenG2P interface. + +## Integration + +* **[g2p_documents](g2p_documents):** Leverages the core document management functionalities provided by this module for document storage, retrieval, and preview. +* **[g2p_programs](g2p_programs):** Extends the existing program management features by integrating document handling capabilities into program definitions, beneficiary memberships, and entitlements. + +## Security + +The module inherits security groups from the [g2p_documents](g2p_documents) module, ensuring that only authorized users can access, upload, or manage documents. This includes roles such as program validators, cycle approvers, program managers, and finance validators. diff --git a/docs/modules/g2p_program_registrant_info.md b/docs/modules/g2p_program_registrant_info.md new file mode 100644 index 00000000..e06037af --- /dev/null +++ b/docs/modules/g2p_program_registrant_info.md @@ -0,0 +1,43 @@ +# G2P Program: Registrant Info Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_program_registrant_info](g2p_program_registrant_info) module enhances the functionality of the OpenSPP by introducing the concept of program-specific application information for registrants. This module allows program managers to collect and store additional data from registrants during the application process, which can be used to assess eligibility, track progress, and manage program participation. + +## Features + +* **Program-Specific Information:** Captures and stores program-specific information during the registrant's application process. +* **Application Tracking:** Assigns a unique application ID to each application and allows tracking of its status throughout the program lifecycle. +* **Integration with Programs and Memberships:** Seamlessly integrates with the [g2p_programs](g2p_programs) and [g2p_registry_individual](g2p_registry_individual) modules to associate application information with specific programs and registrants. +* **Dynamic Data Collection:** Employs a flexible JSON field to accommodate various data structures and program-specific requirements. +* **Improved Decision Making:** Provides program managers with comprehensive information to facilitate informed decisions regarding eligibility and enrollment. + +## Functionality and Integration + +The module introduces a new model, `g2p.program.registrant_info`, which stores program-specific information submitted by registrants. Each record in this model represents an application instance and is linked to: + +* **Registrant:** The individual or group applying to the program (`res.partner` model). +* **Program:** The specific program to which the registrant is applying ([g2p.program](g2p_program) model). +* **Program Membership:** The registrant's membership in the program, if approved ([g2p.program_membership](g2p_program_membership) model). + +The module also extends the functionality of the `g2p.program_membership` model to include a one-to-many relationship with `g2p.program.registrant_info`, enabling tracking of multiple applications by the same registrant to the same program. + +The [g2p_program_registrant_info](g2p_program_registrant_info) module is designed to work in conjunction with the following modules: + +* **[g2p_programs](g2p_programs):** Manages program definitions and lifecycles. +* **[g2p_registry_individual](g2p_registry_individual):** Manages individual registrant information. +* **[g2p_registry_group](g2p_registry_group):** Manages group registrant information. + +## Benefits + +* **Enhanced Data Collection:** Allows programs to capture specific data points relevant to their operations. +* **Improved Application Management:** Facilitates efficient tracking and processing of registrant applications. +* **Data-Driven Decision Making:** Provides program managers with the necessary information to make informed decisions regarding eligibility and enrollment. +* **Increased Transparency and Accountability:** Creates a clear and auditable record of the application process. + +This module contributes to the overall efficiency and effectiveness of social protection programs by providing a structured and comprehensive approach to managing registrant information during the crucial application stage. diff --git a/docs/modules/g2p_program_registrant_info_rest_api.md b/docs/modules/g2p_program_registrant_info_rest_api.md new file mode 100644 index 00000000..1dc89469 --- /dev/null +++ b/docs/modules/g2p_program_registrant_info_rest_api.md @@ -0,0 +1,30 @@ +# G2P Program: Program Registrant Info REST API + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the functionality of the [g2p_programs_rest_api](g2p_programs_rest_api) and [g2p_program_registrant_info](g2p_program_registrant_info) modules to expose program registrant information via a REST API. This allows external systems to interact with and manage program-specific data associated with registrants. + +### Functionality: + +- **Exposes Program Registrant Info:** Provides API endpoints to access and manipulate program-specific information of registrants within a program. This includes data such as enrollment status, benefit level, and other custom fields defined for the program. + +### Integration: + +- **[g2p_programs_rest_api](g2p_programs_rest_api):** This module extends the existing API endpoints for managing program memberships. It adds fields to include program registrant information when retrieving or updating memberships. +- **[g2p_program_registrant_info](g2p_program_registrant_info):** This module utilizes the data models defined in `g2p_program_registrant_info` to represent and handle program-specific information. + +### Data Models: + +- **ProgramRegistrantInfoOut:** Represents the output format of program registrant information returned by the API. It includes fields like `state` and a dictionary or list of dictionaries for `program_registrant_info`. +- **ProgramMembershipIn/Out:** Extends the existing input and output models for program memberships defined in [g2p_programs_rest_api](g2p_programs_rest_api). The `ProgramMembershipIn` model adds an optional field `program_registrant_info` for receiving program-specific data. The `ProgramMembershipOut` model includes a list of `ProgramRegistrantInfoOut` objects under the field `program_registrant_info_ids`. + +### Benefits: + +- **Seamless Integration:** Enables external applications to access and manage program-specific registrant data directly. +- **Enhanced Data Management:** Facilitates efficient handling and updating of program-related information for individual registrants. +- **Improved Interoperability:** Promotes interoperability between the OpenSPP system and other systems requiring access to program registrant details. + +This module is essential for integrating OpenSPP with external systems that need to interact with program-specific information of registrants. It provides a structured and secure way to access and manage this data, further enhancing the efficiency and transparency of social protection programs. diff --git a/docs/modules/g2p_program_reimbursement.md b/docs/modules/g2p_program_reimbursement.md new file mode 100644 index 00000000..87075de7 --- /dev/null +++ b/docs/modules/g2p_program_reimbursement.md @@ -0,0 +1,44 @@ +# OpenG2P Programs: Reimbursement Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_program_reimbursement](g2p_program_reimbursement) module extends the OpenG2P platform to manage reimbursement programs. These programs differ from standard social assistance programs, focusing on reimbursing pre-approved service providers for delivering goods or services to beneficiaries. + +This module builds upon the core functionality of the [g2p_programs](g2p_programs) and [g2p_program_assessment](g2p_program_assessment) modules. + +## Features + +* **Reimbursement Program Designation:** Designate specific programs as "reimbursement programs" within the system. +* **Service Provider Management:** Manage service providers as participants in reimbursement programs. The module leverages the existing `res.partner` model, filtering and displaying partners designated as "Service Providers". +* **Reimbursement Claim Submission:** Enables service providers to submit reimbursement claims for services rendered to beneficiaries. +* **Claim Validation and Approval:** Provides a structured workflow to validate and approve submitted reimbursement claims. +* **Integration with Entitlements:** Seamlessly integrates with the entitlement system to generate and track reimbursements. + +## Key Concepts + +* **Reimbursement Program:** A specialized type of program within OpenG2P that manages the reimbursement of pre-approved service providers. +* **Service Provider:** A business or individual registered in the system to provide goods or services to beneficiaries and eligible for reimbursement. +* **Reimbursement Claim:** A formal request submitted by a service provider for reimbursement of rendered services. +* **Original Entitlement:** In cases where a reimbursement is directly linked to a beneficiary's existing entitlement, this refers to the initial entitlement against which the service was provided. + +## Module Integration + +The [g2p_program_reimbursement](g2p_program_reimbursement) module seamlessly integrates with the following modules: + +* **[g2p_programs](g2p_programs):** Inherits core program management features and extends them to accommodate reimbursement program specifics. +* **[g2p_program_assessment](g2p_program_assessment):** Leverages assessment functionalities to potentially support the validation of reimbursement claims. + +## Example Use Case + +1. **Program Setup:** A government agency sets up a reimbursement program for agricultural inputs. They register fertilizer suppliers as service providers in the system. +2. **Beneficiary Entitlement:** A farmer is assessed and granted an entitlement for a specific type and quantity of fertilizer. +3. **Service Delivery & Claim:** The farmer redeems their entitlement from a registered fertilizer supplier. The supplier then submits a reimbursement claim through the system, referencing the farmer's original entitlement and providing necessary documentation. +4. **Claim Review & Approval:** The claim undergoes review and approval by the program administrators. +5. **Reimbursement Processing:** Once approved, the system generates a reimbursement payment to the supplier. + +This module streamlines the management of reimbursement programs, improves transparency, and ensures efficient service delivery to beneficiaries. diff --git a/docs/modules/g2p_programs.md b/docs/modules/g2p_programs.md index 2d5ceec8..d4102d0d 100644 --- a/docs/modules/g2p_programs.md +++ b/docs/modules/g2p_programs.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document details the **G2P Programs** module within the OpenSPP platform. This module is responsible for defining and managing the core aspects of social protection programs, including eligibility criteria, program cycles, entitlement management, and payment processing. @@ -56,7 +56,6 @@ The **G2P Programs** module provides a comprehensive framework for: * Enables SMS notifications for program-related events, including enrollment confirmations, eligibility updates, payment notifications, and reminders. * Leverages the module's SMS gateway integration for efficient and timely communication with beneficiaries. - ### Additional Functionality * **Program Model (g2p.program)**: diff --git a/docs/modules/g2p_programs_rest_api.md b/docs/modules/g2p_programs_rest_api.md new file mode 100644 index 00000000..2dc5bffd --- /dev/null +++ b/docs/modules/g2p_programs_rest_api.md @@ -0,0 +1,35 @@ +# G2P Programs REST API Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [`g2p_programs_rest_api`](g2p_programs_rest_api) module extends the functionality provided by the [`g2p_registry_rest_api`](g2p_registry_rest_api) and [`g2p_programs`](g2p_programs) modules to expose program-related data and operations through a REST API. + +## Functionality + +This module focuses on integrating program information with the registry data. It allows external systems to: + +- **Manage program memberships:** Create, read, update, and delete program membership information for registrants. +- **Retrieve program-specific registrant data:** Access registrant information enriched with their program memberships, including enrollment and exit dates. +- **Manage program memberships for groups:** Handle program membership data within the context of groups registered in the system. + +## Data Models + +This module introduces new data structures and extends existing ones from the [`g2p_registry_rest_api`](g2p_registry_rest_api) module: + +- **`RegistrantProgramMembershipIn`** and **`RegistrantProgramMembershipOut`**: Represent program membership information for individual registrants, including enrollment and exit dates. +- **`RegistrantProgramMemberInfoIn`** and **`RegistrantProgramMemberInfoOut`**: Extend the `RegistrantInfoIn` and `RegistrantInfoOut` models from [`g2p_registry_rest_api`](g2p_registry_rest_api) to include program membership details. +- **`GroupMembersInfoIn`**: Extends the `GroupMembersInfoIn` model from [`g2p_registry_rest_api`](g2p_registry_rest_api) to include program membership details for members of a group. + +## Integration + +The [`g2p_programs_rest_api`](g2p_programs_rest_api) module seamlessly integrates with: + +- **[`g2p_registry_rest_api`](g2p_registry_rest_api)**: It leverages the existing API infrastructure and data models for registrants and groups. +- **[`g2p_programs`](g2p_programs)**: It interacts with this module to retrieve and manage program-related data within the DCI system. + +This module enables efficient data exchange and synchronization between the OpenSPP system and external systems that require access to program and beneficiary information. diff --git a/docs/modules/g2p_proxy_means_test.md b/docs/modules/g2p_proxy_means_test.md new file mode 100644 index 00000000..c33e233b --- /dev/null +++ b/docs/modules/g2p_proxy_means_test.md @@ -0,0 +1,30 @@ +# G2P: Proxy Means Test Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the OpenSPP system to incorporate **Proxy Means Testing (PMT)** functionality into social protection programs. It enables program administrators to define and configure PMT parameters, automatically calculate PMT scores for registrants, and leverage these scores for program targeting and enrollment. + +## Features: + +- **PMT Configuration:** Enables program administrators to enable PMT for specific programs and define the parameters used in the PMT calculation ([g2p_programs](g2p_programs)). +- **Parameter Definition:** Allows administrators to select specific fields from the registrant information form ([g2p_program_registrant_info](g2p_program_registrant_info)) and assign weightages to these fields, effectively defining the PMT formula. +- **Automatic Score Calculation:** Automatically calculates and stores the PMT score for each registrant based on their provided information and the defined PMT parameters. +- **Score Visibility:** Displays the calculated PMT score on relevant forms, including the registrant information form, program membership form, and individual/group views, providing stakeholders with easy access to this information. + +## Integration and Dependencies: + +- **[g2p_programs](g2p_programs):** This module integrates with the core `g2p_programs` module to add PMT configuration options to program definitions. +- **[g2p_program_registrant_info](g2p_program_registrant_info):** This module extends the functionality of `g2p_program_registrant_info` to include: + - Calculation and storage of the PMT score. + - Dynamic retrieval of available fields for PMT parameter definition. + - Logic to delete related PMT parameters when a field is deleted. + +## Benefits: + +- **Improved Targeting:** Enables programs to target beneficiaries more effectively based on their socio-economic status. +- **Enhanced Efficiency:** Automates the PMT calculation process, reducing administrative burden and potential for errors. +- **Increased Transparency:** Provides a clear and auditable method for determining program eligibility. +- **Data-Driven Decision Making:** Empowers program administrators to make data-informed decisions regarding program enrollment and resource allocation. diff --git a/docs/modules/g2p_registry_addl_info.md b/docs/modules/g2p_registry_addl_info.md new file mode 100644 index 00000000..1b5e0e12 --- /dev/null +++ b/docs/modules/g2p_registry_addl_info.md @@ -0,0 +1,38 @@ +# G2P Registry: Additional Info Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_registry_addl_info](g2p_registry_addl_info) module extends the OpenSPP platform by providing a flexible mechanism for capturing and managing additional, program-specific information for both individual and group registrants. + +## Purpose + +This module aims to address the need for capturing data points that are not part of the core registrant information but are crucial for specific social protection programs. It achieves this by adding a dedicated "Additional Information" section to both individual and group registrant forms. + +## Functionality + +The module introduces the following key features: + +- **JSON Field for Additional Information:** A dedicated JSON field `additional_g2p_info` is added to the `res.partner` model. This field allows storing unstructured data, providing flexibility in capturing diverse program-specific information. +- **Customizable Input Widget:** A dedicated Javascript widget `g2p_registry_addl_info_widget` is used to render and manage the content of the `additional_g2p_info` field. This allows for dynamic and user-friendly data entry tailored to the specific requirements of different programs. +- **Integration with Registrant Forms:** The "Additional Information" section is seamlessly integrated into both the [g2p_registry_individual](g2p_registry_individual) and [g2p_registry_group](g2p_registry_group) forms, ensuring that program implementers can easily access and manage this additional data. + +## Dependencies + +The [g2p_registry_addl_info](g2p_registry_addl_info) module depends on the following modules: + +- [g2p_registry_base](g2p_registry_base): Provides the foundational framework for the G2P registry. +- [g2p_registry_individual](g2p_registry_individual): Enables the registration and management of individual registrants. +- [g2p_registry_group](g2p_registry_group): Facilitates the registration and management of group registrants. + +## Benefits + +- **Enhanced Data Capture:** Enables capturing a wider range of data points relevant to specific social protection programs. +- **Program Flexibility:** Accommodates diverse data needs without requiring code-level modifications. +- **Improved Data Management:** Provides a structured approach to managing additional registrant information. + +By providing a flexible and extensible mechanism for managing additional registrant information, the [g2p_registry_addl_info](g2p_registry_addl_info) module empowers program implementers to effectively tailor OpenSPP to the unique requirements of their social protection initiatives. diff --git a/docs/modules/g2p_registry_addl_info_rest_api.md b/docs/modules/g2p_registry_addl_info_rest_api.md new file mode 100644 index 00000000..8c4e0575 --- /dev/null +++ b/docs/modules/g2p_registry_addl_info_rest_api.md @@ -0,0 +1,30 @@ +# G2P Registry: Additional Info REST API Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module extends the functionality of the [g2p_registry_rest_api](g2p_registry_rest_api) and [g2p_registry_addl_info](g2p_registry_addl_info) modules by providing API endpoints for managing additional G2P (Government-to-Person) information associated with registrants and group memberships. + +### Functionality and Integration + +This module introduces two new classes: + +- **RegistrantAddlInfoIn** and **RegistrantAddlInfoOut**: These classes, extending the existing `RegistrantInfoIn` and `RegistrantInfoOut` classes from the [g2p_registry_rest_api](g2p_registry_rest_api) module, add fields for handling additional G2P information during data input and output for individual registrants. This allows external systems to read and write this custom information through the API. + +- **GroupMembersInfoIn**: This class extends the `GroupMembersInfoIn` class from the [g2p_registry_rest_api](g2p_registry_rest_api) module and adds a field for managing additional G2P information associated with group memberships. This facilitates exchanging custom group-related data via the API. + +By integrating with the core registry and REST API modules, this module enables a seamless flow of additional G2P data, ensuring that external systems can access and manage this crucial information alongside the standard registry data. + +### Key Features: + +- **API Endpoints for Additional G2P Info:** Provides dedicated API endpoints for managing additional G2P information related to individual registrants and group memberships. +- **Data Model Extension:** Extends the existing data models for registrants and group memberships to accommodate additional G2P information. +- **Seamless Integration:** Integrates smoothly with the [g2p_registry_rest_api](g2p_registry_rest_api) module, leveraging its existing infrastructure for authentication, authorization, and data handling. + +### Benefits: + +- **Enhanced Data Management:** Enables efficient management of custom G2P data alongside standard registry information. +- **Improved Interoperability:** Facilitates data exchange with external systems that require access to additional G2P information. +- **Flexibility and Customization:** Allows for tailored data structures to meet the specific needs of different social protection programs. diff --git a/docs/modules/g2p_registry_base.md b/docs/modules/g2p_registry_base.md index b97b801b..c993cf48 100644 --- a/docs/modules/g2p_registry_base.md +++ b/docs/modules/g2p_registry_base.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **G2P Registry: Base** module within the OpenSPP ecosystem. This module is the foundational layer upon which other OpenSPP registry modules are built. It provides core features for managing registrant data, relationships, and identification, leaving specialized functionalities to dependent modules. @@ -29,7 +29,6 @@ The **G2P Registry: Base** module aims to: 3. **Portal (portal)**: The Portal module is utilized for potential future features, enabling secure access to registry data for external stakeholders (e.g., registrants themselves) through a dedicated online portal. - ### Additional Functionality Beyond extending the Contacts module, the **G2P Registry: Base** module introduces: diff --git a/docs/modules/g2p_registry_encryption.md b/docs/modules/g2p_registry_encryption.md new file mode 100644 index 00000000..33d622a9 --- /dev/null +++ b/docs/modules/g2p_registry_encryption.md @@ -0,0 +1,40 @@ +# G2P Registry: Encryption Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_registry_encryption](g2p_registry_encryption) module adds an encryption layer to the OpenSPP registry system. It allows sensitive registry data to be stored securely, enhancing the system's overall privacy and security. This module builds upon the functionality provided by the [g2p_encryption](g2p_encryption), [g2p_registry_base](g2p_registry_base) and [g2p_registry_individual](g2p_registry_individual) modules. + +## Features + +- **Selective Encryption:** Encrypts specific fields of the `res.partner` model that contain sensitive registrant information like name, address, and birth place. +- **Configurable Encryption Provider:** Allows administrators to select and configure the desired encryption provider from the available options within OpenSPP. +- **On-the-fly Encryption and Decryption:** Transparently encrypts data upon saving a record and decrypts it when retrieved, ensuring a seamless user experience. +- **Granular Control:** Provides options to enable or disable encryption and decryption through system configuration settings. + +## Integration + +- **[g2p_encryption](g2p_encryption):** Utilizes the encryption providers and functionalities provided by this module to perform the actual encryption and decryption operations. +- **[g2p_registry_base](g2p_registry_base) and [g2p_registry_individual](g2p_registry_individual):** Extends the existing registry data models and views to accommodate the encryption features. + +## Configuration + +The module can be configured through the OpenSPP settings interface: + +1. **Encryption Provider:** Choose the preferred encryption provider from the list of configured providers. +2. **Enable Encryption:** Toggle the "Encrypt Registry fields" option to enable encryption for the specified fields. +3. **Enable Decryption (Caution):** This option allows decryption of registry fields. Use with caution, as enabling it might expose sensitive data. It is generally recommended to keep this disabled unless explicitly required. + +## Security Considerations + +While this module enhances data security, it is crucial to remember that the overall system's security relies on several factors: + +- **Encryption Key Management:** Securely store and manage the encryption keys used by the chosen provider. +- **Access Control:** Implement strict access control measures to prevent unauthorized access to sensitive data and configuration settings. +- **Regular Security Audits:** Conduct periodic security audits and updates to mitigate potential vulnerabilities. + +By carefully configuring and integrating this module into the OpenSPP ecosystem, implementers can significantly improve the protection of sensitive registry data. diff --git a/docs/modules/g2p_registry_group.md b/docs/modules/g2p_registry_group.md index 74e2310c..ba1f4d9e 100644 --- a/docs/modules/g2p_registry_group.md +++ b/docs/modules/g2p_registry_group.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **G2P Registry: Groups** module within the OpenSPP framework. This module builds upon the **G2P Registry: Base** module to provide specific functionality for managing groups of registrants. diff --git a/docs/modules/g2p_registry_individual.md b/docs/modules/g2p_registry_individual.md index 87d67e68..ce88f058 100644 --- a/docs/modules/g2p_registry_individual.md +++ b/docs/modules/g2p_registry_individual.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **G2P Registry: Individual** module within the OpenSPP ecosystem. Building upon the foundation provided by the **[G2P Registry: Base](g2p_registry_base)** module, this module focuses specifically on managing **individual registrant** data. diff --git a/docs/modules/g2p_registry_membership.md b/docs/modules/g2p_registry_membership.md index e1e23497..4f2c3ace 100644 --- a/docs/modules/g2p_registry_membership.md +++ b/docs/modules/g2p_registry_membership.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **G2P Registry: Membership** module within the OpenSPP ecosystem. This module focuses on managing relationships between individual registrants and groups, adding an essential layer of organization and data management to the platform. diff --git a/docs/modules/g2p_registry_rest_api.md b/docs/modules/g2p_registry_rest_api.md new file mode 100644 index 00000000..ef39556b --- /dev/null +++ b/docs/modules/g2p_registry_rest_api.md @@ -0,0 +1,44 @@ +# G2P Registry: Rest API Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The [g2p_registry_rest_api](g2p_registry_rest_api) module extends the functionality of the OpenG2P platform by providing a RESTful API for interacting with the [g2p_registry_membership](g2p_registry_membership) module. This module allows external systems and applications to seamlessly access and manage data related to groups and individuals within the registry. + +## Features + +- **RESTful API Endpoints:** Exposes API endpoints for performing CRUD (Create, Read, Update, Delete) operations on group and individual records. +- **Integration with FastAPI:** Leverages the FastAPI framework for building high-performance and scalable APIs. +- **Security:** Implements role-based access control to restrict API access based on user permissions defined in the `g2p_security.xml` file. +- **Customizable Endpoints:** Allows for the creation of custom API endpoints to cater to specific integration needs. + +## Dependencies + +This module directly depends on the following modules: + +- **[g2p_registry_membership](g2p_registry_membership):** Provides the core functionality for managing groups and individuals within the registry. +- **fastapi:** A modern, fast (high-performance), web framework for building APIs with Python. +- **extendable_fastapi:** Extends the FastAPI framework with additional features for DCI integration. + +## Functionality + +The module enhances the OpenG2P platform by: + +- **Enabling external system integration:** Provides a standardized way for other systems, such as mobile applications or data analysis tools, to interact with the registry data. +- **Automating data exchange:** Allows for automated data synchronization between the OpenG2P platform and other systems. +- **Building custom applications:** Enables the development of custom applications that leverage the registry data through its API. + +## Security + +The [g2p_registry_rest_api](g2p_registry_rest_api) module enforces security through the following mechanisms: + +- **Role-based access control:** Defines specific roles (`Rest API POST` and `Rest API GET`) that grant access to different API endpoints and operations. +- **DCI authentication:** Leverages DCI's built-in authentication system to authenticate API requests. + +## Conclusion + +The [g2p_registry_rest_api](g2p_registry_rest_api) module plays a crucial role in enhancing the interoperability and extensibility of the OpenG2P platform. By providing a comprehensive RESTful API, it enables seamless data exchange and integration with external systems, empowering organizations to build more connected and efficient social protection programs. diff --git a/docs/modules/g2p_registry_rest_api_extension_demo.md b/docs/modules/g2p_registry_rest_api_extension_demo.md new file mode 100644 index 00000000..fce56b08 --- /dev/null +++ b/docs/modules/g2p_registry_rest_api_extension_demo.md @@ -0,0 +1,28 @@ +# G2P Registry: Rest API Extension Demo + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +This module serves as a demonstration of how to extend the OpenG2P Registry Rest API. It provides a practical example of adding new fields to existing API responses without directly modifying the core API module ([g2p_registry_rest_api](g2p_registry_rest_api)). + +## Purpose + +The main goal of this module is to illustrate the extensibility of the OpenG2P Registry Rest API. By providing a concrete example, it guides developers on how to tailor the API output to their specific needs without compromising the integrity of the core API functionality. + +## Functionality + +The module focuses on extending the `GroupInfoOut` model from the [g2p_registry_rest_api](g2p_registry_rest_api) module. It adds a new field `active` to the `GroupInfoOut` response, which indicates whether the group is currently active. + +This is achieved using the `extends` feature provided by the `extendable-pydantic` library. This approach ensures that the extended model inherits all the existing fields and functionalities of the original `GroupInfoOut` model while adding the new `active` field. + +## Integration + +The [g2p_registry_rest_api_extension_demo](g2p_registry_rest_api_extension_demo) module depends on the [g2p_registry_rest_api](g2p_registry_rest_api) module. It leverages the API endpoints and data models provided by the core API module and extends them to include additional information. + +## Conclusion + +This demonstration module provides a blueprint for developers looking to customize the OpenG2P Registry Rest API. By following the principles illustrated in this module, developers can seamlessly extend the API to accommodate specific data requirements and functionalities. diff --git a/docs/modules/index.md b/docs/modules/index.md index c7129614..0edb5d37 100644 --- a/docs/modules/index.md +++ b/docs/modules/index.md @@ -1,5 +1,10 @@ # OpenSPP Modules Index +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + ## SPP Modules | Module | Summary | @@ -75,7 +80,6 @@ | [OpenSPP Entitlement Transactions](spp_ent_trans) | This module records and manages transactions related to entitlement redemptions, providing a transparent history for both cash and in-kind benefits. | | [OpenSPP Cash Entitlement](spp_entitlement_cash) | Manage cash-based entitlements for beneficiaries within social protection programs, including defining calculation rules, automating disbursement, and tracking payments. | - ## G2P Modules | Module | Summary | diff --git a/docs/modules/spp_api.md b/docs/modules/spp_api.md index e2af71b9..e6cb87c4 100644 --- a/docs/modules/spp_api.md +++ b/docs/modules/spp_api.md @@ -1,8 +1,8 @@ -# OpenSPP API +# OpenSPP API ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_api_records.md b/docs/modules/spp_api_records.md index 8229b195..2bcc4a39 100644 --- a/docs/modules/spp_api_records.md +++ b/docs/modules/spp_api_records.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document details the **OpenSPP API Records** module within the OpenSPP platform. This module is responsible for defining and exposing API endpoints that provide access to records and data related to OpenSPP's core functionalities, including service points, programs, entitlements, and registries. diff --git a/docs/modules/spp_area.md b/docs/modules/spp_area.md index b81f8c61..13c3ea31 100644 --- a/docs/modules/spp_area.md +++ b/docs/modules/spp_area.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Area** module, which extends the OpenSPP framework by providing features to manage and organize geographical areas within the system. It integrates with the core registry modules to allow associating registrants and other data with specific locations. @@ -42,7 +42,6 @@ The **OpenSPP Area** module is designed to: * Utilizes the Queue Job module to perform data validation and import operations in the background, preventing performance issues and providing a smoother user experience. * Ability to localize the name of the imported area. - ## Conclusion The **OpenSPP Area** module enhances the OpenSPP platform by providing a robust and flexible system for managing geographical areas and linking them to registrant data. Its integration with the core registry modules ensures that location information is seamlessly incorporated into the overall system, supporting location-based targeting, analysis, and program management for social protection programs and farmer registries. diff --git a/docs/modules/spp_area_gis.md b/docs/modules/spp_area_gis.md index 62449081..32fd3761 100644 --- a/docs/modules/spp_area_gis.md +++ b/docs/modules/spp_area_gis.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` The **OpenSPP Area GIS** module extends the functionality of the [OpenSPP Area](link-to-area-module-documentation) module by integrating Geographical Information System (GIS) capabilities. This module allows users to visualize and interact with geographical areas on a map, providing a spatial dimension to area management within OpenSPP. diff --git a/docs/modules/spp_audit_config.md b/docs/modules/spp_audit_config.md index 97fba522..f4f3bda2 100644 --- a/docs/modules/spp_audit_config.md +++ b/docs/modules/spp_audit_config.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP Audit Config** module within the OpenSPP platform. This module is responsible for configuring and managing audit rules used to track and log changes made to critical data within the system. diff --git a/docs/modules/spp_audit_log.md b/docs/modules/spp_audit_log.md index 9a392f07..66287d21 100644 --- a/docs/modules/spp_audit_log.md +++ b/docs/modules/spp_audit_log.md @@ -1,5 +1,10 @@ # OpenSPP Audit Log +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + This module provides audit logging functionality for OpenSPP, enabling the tracking of changes made to specific data within the system. It helps maintain data integrity, accountability, and provides a historical record of modifications. ## Purpose diff --git a/docs/modules/spp_audit_post.md b/docs/modules/spp_audit_post.md index 8cc6b108..dc372069 100644 --- a/docs/modules/spp_audit_post.md +++ b/docs/modules/spp_audit_post.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **G2P Registry: Audit Post** module within the OpenSPP platform. This module extends the functionality of the audit log by enabling the posting of audit log messages to related parent records. diff --git a/docs/modules/spp_auto_update_entitlements.md b/docs/modules/spp_auto_update_entitlements.md index 2c14ec8b..f0fc7552 100644 --- a/docs/modules/spp_auto_update_entitlements.md +++ b/docs/modules/spp_auto_update_entitlements.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Auto-Update Entitlements** module within the OpenSPP platform. This module enhances the management of entitlement lifecycles by automatically updating entitlement states when program cycles end. This automation streamlines benefit administration and provides a more accurate view of benefit utilization. diff --git a/docs/modules/spp_base.md b/docs/modules/spp_base.md index e8c15a42..0bd95fae 100644 --- a/docs/modules/spp_base.md +++ b/docs/modules/spp_base.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Base** module, the core module for the OpenSPP system. It builds upon existing G2P Registry modules, providing essential customizations and configurations for OpenSPP's specialized functionalities. @@ -31,7 +31,6 @@ The **OpenSPP Base** module depends on several other modules, integrating their - [utm](utm): Leverages this module for tracking and managing UTM (Urchin Tracking Module) parameters, commonly used in digital marketing campaigns. - [g2p_registry_individual](g2p_registry_individual): Integrates with this module to manage individual registrant data, including specific attributes and validations. - ### Additional Functionality The **OpenSPP Base** module introduces the following key functionalities: diff --git a/docs/modules/spp_base_api.md b/docs/modules/spp_base_api.md index 7daf3c98..67219d76 100644 --- a/docs/modules/spp_base_api.md +++ b/docs/modules/spp_base_api.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_base_demo.md b/docs/modules/spp_base_demo.md index ea4927d6..3466163b 100644 --- a/docs/modules/spp_base_demo.md +++ b/docs/modules/spp_base_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module provides demonstration data for the OpenSPP system. It populates the database with sample records for various entities, allowing users to explore the system's functionalities with pre-populated data. diff --git a/docs/modules/spp_base_gis.md b/docs/modules/spp_base_gis.md index aa049738..47106d8b 100644 --- a/docs/modules/spp_base_gis.md +++ b/docs/modules/spp_base_gis.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_base_gis_demo.md b/docs/modules/spp_base_gis_demo.md index e1256c25..bd11770b 100644 --- a/docs/modules/spp_base_gis_demo.md +++ b/docs/modules/spp_base_gis_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module serves as a demonstration of the GIS capabilities provided by the [OpenSPP Base GIS](OpenSPP Base GIS)(./openspp-base-gis) module. It extends the functionality of the base module by adding practical examples and use cases. diff --git a/docs/modules/spp_base_gis_rest.md b/docs/modules/spp_base_gis_rest.md index 05161bbe..3a6ee03a 100644 --- a/docs/modules/spp_base_gis_rest.md +++ b/docs/modules/spp_base_gis_rest.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module extends the [spp_base_gis](spp_base_gis) by providing RESTful API endpoints for accessing and querying geospatial data. It depends on the following modules: diff --git a/docs/modules/spp_base_setting.md b/docs/modules/spp_base_setting.md index b2e89e46..ee60cb49 100644 --- a/docs/modules/spp_base_setting.md +++ b/docs/modules/spp_base_setting.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality and purpose of the **OpenSPP Base Settings** module within the OpenSPP ecosystem. This module builds upon the foundational [g2p_registry_base](g2p_registry_base) module to provide essential configuration options for OpenSPP deployments. diff --git a/docs/modules/spp_basic_cash_entitlement_spent.md b/docs/modules/spp_basic_cash_entitlement_spent.md index ff5263ad..b65eb270 100644 --- a/docs/modules/spp_basic_cash_entitlement_spent.md +++ b/docs/modules/spp_basic_cash_entitlement_spent.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document details the **SPP Program Entitlement Basic Cash Spent** module within the OpenSPP platform. This module extends the functionality of the [g2p_programs](g2p_programs) module to specifically handle the tracking of cash spent for basic cash entitlement programs. diff --git a/docs/modules/spp_change_request.md b/docs/modules/spp_change_request.md index e2f4a2f4..31af142c 100644 --- a/docs/modules/spp_change_request.md +++ b/docs/modules/spp_change_request.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_change_request_add_children_demo.md b/docs/modules/spp_change_request_add_children_demo.md index 5066d6c8..0dda3234 100644 --- a/docs/modules/spp_change_request_add_children_demo.md +++ b/docs/modules/spp_change_request_add_children_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_change_request_add_farmer.md b/docs/modules/spp_change_request_add_farmer.md index 9fd71326..dee6d8f3 100644 --- a/docs/modules/spp_change_request_add_farmer.md +++ b/docs/modules/spp_change_request_add_farmer.md @@ -2,12 +2,12 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview -The [spp_change_request_add_farmer](spp_change_request_add_farmer) module extends the OpenSPP Change Request system to specifically handle requests for adding new farmers to existing groups within the registry. It leverages the framework provided by the [spp_change_request](spp_change_request_add_farmer](spp_change_request](spp_change_request_add_farmer) module extends the OpenSPP Change Request system to specifically handle requests for adding new farmers to existing groups within the registry. It leverages the framework provided by the `[spp_change_request)` module and integrates with other registry modules to streamline the process of adding farmers while maintaining data integrity and consistency. +The [spp_change_request_add_farmer](spp_change_request_add_farmer) module extends the OpenSPP Change Request system to specifically handle requests for adding new farmers to existing groups within the registry. It leverages the framework provided by the [spp_change_request](spp_change_request) module and integrates with other registry modules to streamline the process of adding farmers while maintaining data integrity and consistency. ## Purpose @@ -22,7 +22,7 @@ The [spp_change_request_add_farmer](spp_change_request_add_farmer) module extend The module relies heavily on the following modules: -* **[spp_change_request](spp_change_request)**: Inherits the core change request functionality, including the request workflow, validation processes, approval mechanisms, and integration with the Document Management System ([spp_dms](spp_change_request](spp_dms](spp_change_request)**: Inherits the core change request functionality, including the request workflow, validation processes, approval mechanisms, and integration with the Document Management System (`[spp_dms)`). +* **[spp_change_request](spp_change_request)**: Inherits the core change request functionality, including the request workflow, validation processes, approval mechanisms, and integration with the Document Management System ([spp_dms](spp_dms)). * **[spp_farmer_registry_base](spp_farmer_registry_base)**: Leverages the farmer-specific data models and attributes to capture and store information about the new farmer. * **[g2p_registry_membership](g2p_registry_membership)**: Integrates with the membership management system to create the appropriate group membership record for the new farmer upon change request approval. * **[phone_validation](phone_validation)**: Utilizes the phone validation module to ensure phone number entries for the new farmer adhere to correct formatting. @@ -41,4 +41,4 @@ The module relies heavily on the following modules: ## Conclusion -The [spp_change_request_add_farmer](spp_change_request_add_farmer) module provides a robust and specialized workflow for adding new farmers to existing groups within the OpenSPP registry. By seamlessly integrating with core change management and registry modules, it ensures data accuracy, consistency, and a streamlined user experience for managing farmer additions. +The [spp_change_request_add_farmer](spp_change_request_add_farmer) module provides a robust and specialized workflow for adding new farmers to existing groups within the OpenSPP registry. By seamlessly integrating with core change management and registry modules, it ensures data accuracy, consistency, and a streamlined user experience for managing farmer additions. diff --git a/docs/modules/spp_consent.md b/docs/modules/spp_consent.md new file mode 100644 index 00000000..34eb1c82 --- /dev/null +++ b/docs/modules/spp_consent.md @@ -0,0 +1,36 @@ +# OpenSPP Consent Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +## Overview + +The OpenSPP Consent module enhances the functionality of the [g2p_registry_individual](g2p_registry_individual) and [g2p_registry_group](g2p_registry_group) modules by providing a framework for managing and tracking consents provided by registrants (both individuals and groups). This module is essential for ensuring compliance with data privacy regulations and maintaining ethical data management practices within social protection programs. + +## Features + +* **Consent Recording:** Allows authorized users to record consents obtained from registrants, specifying the type of consent, the signatory (for groups), and the expiry date. +* **Consent Management:** Provides a centralized repository for storing and managing all recorded consents, making it easy to track consent status and expiry dates. +* **Consent Integration:** Seamlessly integrates with the registrant profiles in the [g2p_registry_individual](g2p_registry_individual) and [g2p_registry_group](g2p_registry_group) modules, providing direct access to consent information from the registrant's record. +* **Expired Consent Tracking:** Includes a dedicated view for monitoring expired consents, enabling proactive management of consent renewals and ensuring continued compliance. + +## Functionality and Integration + +The OpenSPP Consent module introduces the following key elements: + +* **Consent Configuration:** Defines different types of consents that can be recorded within the system. +* **Consent Model:** Stores information related to each consent, including the type of consent, associated registrant (individual or group), signatory, expiry date, and related configuration. +* **Consent Mixin:** A mixin model that extends the functionality of the `res.partner` model (used for both individuals and groups) in the registry modules. This mixin adds a relationship field to link registrants with their respective consents. +* **Consent Wizard:** Provides a user-friendly interface for recording new consents, accessible directly from the registrant's profile. +* **Expired Consent View:** Offers a dedicated view for easily identifying and managing consents that have passed their expiry date. + +## Benefits + +* **Enhanced Data Privacy:** Ensures compliance with data privacy regulations by explicitly obtaining and tracking consents for data processing activities. +* **Improved Transparency:** Increases transparency by providing a clear record of consents obtained from registrants. +* **Streamlined Consent Management:** Simplifies the process of managing consents, reducing administrative burden and the risk of errors. +* **Proactive Compliance:** Enables proactive management of consents, ensuring timely renewals and minimizing the risk of non-compliance. + +By integrating the OpenSPP Consent module with your existing registry system, you can significantly strengthen your data protection measures and promote ethical data management practices within your social protection programs. diff --git a/docs/modules/spp_custom_field.md b/docs/modules/spp_custom_field.md index 17146e55..b65b2774 100644 --- a/docs/modules/spp_custom_field.md +++ b/docs/modules/spp_custom_field.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Custom Field** module, which extends the functionality of OpenSPP by adding customizable fields to registrant profiles. This module is specifically designed to work with the **[g2p_registry_base](g2p_registry_base)** module and leverages its features for managing registrant data. diff --git a/docs/modules/spp_custom_field_custom_filter.md b/docs/modules/spp_custom_field_custom_filter.md index c4fad946..d545260b 100644 --- a/docs/modules/spp_custom_field_custom_filter.md +++ b/docs/modules/spp_custom_field_custom_filter.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_custom_field_recompute_daily.md b/docs/modules/spp_custom_field_recompute_daily.md index 175caace..624d8a38 100644 --- a/docs/modules/spp_custom_field_recompute_daily.md +++ b/docs/modules/spp_custom_field_recompute_daily.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module extends the functionality of OpenSPP by introducing a mechanism to recompute specific fields on a daily basis. This is particularly useful for maintaining up-to-date values for fields that are computationally intensive or rely on frequently changing data. diff --git a/docs/modules/spp_custom_fields_ui.md b/docs/modules/spp_custom_fields_ui.md index 6cb13ad8..a33102d3 100644 --- a/docs/modules/spp_custom_fields_ui.md +++ b/docs/modules/spp_custom_fields_ui.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **G2P Registry: Custom Fields UI** module within the OpenSPP ecosystem. This module, depending on the **[g2p_registry_base](g2p_registry_base)** module, provides a user-friendly interface for defining and managing custom fields for registrants. These custom fields allow implementers to tailor the registry to their specific program needs by capturing additional data beyond the core fields provided by the base module. diff --git a/docs/modules/spp_custom_filter.md b/docs/modules/spp_custom_filter.md index a3412002..85376683 100644 --- a/docs/modules/spp_custom_filter.md +++ b/docs/modules/spp_custom_filter.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_custom_filter_ui.md b/docs/modules/spp_custom_filter_ui.md index 527cf126..5bd16624 100644 --- a/docs/modules/spp_custom_filter_ui.md +++ b/docs/modules/spp_custom_filter_ui.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ### Overview diff --git a/docs/modules/spp_data_export.md b/docs/modules/spp_data_export.md index 0305599b..229a0b3c 100644 --- a/docs/modules/spp_data_export.md +++ b/docs/modules/spp_data_export.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_dci_api_server.md b/docs/modules/spp_dci_api_server.md index 0d74c8fa..1a140efd 100644 --- a/docs/modules/spp_dci_api_server.md +++ b/docs/modules/spp_dci_api_server.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview @@ -19,9 +19,9 @@ This module serves as a bridge between OpenSPP and external systems seeking to a ## Dependencies -- [g2p_registry_base](g2p_registry_base): The [spp_dci_api_server](spp_dci_api_server) module relies on the core registry functionality provided by the [g2p_registry_base](g2p_registry_base](g2p_registry_base](g2p_registry_base): The [spp_dci_api_server](spp_dci_api_server) module relies on the core registry functionality provided by the `[g2p_registry_base)` module. This includes the management of registrants, their IDs, relationships, and other essential attributes. -- [spp_oauth](spp_oauth): This module leverages the OAuth 2.0 authentication and authorization mechanisms provided by the [spp_oauth](spp_oauth](spp_oauth](spp_oauth): This module leverages the OAuth 2.0 authentication and authorization mechanisms provided by the `[spp_oauth)` module. External systems are required to authenticate using OAuth 2.0 before they can access the DCI API endpoints. -- [g2p_registry_individual](g2p_registry_individual): This module utilizes the individual-specific data structures and functionalities provided by the [g2p_registry_individual](g2p_registry_individual](g2p_registry_individual](g2p_registry_individual): This module utilizes the individual-specific data structures and functionalities provided by the `[g2p_registry_individual)` module. This is crucial for retrieving and formatting individual registry data according to the DCI specification. +- [g2p_registry_base](g2p_registry_base): The [spp_dci_api_server](spp_dci_api_server) module relies on the core registry functionality provided by the [g2p_registry_base](g2p_registry_base) module. This includes the management of registrants, their IDs, relationships, and other essential attributes. +- [spp_oauth](spp_oauth): This module leverages the OAuth 2.0 authentication and authorization mechanisms provided by the [spp_oauth](spp_oauth) module. External systems are required to authenticate using OAuth 2.0 before they can access the DCI API endpoints. +- [g2p_registry_individual](g2p_registry_individual): This module utilizes the individual-specific data structures and functionalities provided by the [g2p_registry_individual](g2p_registry_individual) module. This is crucial for retrieving and formatting individual registry data according to the DCI specification. ## Functionality and Integration @@ -31,7 +31,7 @@ The [spp_dci_api_server](spp_dci_api_server) module exposes specific API endpoin 2. **DCI Sync Search Endpoint (`/api/v1/registry/sync/search`)**: This endpoint receives search requests from external systems. These requests, formatted according to the DCI specification, include criteria for filtering individual registrants within OpenSPP. The module processes these requests, retrieves matching registrant data, and returns the results in a standardized DCI response format. - - **Integration with [g2p_registry_individual](g2p_registry_individual):** The module utilizes the `get_dci_individual_registry_data` method from the [g2p_registry_individual](g2p_registry_individual](g2p_registry_individual](g2p_registry_individual):** The module utilizes the `get_dci_individual_registry_data` method from the `[g2p_registry_individual)` module to retrieve and structure individual registry data according to the DCI format. + - **Integration with [g2p_registry_individual](g2p_registry_individual):** The module utilizes the `get_dci_individual_registry_data` method from the [g2p_registry_individual](g2p_registry_individual) module to retrieve and structure individual registry data according to the DCI format. - **Data Mapping:** The module maps DCI attribute names to corresponding fields in the OpenSPP database schema, ensuring accurate data retrieval and formatting. - **Error Handling:** The module implements robust error handling, returning appropriate error codes and messages in the DCI response format for any invalid requests or data access issues. diff --git a/docs/modules/spp_demo.md b/docs/modules/spp_demo.md index aa1fa60d..c66a6f45 100644 --- a/docs/modules/spp_demo.md +++ b/docs/modules/spp_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` The `spp_demo` module serves as a demonstration and testing ground for the OpenSPP system, showcasing its capabilities with pre-populated data. It builds upon core OpenSPP modules to create a realistic simulation of social protection programs and registries in action. diff --git a/docs/modules/spp_dms.md b/docs/modules/spp_dms.md index 39d7822b..3abd6cb2 100644 --- a/docs/modules/spp_dms.md +++ b/docs/modules/spp_dms.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_eligibility_sql.md b/docs/modules/spp_eligibility_sql.md index cf93838a..f2aafd53 100644 --- a/docs/modules/spp_eligibility_sql.md +++ b/docs/modules/spp_eligibility_sql.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP SQL Query Eligibility Manager** module. This module enhances the **[g2p_programs](g2p_programs)** module by introducing a flexible way to define program eligibility criteria using SQL queries. diff --git a/docs/modules/spp_eligibility_tags.md b/docs/modules/spp_eligibility_tags.md index e3626f78..b0383eba 100644 --- a/docs/modules/spp_eligibility_tags.md +++ b/docs/modules/spp_eligibility_tags.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Tag Based Eligibility Manager** module within the OpenSPP ecosystem. This module extends the eligibility management capabilities of OpenSPP, providing a flexible and efficient way to define eligibility criteria based on registrant tags and geographical areas. diff --git a/docs/modules/spp_encryption.md b/docs/modules/spp_encryption.md index 35ad1486..3d53fb94 100644 --- a/docs/modules/spp_encryption.md +++ b/docs/modules/spp_encryption.md @@ -2,10 +2,10 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` -The [spp_encryption](spp_encryption) module extends the encryption capabilities of OpenSPP by adding support for the [JWCrypto](https://jwcrypto.readthedocs.io/en/latest/) library. This module builds upon the foundation provided by the [[g2p_encryption](JWCrypto](https://jwcrypto.readthedocs.io/en/latest/) library. This module builds upon the foundation provided by the [`[g2p_encryption) Encryption Module](spp_encryption]` module extends the encryption capabilities of OpenSPP by adding support for the [JWCrypto](https://jwcrypto.readthedocs.io/en/latest/) library. This module builds upon the foundation provided by the [[g2p_encryption](JWCrypto](https://jwcrypto.readthedocs.io/en/latest/) library. This module builds upon the foundation provided by the [`[g2p_encryption) Encryption Module)(#g2p-encryption-module) and offers a concrete implementation of an encryption provider utilizing JWCrypto's functionalities. +The [spp_encryption](spp_encryption) module extends the encryption capabilities of OpenSPP by adding support for the [JWCrypto](https://jwcrypto.readthedocs.io/en/latest/) library. This module builds upon the foundation provided by the [g2p_encryption](g2p-encryption) and offers a concrete implementation of an encryption provider utilizing JWCrypto's functionalities. ### Purpose and Functionality @@ -18,7 +18,7 @@ The primary purpose of this module is to enable secure encryption, decryption, s ### Integration and Usage -The [spp_encryption](spp_encryption) module extends the `g2p.encryption.provider` model introduced by the [g2p_encryption](spp_encryption](g2p_encryption](spp_encryption) module extends the `g2p.encryption.provider` model introduced by the `[g2p_encryption)` Encryption Module. It adds a new encryption provider type, "JWCrypto," which users can select and configure through the Odoo interface. +The [spp_encryption](spp_encryption) module extends the `g2p.encryption.provider` model introduced by the [g2p_encryption](g2p-encryption). It adds a new encryption provider type, "JWCrypto," which users can select and configure through the Odoo interface. Here's how this module integrates with other OpenSPP components: @@ -35,7 +35,7 @@ Let's consider a module responsible for handling beneficiary payment data. This 3. Using the provider's `encrypt_data_jwcrypto` method, the module can securely encrypt the payment data. 4. Upon retrieval, the module would use the corresponding `decrypt_data_jwcrypto` method to decrypt the data. -### Benefits of using [spp_encryption](spp_encryption): +### Benefits of using spp_encryption: - **Enhanced Security:** Leverages JWCrypto's robust cryptographic algorithms to provide strong encryption and data protection. - **Standardized Implementation:** Adheres to established standards like JWE and JWT, ensuring interoperability and security best practices. diff --git a/docs/modules/spp_ent_trans.md b/docs/modules/spp_ent_trans.md index 30f94ab5..05502754 100644 --- a/docs/modules/spp_ent_trans.md +++ b/docs/modules/spp_ent_trans.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document details the **OpenSPP Entitlement Transactions** module within the OpenSPP platform. This module is responsible for recording and managing transactions related to entitlement redemptions, providing a transparent and auditable history of benefit disbursement. It caters to both cash and in-kind entitlements, offering dedicated models and views for each type. @@ -24,13 +24,13 @@ The **OpenSPP Entitlement Transactions** module primarily focuses on: 2. **[g2p_registry_base](g2p_registry_base)**: * Utilizes the base registry module indirectly through the [OpenSPP Programs](OpenSPP Programs)(#openspp-programs-module-documentation) module. + * Links transactions to the relevant registrant profiles, providing context and enabling analysis of benefit distribution at the beneficiary level. 3. **[g2p_programs](g2p_programs)**: * Integrates with program data to associate transactions with specific programs and cycles. * Allows for program-level analysis of transaction trends, service point utilization, and overall program performance. - ## Additional Functionality * **Cash Entitlement Transactions Model (spp.entitlement.transactions)**: diff --git a/docs/modules/spp_entitlement_basket.md b/docs/modules/spp_entitlement_basket.md index 8b977457..814a3a7c 100644 --- a/docs/modules/spp_entitlement_basket.md +++ b/docs/modules/spp_entitlement_basket.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Entitlement Basket** module. This module extends OpenSPP's program management by introducing the concept of predefined "baskets" of goods and services that beneficiaries are entitled to receive. diff --git a/docs/modules/spp_entitlement_cash.md b/docs/modules/spp_entitlement_cash.md index 9fff4aa0..15933021 100644 --- a/docs/modules/spp_entitlement_cash.md +++ b/docs/modules/spp_entitlement_cash.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Program Entitlement (Cash)** module. This module extends the **G2P Programs** module, providing specialized features for managing cash-based entitlements within social protection programs. diff --git a/docs/modules/spp_entitlement_in_kind.md b/docs/modules/spp_entitlement_in_kind.md index 9efe1abf..2fbe67f2 100644 --- a/docs/modules/spp_entitlement_in_kind.md +++ b/docs/modules/spp_entitlement_in_kind.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP In-Kind Entitlement ([spp_entitlement_in_kind](spp_entitlement_in_kind))** module, which extends the OpenSPP platform to manage the distribution of in-kind entitlements within social protection programs. diff --git a/docs/modules/spp_event_data.md b/docs/modules/spp_event_data.md index 522ea4ac..065d76e2 100644 --- a/docs/modules/spp_event_data.md +++ b/docs/modules/spp_event_data.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **[spp_event_data](spp_event_data)** module within the OpenSPP ecosystem. This module is designed to record and track specific events related to registrants, building upon the functionalities offered by the base registry modules. diff --git a/docs/modules/spp_event_data_program_membership.md b/docs/modules/spp_event_data_program_membership.md index c892def1..24746f43 100644 --- a/docs/modules/spp_event_data_program_membership.md +++ b/docs/modules/spp_event_data_program_membership.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module enhances the functionality of OpenSPP by integrating the **Event Data** module ([spp_event_data](spp_event_data)) with the **G2P Programs** module ([g2p_programs](spp_event_data](g2p_programs](spp_event_data)) with the **G2P Programs** module ([g2p_programs)). It allows users to record and track program membership-related events within the OpenSPP system. @@ -42,7 +42,6 @@ The **spp_event_data_program_membership** module serves to: 3. **Viewing Event History:** Program staff can access a beneficiary's program membership record and view a chronological list of all events, providing a clear audit trail of their participation in the program. - ### Conclusion The **spp_event_data_program_membership** module enhances the tracking and management of program membership events within OpenSPP. By integrating event data with program memberships, it improves data integrity, transparency, and the overall efficiency of program administration. diff --git a/docs/modules/spp_event_demo.md b/docs/modules/spp_event_demo.md index dfbb3a28..477363cd 100644 --- a/docs/modules/spp_event_demo.md +++ b/docs/modules/spp_event_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module, **[spp_event_demo](spp_event_demo)**, provides demonstration data and functionalities for the **[spp_event_data](spp_event_demo](spp_event_data](spp_event_demo)**, provides demonstration data and functionalities for the **[spp_event_data)** module within the OpenSPP ecosystem. It showcases how to extend and utilize the event tracking capabilities of OpenSPP for specific use cases. diff --git a/docs/modules/spp_exclusion_filter.md b/docs/modules/spp_exclusion_filter.md index 7a900be9..e09c5060 100644 --- a/docs/modules/spp_exclusion_filter.md +++ b/docs/modules/spp_exclusion_filter.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Exclusion Filter** module. This module enhances the program creation process within OpenSPP by introducing exclusion filters during the program wizard. diff --git a/docs/modules/spp_farmer_registry_base.md b/docs/modules/spp_farmer_registry_base.md index e0427ef0..fd6442cc 100644 --- a/docs/modules/spp_farmer_registry_base.md +++ b/docs/modules/spp_farmer_registry_base.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_farmer_registry_dashboard.md b/docs/modules/spp_farmer_registry_dashboard.md index f830ddc1..f6bf8b64 100644 --- a/docs/modules/spp_farmer_registry_dashboard.md +++ b/docs/modules/spp_farmer_registry_dashboard.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview @@ -19,11 +19,11 @@ This module aims to: ## Module Dependencies and Integration -* **[spp_farmer_registry_base](spp_farmer_registry_base)** : The dashboard module heavily relies on the data models and functionalities provided by [spp_farmer_registry_base](spp_farmer_registry_base](spp_farmer_registry_base](spp_farmer_registry_base)** : The dashboard module heavily relies on the data models and functionalities provided by `[spp_farmer_registry_base). It fetches data about farmers, farm groups, land records, agricultural activities, and other relevant information from this core module. +* **[spp_farmer_registry_base](spp_farmer_registry_base)** : The dashboard module heavily relies on the data models and functionalities provided by [spp_farmer_registry_base](spp_farmer_registry_base). It fetches data about farmers, farm groups, land records, agricultural activities, and other relevant information from this core module. * **[g2p_registry_membership](g2p_registry_membership)** : Utilizes this module to display data related to group memberships, such as the number of farmers belonging to different types of farmer groups. -* **[spp_farmer_registry_demo](spp_farmer_registry_demo)** : While not a strict dependency, the dashboard module is particularly useful when used in conjunction with [spp_farmer_registry_demo](spp_farmer_registry_demo](spp_farmer_registry_demo](spp_farmer_registry_demo)** : While not a strict dependency, the dashboard module is particularly useful when used in conjunction with `[spp_farmer_registry_demo). The demo data provides a rich dataset for the dashboards to visualize, showcasing the module's capabilities. +* **[spp_farmer_registry_demo](spp_farmer_registry_demo)** : While not a strict dependency, the dashboard module is particularly useful when used in conjunction with [spp_farmer_registry_demo](spp_farmer_registry_demo). The demo data provides a rich dataset for the dashboards to visualize, showcasing the module's capabilities. * **spreadsheet_dashboard**: Leverages the `spreadsheet_dashboard` module to create dynamic and interactive dashboards. This dependency provides the framework for embedding charts and graphs directly within the Odoo interface. -* **[g2p_registry_base](g2p_registry_base)** : Indirectly depends on this module through its reliance on [spp_farmer_registry_base](spp_farmer_registry_base). The core registrant data structures and relationships defined in [g2p_registry_base](g2p_registry_base](g2p_registry_base](g2p_registry_base)** : Indirectly depends on this module through its reliance on `[spp_farmer_registry_base](spp_farmer_registry_base). The core registrant data structures and relationships defined in `[g2p_registry_base)` are essential for the dashboard's functionality. +* **[g2p_registry_base](g2p_registry_base)** : Indirectly depends on this module through its reliance on [spp_farmer_registry_base](spp_farmer_registry_base). The core registrant data structures and relationships defined in [g2p_registry_base](g2p_registry_base) are essential for the dashboard's functionality. * **[g2p_registry_group](g2p_registry_group)** : Utilized indirectly to access and display information about different types of farmer groups, which are defined and managed by this module. * **[g2p_registry_individual](g2p_registry_individual)** : Also indirectly relied upon to access and visualize data related to individual farmers, such as their demographic information and registration details. diff --git a/docs/modules/spp_farmer_registry_demo.md b/docs/modules/spp_farmer_registry_demo.md index 70748c5b..6d13e228 100644 --- a/docs/modules/spp_farmer_registry_demo.md +++ b/docs/modules/spp_farmer_registry_demo.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_idqueue.md b/docs/modules/spp_idqueue.md index e70aa5a5..0966f50d 100644 --- a/docs/modules/spp_idqueue.md +++ b/docs/modules/spp_idqueue.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP ID Queue** module within the OpenSPP ecosystem. This module adds functionality for managing requests for printed identification cards for registrants. It integrates with other OpenSPP modules to provide a seamless workflow from ID request to printing and distribution. @@ -28,7 +28,6 @@ The **OpenSPP ID Queue** module is designed to: 5. **[g2p_registry_group](g2p_registry_group)** (G2P Registry: Group): Incorporates functionality from the **G2P Registry: Group** module to support ID card requests and batch printing for groups of registrants. - ## Additional Functionality * **ID Request Queue (`spp.print.queue.id`)**: diff --git a/docs/modules/spp_import_dci_api.md b/docs/modules/spp_import_dci_api.md index ef751601..62acfe0c 100644 --- a/docs/modules/spp_import_dci_api.md +++ b/docs/modules/spp_import_dci_api.md @@ -2,16 +2,16 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview -The `[spp_import_dci_api](spp_import_dci_api)` module is an OpenSPP extension that enables the integration of external registries, particularly those adhering to the DCI (Digital Civil Identity) standard, into the OpenSPP ecosystem. +The [spp_import_dci_api](spp_import_dci_api.md) module is an OpenSPP extension that enables the integration of external registries, particularly those adhering to the [DCI (Digital Convergence Initiative)](https://spdci.org/) standard, into the OpenSPP ecosystem. ## Purpose -This module streamlines the process of importing and synchronizing registrant data from DCI-compliant registries into the OpenSPP registry. This facilitates efficient data sharing and interoperability between different systems. +This module streamlines the process of importing and synchronizing registrant data from DCI-compliant registries into the OpenSPP registry. This facilitates efficient data sharing and interoperability between different systems. For more information, visit [Digital Convergence Initiative](https://spdci.org/). ## Key Features @@ -27,29 +27,29 @@ This module streamlines the process of importing and synchronizing registrant da ## Dependencies and Integration -### 1. G2P Programs ([g2p_programs](g2p_programs)) +### 1. G2P Programs ([g2p_programs](g2p_programs.md)) -* **Integration:** Utilizes program definitions and eligibility criteria from `[g2p_programs](g2p_programs)` to potentially assign imported registrants to relevant programs based on their DCI attributes. +* **Integration:** Utilizes program definitions and eligibility criteria from [g2p_programs](g2p_programs.md) to potentially assign imported registrants to relevant programs based on their DCI attributes. -### 2. SPP Programs ([spp_programs](spp_programs)) +### 2. SPP Programs ([spp_programs](spp_programs.md)) -* **Integration:** Similar to `[g2p_programs](g2p_programs)`, this module might utilize in-kind entitlement logic from `[spp_programs](spp_programs)` if the imported DCI data includes information relevant to in-kind benefits. +* **Integration:** Similar to [g2p_programs](g2p_programs.md), this module might utilize in-kind entitlement logic from [spp_programs](spp_programs.md) if the imported DCI data includes information relevant to in-kind benefits. -### 3. G2P Registry: Base ([g2p_registry_base](g2p_registry_base)) +### 3. G2P Registry: Base ([g2p_registry_base](g2p_registry_base.md)) -* **Integration:** Relies heavily on `[g2p_registry_base](g2p_registry_base)` for core registry functionality: - * **Registrant Creation:** Creates new registrant records using the base model provided by `[g2p_registry_base](g2p_registry_base)`. - * **ID Management:** Leverages `g2p.reg.id` from `[g2p_registry_base](g2p_registry_base)` to store and manage DCI-provided identifiers. +* **Integration:** Relies heavily on [g2p_registry_base](g2p_registry_base.md) for core registry functionality: + * **Registrant Creation:** Creates new registrant records using the base model provided by [g2p_registry_base](g2p_registry_base.md). + * **ID Management:** Leverages `g2p.reg.id` from [g2p_registry_base](g2p_registry_base.md) to store and manage DCI-provided identifiers. * **Relationships:** Potentially utilizes the `g2p.reg.rel` model to establish relationships between imported registrants based on DCI data. -### 4. SPP Registry Data Source ([spp_registry_data_source](spp_registry_data_source)) +### 4. SPP Registry Data Source ([spp_registry_data_source](spp_registry_data_source.md)) -* **Integration:** Depends on `[spp_registry_data_source](spp_registry_data_source)` for: +* **Integration:** Depends on [spp_registry_data_source](spp_registry_data_source.md) for: * **Data Source Configuration:** Retrieves connection details and API specifications of the external DCI registry from data source configurations defined in this module. -### 5. G2P Registry: Individual ([g2p_registry_individual](g2p_registry_individual)) +### 5. G2P Registry: Individual ([g2p_registry_individual](g2p_registry_individual.md)) -* **Integration:** Extends the individual registrant model (`res.partner`) from `[g2p_registry_individual](g2p_registry_individual)`: +* **Integration:** Extends the individual registrant model (`res.partner`) from [g2p_registry_individual](g2p_registry_individual.md): * **Data Population:** Populates individual-specific fields within the OpenSPP registry using mapped DCI data (e.g., name, birthdate, gender). ## Additional Functionality @@ -68,7 +68,6 @@ The module includes specialized components for interacting with CRVS (Civil Regi * Processes retrieved CRVS data, creating or updating registrant records in OpenSPP (`spp.crvs.imported.individuals`). * Handles the creation of family groups and relationships based on CRVS data. - ## Conclusion -The `[spp_import_dci_api](spp_import_dci_api)` module enhances the OpenSPP platform by enabling seamless data exchange with external DCI-compliant registries, including specialized integration with CRVS systems. This promotes interoperability, streamlines data management, and expands the potential reach of OpenSPP implementations. +The [spp_import_dci_api](spp_import_dci_api) module enhances the OpenSPP platform by enabling seamless data exchange with external DCI-compliant registries, including specialized integration with CRVS systems. This promotes interoperability, streamlines data management, and expands the potential reach of OpenSPP implementations. For more information, visit [Digital Convergence Initiative](https://spdci.org/). diff --git a/docs/modules/spp_import_match.md b/docs/modules/spp_import_match.md index e6034f40..d3df9ace 100644 --- a/docs/modules/spp_import_match.md +++ b/docs/modules/spp_import_match.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` The [spp_import_match](spp_import_match) module enhances the data import functionality within OpenSPP by enabling the matching of imported records with existing records in the database. This helps prevent duplicate entries and ensures data integrity during import processes. diff --git a/docs/modules/spp_irrigation.md b/docs/modules/spp_irrigation.md index 7a67d7a8..77ea7c06 100644 --- a/docs/modules/spp_irrigation.md +++ b/docs/modules/spp_irrigation.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_land_record.md b/docs/modules/spp_land_record.md index fe375ea5..fa8e92bf 100644 --- a/docs/modules/spp_land_record.md +++ b/docs/modules/spp_land_record.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_manual_entitlement.md b/docs/modules/spp_manual_entitlement.md index f7ac75d7..7be4e13e 100644 --- a/docs/modules/spp_manual_entitlement.md +++ b/docs/modules/spp_manual_entitlement.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Manual Entitlement** module, which extends the OpenSPP system to allow for manual entitlement creation within social protection programs. diff --git a/docs/modules/spp_oauth.md b/docs/modules/spp_oauth.md index 3539cf19..aaac1f1f 100644 --- a/docs/modules/spp_oauth.md +++ b/docs/modules/spp_oauth.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_openid_vci.md b/docs/modules/spp_openid_vci.md index 8aa9c9b8..a04a9356 100644 --- a/docs/modules/spp_openid_vci.md +++ b/docs/modules/spp_openid_vci.md @@ -2,14 +2,14 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview -The `[spp_openid_vci](spp_openid_vci)` module enhances the functionality of the OpenSPP platform by enabling the issuance of Verifiable Credentials (VCs) to registrants. These VCs, based on OpenID Connect for Verifiable Presentations (OpenID4VP) and Decentralized Identifiers (DIDs), provide a secure and verifiable way to represent claims about a registrant's identity or attributes. +The [spp_openid_vci](spp_openid_vci.md) module enhances the functionality of the OpenSPP platform by enabling the issuance of Verifiable Credentials (VCs) to registrants. These VCs, based on OpenID Connect for Verifiable Presentations (OpenID4VP) and Decentralized Identifiers (DIDs), provide a secure and verifiable way to represent claims about a registrant's identity or attributes. -This module builds upon the capabilities provided by several other modules, including `[spp_encryption](spp_encryption)`, `[g2p_openid_vci](g2p_openid_vci)`, `[g2p_registry_base](g2p_registry_base)`, and `[g2p_encryption_rest_api](g2p_encryption_rest_api)`, to offer a comprehensive VC issuance solution. +This module builds upon the capabilities provided by several other modules, including [spp_encryption](spp_encryption.md), [g2p_openid_vci](g2p_openid_vci.md), [g2p_registry_base](g2p_registry_base.md), and [g2p_encryption_rest_api](g2p_encryption_rest_api.md), to offer a comprehensive VC issuance solution. ## Purpose @@ -21,12 +21,12 @@ This module aims to: ## Role and Integration -The `[spp_openid_vci](spp_openid_vci)` module relies on the foundational elements provided by its dependencies: +The [spp_openid_vci](spp_openid_vci.md) module relies on the foundational elements provided by its dependencies: -- **`[spp_encryption](spp_encryption)`:** Leverages this module to digitally sign issued VCs, ensuring their authenticity and integrity. -- **`[g2p_openid_vci](g2p_openid_vci)`:** Utilizes the core VC issuance logic and issuer management functionalities provided by this module. -- **`[g2p_registry_base](g2p_registry_base)`:** Fetches the necessary registrant data (name, address, etc.) from this module to populate the claims within the VCs. -- **`[g2p_encryption_rest_api](g2p_encryption_rest_api)`:** This module is not directly utilized by `[spp_openid_vci](spp_openid_vci)` but is essential for external systems to interact with the encryption and VC verification mechanisms. +- **[spp_encryption](spp_encryption.md):** Leverages this module to digitally sign issued VCs, ensuring their authenticity and integrity. +- **[g2p_openid_vci](g2p_openid_vci.md):** Utilizes the core VC issuance logic and issuer management functionalities provided by this module. +- **[g2p_registry_base](g2p_registry_base.md):** Fetches the necessary registrant data (name, address, etc.) from this module to populate the claims within the VCs. +- **[g2p_encryption_rest_api](g2p_encryption_rest_api.md):** This module is not directly utilized by [spp_openid_vci](spp_openid_vci.md) but is essential for external systems to interact with the encryption and VC verification mechanisms. ## Additional Functionality @@ -38,12 +38,12 @@ This module extends the capabilities of its dependencies by adding: ## Example Usage Scenario: -1. **Configuration:** An administrator configures a VCI issuer within the `[g2p_openid_vci](g2p_openid_vci)` module to represent their organization and defines the format and data fields for the VC, including the scope of the credential (e.g., proof of address). -2. **Data Fetching:** When a user initiates the VC issuance process for a registrant, the module retrieves the relevant information from the registrant's profile managed by `[g2p_registry_base](g2p_registry_base)`. -3. **VC Generation and Signing:** The module leverages the `[g2p_openid_vci](g2p_openid_vci)` module to construct the VC, populating it with the fetched data. The VC is then digitally signed using the encryption provider configured in the `[spp_encryption](spp_encryption)` module. +1. **Configuration:** An administrator configures a VCI issuer within the [g2p_openid_vci](g2p_openid_vci.md) module to represent their organization and defines the format and data fields for the VC, including the scope of the credential (e.g., proof of address). +2. **Data Fetching:** When a user initiates the VC issuance process for a registrant, the module retrieves the relevant information from the registrant's profile managed by [g2p_registry_base](g2p_registry_base.md). +3. **VC Generation and Signing:** The module leverages the [g2p_openid_vci](g2p_openid_vci.md) module to construct the VC, populating it with the fetched data. The VC is then digitally signed using the encryption provider configured in the [spp_encryption](spp_encryption.md) module. 4. **QR Code Generation:** A QR code, encoding the signed VC, is generated. This QR code is then associated with the registrant's record. 5. **ID Card Printing (Optional):** Users can opt to print an ID card for the registrant, which includes the generated QR code. This provides a physical credential that can be easily verified using a QR code scanner. ## Conclusion -The `[spp_openid_vci](spp_openid_vci)` module enhances OpenSPP by providing a streamlined and user-friendly way to issue and manage Verifiable Credentials. By integrating seamlessly with other key modules, it enables organizations to leverage the power of VCs to enhance trust and streamline data sharing within their ecosystems and with external parties. +The [spp_openid_vci](spp_openid_vci) module enhances OpenSPP by providing a streamlined and user-friendly way to issue and manage Verifiable Credentials. By integrating seamlessly with other key modules, it enables organizations to leverage the power of VCs to enhance trust and streamline data sharing within their ecosystems and with external parties. diff --git a/docs/modules/spp_openid_vci_group.md b/docs/modules/spp_openid_vci_group.md index 1c1f8b1c..3c746d73 100644 --- a/docs/modules/spp_openid_vci_group.md +++ b/docs/modules/spp_openid_vci_group.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ### Overview diff --git a/docs/modules/spp_openid_vci_individual.md b/docs/modules/spp_openid_vci_individual.md index 917104f6..8ebdc8a9 100644 --- a/docs/modules/spp_openid_vci_individual.md +++ b/docs/modules/spp_openid_vci_individual.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module extends the OpenSPP platform's Verifiable Credentials (VC) capabilities to specifically handle VC issuance for **individual registrants**. It seamlessly integrates the OpenID Connect for Verifiable Presentations (OpenID4VP) and Decentralized Identifiers (DIDs) framework with individual registrant data managed within the OpenSPP system. diff --git a/docs/modules/spp_pmt.md b/docs/modules/spp_pmt.md index 39875d03..08678647 100644 --- a/docs/modules/spp_pmt.md +++ b/docs/modules/spp_pmt.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Proxy Means Testing (spp_pmt)** module, which extends the OpenSPP framework to incorporate Proxy Means Testing (PMT) functionalities. This module allows program implementers to calculate a PMT score for groups of registrants based on specific criteria, aiding in the identification and prioritization of beneficiaries for social protection programs. diff --git a/docs/modules/spp_pos.md b/docs/modules/spp_pos.md index ddd01ebc..b95afeb4 100644 --- a/docs/modules/spp_pos.md +++ b/docs/modules/spp_pos.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document details the **OpenSPP POS ([spp_pos](spp_pos))** module within the OpenSPP ecosystem. This module extends the functionality of the Odoo Point of Sale (POS) system to integrate with OpenSPP's core modules, enabling the redemption of entitlements and management of beneficiary transactions at designated points of sale. diff --git a/docs/modules/spp_program_id.md b/docs/modules/spp_program_id.md index 7acc97ce..6a5f6ab0 100644 --- a/docs/modules/spp_program_id.md +++ b/docs/modules/spp_program_id.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Program ID** module, an extension to the OpenSPP platform. This module enhances the existing **OpenG2P: Programs** functionality by adding unique, system-generated IDs to each program for improved tracking and reference. diff --git a/docs/modules/spp_programs.md b/docs/modules/spp_programs.md index 714bd6c2..809c1cf8 100644 --- a/docs/modules/spp_programs.md +++ b/docs/modules/spp_programs.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Programs** module. This module extends the **OpenG2P: Programs** functionality, introducing in-kind entitlement management alongside existing cash-based features. diff --git a/docs/modules/spp_programs_compliance_criteria.md b/docs/modules/spp_programs_compliance_criteria.md index 93489646..696f77c9 100644 --- a/docs/modules/spp_programs_compliance_criteria.md +++ b/docs/modules/spp_programs_compliance_criteria.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Programs: Compliance Criteria** module, an extension to the OpenSPP framework. This module adds functionality to manage compliance criteria within social protection programs. diff --git a/docs/modules/spp_programs_sp.md b/docs/modules/spp_programs_sp.md index f44c25e1..618955cc 100644 --- a/docs/modules/spp_programs_sp.md +++ b/docs/modules/spp_programs_sp.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP Programs (Service Points Integration)** module, which extends the OpenSPP platform to integrate the management of service points within social protection programs. This module enables programs to link entitlements and beneficiaries with designated service points, streamlining the delivery of benefits and improving program efficiency. diff --git a/docs/modules/spp_registrant_import.md b/docs/modules/spp_registrant_import.md index fccf64ca..ea88ae37 100644 --- a/docs/modules/spp_registrant_import.md +++ b/docs/modules/spp_registrant_import.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document describes the **OpenSPP Registrant Import** module, which enhances the import functionality within the OpenSPP system, specifically focusing on streamlining the process of importing registrant data. It builds upon the existing import capabilities and introduces features to improve data mapping and ID management. diff --git a/docs/modules/spp_registrant_tag.md b/docs/modules/spp_registrant_tag.md index 34191e3c..1cc031fa 100644 --- a/docs/modules/spp_registrant_tag.md +++ b/docs/modules/spp_registrant_tag.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Registrant Tags** module within the OpenSPP ecosystem. This module extends the tagging capabilities of the [g2p_registry_base](g2p_registry_base) module, enabling more organized and efficient management of registrant data. diff --git a/docs/modules/spp_registry_data_source.md b/docs/modules/spp_registry_data_source.md index e84ef299..86683950 100644 --- a/docs/modules/spp_registry_data_source.md +++ b/docs/modules/spp_registry_data_source.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview diff --git a/docs/modules/spp_registry_group_hierarchy.md b/docs/modules/spp_registry_group_hierarchy.md index c35872ab..95c2b31c 100644 --- a/docs/modules/spp_registry_group_hierarchy.md +++ b/docs/modules/spp_registry_group_hierarchy.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This module builds upon the existing OpenSPP group and membership management functionalities to introduce a hierarchical structure for groups. It allows groups to be nested within other groups, creating a parent-child relationship between them. This hierarchy is beneficial for representing complex organizational structures within social protection programs or farmer registries. diff --git a/docs/modules/spp_scan_id_document.md b/docs/modules/spp_scan_id_document.md index d6d5c766..4041adbd 100644 --- a/docs/modules/spp_scan_id_document.md +++ b/docs/modules/spp_scan_id_document.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the functionality of the **OpenSPP Registry - Scan ID Document** module. This module enhances the registrant registration process by enabling users to scan physical ID documents directly into a registrant's profile. diff --git a/docs/modules/spp_service_point_device.md b/docs/modules/spp_service_point_device.md index fcd059ed..27cbc13d 100644 --- a/docs/modules/spp_service_point_device.md +++ b/docs/modules/spp_service_point_device.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP Service Point Device** module, which extends the functionality of the **[spp_service_points](spp_service_points)** module to manage terminal devices associated with each service point. It allows for the registration and tracking of devices used at service points, including their model, Android version, and active status. diff --git a/docs/modules/spp_service_points.md b/docs/modules/spp_service_points.md index 8d9c6b42..7799f4c7 100644 --- a/docs/modules/spp_service_points.md +++ b/docs/modules/spp_service_points.md @@ -2,7 +2,7 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` This document outlines the **OpenSPP Service Points** module, which adds functionality to manage service points and their agents within the OpenSPP ecosystem. It enables the registration and tracking of service points, their associated areas, offered services, and their connection to company entities and their respective contacts. diff --git a/docs/modules/spp_starter.md b/docs/modules/spp_starter.md new file mode 100644 index 00000000..685092c5 --- /dev/null +++ b/docs/modules/spp_starter.md @@ -0,0 +1,30 @@ +# OpenSPP Starter Module + +```{warning} + +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. +``` + +This module serves as the starting point for configuring and launching a new OpenSPP instance. It doesn't introduce any specific business logic or data models related to social protection programs or farmer registries. Instead, it focuses on providing a basic setup and customization options for the OpenSPP platform. + +### Functionality + +* **Configuration:** The module allows administrators to enable or disable the display of a custom menu entry that directs users to the OpenSPP modules and functionalities. +* **User Interface:** It can replace the standard Odoo "Management" menu with a dedicated OpenSPP menu, guiding users towards the relevant features for managing social protection programs and farmer registries. + +### Dependencies + +* **base:** This module depends on the Odoo base module, inheriting its functionality for menus and user interface elements. + +### Integration + +The [spp_starter](spp_starter) module doesn't directly integrate with other specific modules related to social protection or farmer registries. However, it acts as a foundation upon which other modules can build and extend the platform's capabilities. By modifying the menu structure and providing configuration options, it prepares the system for the installation and utilization of more specialized modules. + +### Key Components + +* **ir.config_parameter:** Utilizes configuration parameters to control the visibility of the OpenSPP menu entry, allowing administrators to customize the user experience based on the specific implementation needs. +* **ir.ui.menu:** Inherits from the `ir.ui.menu` model to override the default menu visibility, replacing the standard "Management" menu with an OpenSPP-specific menu when configured. + +### Usage + +Once the module is installed, administrators can configure the visibility of the OpenSPP menu entry by accessing the system parameters. Depending on the chosen configuration, users will see either the standard Odoo "Management" menu or a custom OpenSPP menu, guiding them to the relevant sections for managing social protection programs and farmer registries. diff --git a/docs/modules/spp_user_roles.md b/docs/modules/spp_user_roles.md index 3812ac82..fde51888 100644 --- a/docs/modules/spp_user_roles.md +++ b/docs/modules/spp_user_roles.md @@ -2,12 +2,12 @@ ```{warning} -This is a work-in-progress document. +**Work in Progress**: This document is actively being developed and updated. Content may be incomplete or subject to change. ``` ## Overview -The [spp_user_roles](spp_user_roles) module enhances the user role management capabilities of OpenSPP, providing a more granular and context-aware approach to user permissions. It builds upon the base user role system in Odoo and introduces the concept of "local" roles, allowing administrators to assign permissions based on specific geographical areas. +The [spp_user_roles](spp_user_roles.md) module enhances the user role management capabilities of OpenSPP, providing a more granular and context-aware approach to user permissions. It builds upon the base user role system in Odoo and introduces the concept of "local" roles, allowing administrators to assign permissions based on specific geographical areas. ## Purpose @@ -19,19 +19,19 @@ This module aims to: ## Dependencies and Integration -1. **G2P Registry: Base ([g2p_registry_base](g2p_registry_base)):** This module indirectly depends on the `res.partner` model from the G2P Registry: Base module, as it modifies the access rules for registrant data based on a user's assigned areas. +1. **G2P Registry: Base ([g2p_registry_base](g2p_registry_base.md)):** This module indirectly depends on the `res.partner` model from the G2P Registry: Base module, as it modifies the access rules for registrant data based on a user's assigned areas. -2. **G2P Registry: Group ([g2p_registry_group](g2p_registry_group)):** Similar to the Base module, it impacts access to group registrant data based on area assignments. +2. **G2P Registry: Group ([g2p_registry_group](g2p_registry_group.md)):** Similar to the Base module, it impacts access to group registrant data based on area assignments. -3. **G2P Programs ([g2p_programs](g2p_programs)):** The module's area-based access control can be applied to program-related data, ensuring that users with local roles only see and manage programs operating within their designated areas. +3. **G2P Programs ([g2p_programs](g2p_programs.md)):** The module's area-based access control can be applied to program-related data, ensuring that users with local roles only see and manage programs operating within their designated areas. -4. **OpenSPP Area ([spp_area](spp_area)):** The module heavily relies on the area hierarchy defined in the [spp_area](spp_area](spp_area](spp_area)):** The module heavily relies on the area hierarchy defined in the `[spp_area) module. Local roles are directly associated with specific areas, and user access is restricted accordingly. +4. **OpenSPP Area ([spp_area](spp_area.md)):** The module heavily relies on the area hierarchy defined in the [spp_area](spp_area.md) module. Local roles are directly associated with specific areas, and user access is restricted accordingly. -5. **OpenSPP ID Queue ([spp_idqueue](spp_idqueue)):** Integrates with the ID Queue module to control access to ID card requests and batches based on area assignments, ensuring that users only manage requests originating from their designated locations. +5. **OpenSPP ID Queue ([spp_idqueue](spp_idqueue.md)):** Integrates with the ID Queue module to control access to ID card requests and batches based on area assignments, ensuring that users only manage requests originating from their designated locations. 6. **Base User Role (base_user_role):** Extends the base Odoo module for user role management, inheriting its core functionalities and adding the area-based restrictions. -7. **OpenSPP API ([spp_api](spp_api)):** The module's access control mechanism is integrated with the OpenSPP API, ensuring that API requests from users with local roles are filtered to return only data within their authorized areas. +7. **OpenSPP API ([spp_api](spp_api.md)):** The module's access control mechanism is integrated with the OpenSPP API, ensuring that API requests from users with local roles are filtered to return only data within their authorized areas. ## Additional Functionality