Merge pull request #402 from openimis/feature/OP-2585

Feature/op 2585

Author: zikani03

README.md

@@ -16,7 +16,7 @@ It is a required module of [openimis-be_py](https://github.com/openimis/openimis
 ## ORM mapping:
 * UUIDModel: abstract model for new entities (and later on migrated entities), enforcing the use of UUID is identifier
 * VersionedModel: abstract model implementing the legacy 'in table archiving' mechanism
-* HistoryModel: abstract model implementing the django-simple-history archiving mechanism with standard mutaitons 
+* HistoryModel: abstract model implementing the django-simple-history archiving mechanism with standard mutations 
 * HistoryBusinessModel: abstract model implementing the django-simple-history archiving mechanism with ValidFrom and ValidTo date and with standard and replace mutations
 * core_ModuleConfiguration > ModuleConfiguration: a generic entity each module should use to let (admin)users provide the expected configuration (via a central management console).
 * core_FieldControl > FieldControl: allow to hide or mark readonly fields in UI (tables, forms,...)
@@ -67,12 +67,12 @@ from core.fields import DateField, DateTimeField
 ```
 
 ### UserManager
-openIMIS backend is configured for SSO, receiving the user (login) in the REMOTE_USER http header. Since django security is defined uppon User (core_User table), the UserManager auto-provision the received login (REMOTE_USER) as User, binding it (i_user) to the corresponding InteractiveUser record.
+openIMIS backend is configured for SSO, receiving the user (login) in the REMOTE_USER http header. Since django security is defined upon User (core_User table), the UserManager auto-provision the received login (REMOTE_USER) as User, binding it (i_user) to the corresponding InteractiveUser record.
 The auto-provisioning assigns a default Group (name can be parameterized) from which django permissions are calculated (with UserRole - Role - RoleRight contributed from InteractiveUser).
 Note: if not existing, the default group is created at startup.
 
 ### Language Support for Role Labels
-If the user has a language different from the system default and a translation is available in alt_language, the role name is returned in that language. Otherwise, it falls back to the default name. This ensures localized role labels are shown based on the user's language preferences.
+Role names are displayed in the user's selected language using Django's translation system with .po and .mo files. If a translation is available for the user's language (e.g., fr), the translated role name is shown. Otherwise, it falls back to the default role name. This ensures localized role labels are displayed based on the user's language preferences, managed through translation files rather than a database column.
 
 ### Mutations & Signals
 The OpenIMISMutation class of this module provides the template code for
@@ -114,7 +114,7 @@ If the callback returns an array of error message:
 ```
 If the callback returns None (or an empty array), the mutation is marked as successful.
 
-__Important Note__: by default the callback is executed __in transaction__ and, as a consequence, will (in case of exception/errors) cancel the complete mutation. If this is not the desired behaviour, the callback must explicitely detach to separate transaction (process).
+__Important Note__: by default the callback is executed __in transaction__ and, as a consequence, will (in case of exception/errors) cancel the complete mutation. If this is not the desired behaviour, the callback must explicitly detach to separate transaction (process).
 
 #### Extending mutations with signals
 Signal callbacks could use mutationExtensions JSON field to receive additional data from mutation payload. This
@@ -139,15 +139,15 @@ function to connect new signals. Receivers can be registered also in other place
 
 #### Modules Scheduled Tasks
 To add a scheduled task directly from within a module, add the file `scheduled_tasks.py` 
-in the module package. From there, the function `schedule_tasks` accepting `BackgroundScheudler` 
+in the module package. From there, the function `schedule_tasks` accepting `BackgroundScheduler` 
 as argument must be accessible. 
 
 **Example content of scheduled_tasks.py:**
 ```python
 def module_task():
     ...
 
-def schedule_tasks(scheduler: BackgroundScheduler): # Has to accept BackgroundScheudler as input
+def schedule_tasks(scheduler: BackgroundScheduler): # Has to accept BackgroundScheduler as input
     scheduler.add_job(
         module_task,
         trigger=CronTrigger(hour=8),  # Daily at 8 AM
@@ -161,7 +161,7 @@ set to `True`.
 ### Graphene Custom Types & Helper Classes/Methods
 * schema.SmallInt: Integer, with values ranging from -32768 to +32767
 * schema.TinyInt: Integer (8 bit), with values ranging from 0 to 255
-* utils.filter_validity: many openIMIS entities have a validity_from/validity_to, this filters provides a helper implementing the vality logic based on date (today if None)
+* utils.filter_validity: many openIMIS entities have a validity_from/validity_to, this filters provides a helper implementing the validity logic based on date (today if None)
 Sample usage:
 ```
 Insuree.objects.get(
@@ -235,14 +235,14 @@ TechnicalUserForm (ability to add technical users from the console)
   which allows filtering by json field attributes in the SQL Server database. Filtering by simple data types and nested 
   arguments. The use is as follows:
   ```
-  claim.objects.filter(json_ext__jsoncontains={'amount': 10.00, 'adress': { 'country': 'X', 'city': 'Y'}})
+  claim.objects.filter(json_ext__jsoncontains={'amount': 10.00, 'address': { 'country': 'X', 'city': 'Y'}})
   ```
 * jsoncontainskey - another custom filtering parameter for json fields. Equivalent to `__contains` search on
   underlying serialized json string. It allows queries as:
   ```
   claim.objects.filter(json_ext__jsoncontainskey='amount')
   ```
-  This query searches for `"amouunt":` in json string, so it will match keys in nested json objects
+  This query searches for `"amount":` in json string, so it will match keys in nested json objects
 
 ### WebSocket client
 The module gives access to WebSocket clients allowing external socket communication. 
@@ -270,7 +270,7 @@ with websocket_instance.connect() as connection: # keeps connection open
 ## Abstract calculation rule class
 * core/abs_calculation_rule: here is defined the abstract calculation rule class that might be used
     for defining some calculation rules.
-* class is a representation of calculation rule. Here are defined some informations about rule and how some actions 
+* class is a representation of calculation rule. Here are defined some information about rule and how some actions 
     are implemented. 
 * members
   - version (static) - the version is used to keep track of the changes in the version of the calculation rule,
@@ -347,7 +347,7 @@ CLASS_RULE_PARAM_VALIDATION = [
   - get_linked_class(List[classname]) - that function will return the possible instance that can have a link to the calculation
   - convert(instance, convert_to, **argv) - Convert on or several object toward another type, especially to invoice or bill . It will check the from-to, and the rights then will call the Function Name with agrv as parameters
 * generic methods defined on abstract class level
-  - get_rule_name(classname) - return an object which is representation of calculaton rule
+  - get_rule_name(classname) - return an object which is representation of calculation rule
   - get_rule_details(classname) - return the data about class and parameters
   - get_parameters(class_name, instance) - Function to obtain the required parameter and its properties for an instance of certain model. 
       This function is registered to the module signal via the ready function if the rule is active

core/__init__.py

@@ -1,8 +1,8 @@
-from core.utils import *
-from core.datetimes.shared import *
-from core.custom_lookups import *
+from core.utils import *  # noqa: F401,F403
+from core.datetimes.shared import *  # noqa: F401,F403
+from core.custom_lookups import *  # noqa: F401,F403
 
-default_app_config = 'core.apps.CoreConfig'
+default_app_config = "core.apps.CoreConfig"
 
 # For IDE support, filled at runtime
 datetime = None

core/abs_calculation_rule.py

@@ -32,7 +32,9 @@ def get_calculation_rule_name(cls):
     def set_calculation_rule_name(cls, val):
         type(cls)._calculation_rule_name = val
 
-    calculation_rule_name = property(get_calculation_rule_name, set_calculation_rule_name)
+    calculation_rule_name = property(
+        get_calculation_rule_name, set_calculation_rule_name
+    )
 
     @classmethod
     def get_description(cls):
@@ -52,7 +54,9 @@ def get_impacted_class_parameter(cls):
     def set_impacted_class_parameter(cls, val):
         type(cls)._impacted_class_parameter = val
 
-    impacted_class_parameter = property(get_impacted_class_parameter, set_impacted_class_parameter)
+    impacted_class_parameter = property(
+        get_impacted_class_parameter, set_impacted_class_parameter
+    )
 
     @classmethod
     def get_type(cls):
@@ -87,8 +91,11 @@ def set_from_to(cls, val):
     @classmethod
     def ready(cls):
         now = datetime.datetime.now()
-        condition_is_valid = (now >= cls.date_valid_from and now <= cls.date_valid_to) \
-            if cls.date_valid_to else (now >= cls.date_valid_from and cls.date_valid_to is None)
+        condition_is_valid = (
+            (now >= cls.date_valid_from and now <= cls.date_valid_to)
+            if cls.date_valid_to
+            else (now >= cls.date_valid_from and cls.date_valid_to is None)
+        )
         if not condition_is_valid:
             cls.status = "inactive"
 
@@ -111,14 +118,18 @@ def calculate(cls, instance, *args, **kwargs):
     def get_linked_class(cls, sender, class_name, **kwargs):
         # calculation are loaded on the side, therefore contentType have to be loaded on execution
         from django.contrib.contenttypes.models import ContentType
+
         list_class = []
         if class_name is not None:
             model_class = ContentType.objects.filter(model__iexact=class_name).first()
             if model_class:
                 model_class = model_class.model_class()
-                list_class = list_class + \
-                             [f.remote_field.model.__name__ for f in model_class._meta.fields
-                              if f.get_internal_type() == 'ForeignKey' and f.remote_field.model.__name__ != "User"]
+                list_class = list_class + [
+                    f.remote_field.model.__name__
+                    for f in model_class._meta.fields
+                    if f.get_internal_type() == "ForeignKey"
+                    and f.remote_field.model.__name__ != "User"
+                ]
         else:
             list_class.append("Calculation")
         return list_class
@@ -143,29 +154,33 @@ def get_rule_details(cls, sender, class_name, **kwargs):
     @classmethod
     def get_parameters(cls, sender, class_name, instance, **kwargs):
         """
-            class_name is the class name of the object where the calculation param need to be added
-            instance is where the link with a calculation need to be found,
-            like the CPB in case of PH insuree or Contract Details
-            return a list only with rule details that matches step 1 and 2
+        class_name is the class name of the object where the calculation param need to be added
+        instance is where the link with a calculation need to be found,
+        like the CPB in case of PH insuree or Contract Details
+        return a list only with rule details that matches step 1 and 2
         """
         rule_details = cls.get_rule_details(sender=sender, class_name=class_name)
         if rule_details:
             if cls.check_calculation(instance=instance):
-                return rule_details["parameters"] if "parameters" in rule_details else []
+                return (
+                    rule_details["parameters"] if "parameters" in rule_details else []
+                )
 
     @classmethod
     def run_calculation_rules(cls, sender, instance, user, context, **kwargs):
         """
-            this function will send a signal and the rules will
-            reply if they have object matching the classname in their list of object
+        this function will send a signal and the rules will
+        reply if they have object matching the classname in their list of object
         """
         list_class = cls.get_linked_class(sender, instance.__class__.__name__)
         # if the class have a calculation param, (like contribution or payment plan) add class name
-        if hasattr(instance, 'calculation'):
+        if hasattr(instance, "calculation"):
             list_class.append(instance.__class__.__name__)
         if list_class:
             for class_name in list_class:
-                rule_details = cls.get_rule_details(class_name=class_name, sender=sender)
+                rule_details = cls.get_rule_details(
+                    class_name=class_name, sender=sender
+                )
                 if rule_details or len(cls.impacted_class_parameter) == 0:
                     # add context to kwargs
                     kwargs["context"] = context
@@ -174,32 +189,39 @@ def run_calculation_rules(cls, sender, instance, user, context, **kwargs):
 
     @classmethod
     def calculate_if_active_for_object(cls, instance, **kwargs):
-        if cls.active_for_object(instance=instance, context=kwargs['context']):
+        if cls.active_for_object(instance=instance, context=kwargs["context"]):
             return cls.calculate(instance, **kwargs)
 
     @classmethod
     def run_convert(cls, instance, convert_to, **kwargs):
         """
-            execute the conversion for the instance with the first
-            rule that provide the conversion (see get_convert_from_to)
+        execute the conversion for the instance with the first
+        rule that provide the conversion (see get_convert_from_to)
         """
         convert_from = instance.__class__.__name__
         if convert_from == "Contract":
             convert_from = "ContractContributionPlanDetails"
         list_possible_conversion = cls.get_convert_from_to()
         for possible_conversion in list_possible_conversion:
-            if convert_from == possible_conversion['from'] and convert_to == possible_conversion['to']:
+            if (
+                convert_from == possible_conversion["from"]
+                and convert_to == possible_conversion["to"]
+            ):
                 result = cls.convert(instance=instance, convert_to=convert_to, **kwargs)
                 return result
 
     @classmethod
     def get_convert_from_to(cls):
         """
-            get the possible conversion, return [calc UUID, from, to]
+        get the possible conversion, return [calc UUID, from, to]
         """
         list_possible_conversion = []
         for ft in cls.from_to:
-            convert_from_to = {'calc_uuid': cls.uuid, 'from': ft['from'], 'to': ft['to']}
+            convert_from_to = {
+                "calc_uuid": cls.uuid,
+                "from": ft["from"],
+                "to": ft["to"],
+            }
             list_possible_conversion.append(convert_from_to)
         return list_possible_conversion