Merge pull request #151 from VineetBala-AOT/main

Refactor condition creation and enums

Author: VineetBala-AOT

condition-api/src/condition_api/resources/condition.py

@@ -152,15 +152,24 @@ def post(project_id, document_id):
             query_params = request.args
             allow_duplicate_condition = query_params.get(
                 'allow_duplicate_condition', 'true').lower() == 'true'
+            check_condition_over_project = query_params.get(
+                'check_condition_over_project', 'false').lower() == 'true'
             created_condition = ConditionService.create_condition(project_id,
                                                                   document_id,
                                                                   conditions_data,
-                                                                  allow_duplicate_condition)
+                                                                  allow_duplicate_condition,
+                                                                  check_condition_over_project)
             return created_condition, HTTPStatus.OK
         except ValidationError as err:
             return {"message": str(err)}, HTTPStatus.BAD_REQUEST
         except ConditionNumberExistsError as err:
             return {"message": str(err)}, HTTPStatus.CONFLICT
+        except ConditionNumberExistsInProjectError as err:
+            response = {
+                "message": str(err),
+                "is_amendment": err.is_amendment
+            }
+            return response, HTTPStatus.PRECONDITION_FAILED
 
 
 @cors_preflight("GET, OPTIONS, PATCH, DELETE")

condition-api/src/condition_api/services/attribute_key_service.py

@@ -51,11 +51,12 @@ def get_all_attributes(condition_id, management_plan_id=None):
             )
             .filter(
                 ~attribute_keys.id.in_(db.session.query(subquery.c.attribute_key_id)),
-                ~attribute_keys.id.in_([AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED,
-                                        # exlucding Parties required to be submitted from attribute_keys
-                                        AttributeKeys.DELIVERABLE_NAME,
-                                        AttributeKeys.MANAGEMENT_PLAN_ACRONYM,
-                                        AttributeKeys.MANAGEMENT_PLAN_NAME]),
+                ~attribute_keys.key_name.in_([
+                    AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED.value,
+                    AttributeKeys.DELIVERABLE_NAME.value,
+                    AttributeKeys.MANAGEMENT_PLAN_ACRONYM.value,
+                    AttributeKeys.MANAGEMENT_PLAN_NAME.value,
+                ]),
             )
             .order_by(attribute_keys.sort_order)
             .all()

condition-api/src/condition_api/services/condition_attribute_service.py

@@ -123,7 +123,7 @@ def _upsert_single_attribute(condition_id, attribute_data, management_plan_id=No
         if existing_attribute:
             existing_attribute.attribute_value = value
         else:
-            if key.id == AttributeKeys.DELIVERABLE_NAME:
+            if key.key_name == AttributeKeys.DELIVERABLE_NAME.value:
                 return
 
             attribute = ConditionAttribute(
@@ -135,12 +135,12 @@ def _upsert_single_attribute(condition_id, attribute_data, management_plan_id=No
             db.session.add(attribute)
             db.session.flush()
 
-        if key.id == AttributeKeys.REQUIRES_CONSULTATION and value == 'true':
+        if key.key_name == AttributeKeys.REQUIRES_CONSULTATION.value and value == 'true':
             ConditionAttributeService._handle_requires_consultation(
                 condition_id, management_plan_id
             )
 
-        if key.id == AttributeKeys.REQUIRES_IEM_TERMS_OF_ENGAGEMENT and value == 'true':
+        if key.key_name == AttributeKeys.REQUIRES_IEM_TERMS_OF_ENGAGEMENT.value and value == 'true':
             ConditionAttributeService._handle_requires_iem_terms_of_engagement(
                 condition_id, value, management_plan_id
             )
@@ -156,7 +156,7 @@ def _handle_requires_consultation(condition_id, management_plan_id):
         :param management_plan_id: If the attribute is for a management plan.
         """
         consultation_key = db.session.query(AttributeKey).filter(
-            AttributeKey.id == AttributeKeys.PARTIES_REQUIRED_TO_BE_CONSULTED
+            AttributeKey.key_name == AttributeKeys.PARTIES_REQUIRED_TO_BE_CONSULTED.value
         ).first()
 
         existing_attribute = db.session.query(ConditionAttribute).filter_by(
@@ -184,28 +184,32 @@ def _handle_requires_iem_terms_of_engagement(condition_id, attribute_value, mana
         :param attribute_value: Value of the current attribute.
         :param management_plan_id: If the attribute is for a management plan.
         """
-        deliverable_key_id = AttributeKeys.DELIVERABLE_NAME
+        deliverable_key_name = AttributeKeys.DELIVERABLE_NAME.value
         deliverable_value = IEMTermsConfig.DELIVERABLE_VALUE
         required_keys = IEMTermsConfig.required_attribute_keys()
 
         if attribute_value != 'true':
             # Remove deliverable attribute if present
-            db.session.query(ConditionAttribute).filter_by(
-                condition_id=condition_id,
-                attribute_key_id=deliverable_key_id
-            ).delete()
+            deliverable_key = db.session.query(AttributeKey).filter(
+                AttributeKey.key_name == deliverable_key_name
+            ).first()
+            if deliverable_key:
+                db.session.query(ConditionAttribute).filter_by(
+                    condition_id=condition_id,
+                    attribute_key_id=deliverable_key.id
+                ).delete()
             db.session.commit()
             return
 
-        keys = db.session.query(AttributeKey).filter(AttributeKey.id.in_(required_keys)).all()
+        keys = db.session.query(AttributeKey).filter(AttributeKey.key_name.in_(required_keys)).all()
         for key in keys:
             existing = db.session.query(ConditionAttribute).filter_by(
                 condition_id=condition_id, attribute_key_id=key.id
             ).first()
 
             if not existing:
                 # Check if the current key is DELIVERABLE_NAME
-                attribute_value = deliverable_value if key.id == deliverable_key_id else None
+                attribute_value = deliverable_value if key.key_name == deliverable_key_name else None
                 new_attribute = ConditionAttribute(
                     condition_id=condition_id,
                     attribute_key_id=key.id,
@@ -216,7 +220,7 @@ def _handle_requires_iem_terms_of_engagement(condition_id, attribute_value, mana
                 db.session.flush()
             else:
                 # Update DELIVERABLE_NAME if it already exists
-                if key.id == deliverable_key_id:
+                if key.key_name == deliverable_key_name:
                     current_value = existing.attribute_value or ""
                     values = current_value.strip('{}').split(',') if current_value else []
                     values = [v.strip() for v in values if v.strip()]
@@ -239,15 +243,15 @@ def _handle_requires_management_plan(condition_id, management_plan_id):
         """
         required_keys = ManagementPlanConfig.required_attribute_keys()
 
-        all_attribute_keys = db.session.query(AttributeKey).filter(AttributeKey.id.in_(required_keys)).all()
+        all_attribute_keys = db.session.query(AttributeKey).filter(AttributeKey.key_name.in_(required_keys)).all()
         for key in all_attribute_keys:
             existing_attribute = db.session.query(ConditionAttribute).filter_by(
                 condition_id=condition_id, attribute_key_id=key.id
             ).first()
 
             if not existing_attribute:
                 # Check if the current key is MANAGEMENT_PLAN_NAME
-                attribute_value = '{}' if key.id == AttributeKeys.MANAGEMENT_PLAN_NAME else None
+                attribute_value = '{}' if key.key_name == AttributeKeys.MANAGEMENT_PLAN_NAME.value else None
                 new_attribute = ConditionAttribute(
                     condition_id=condition_id,
                     attribute_key_id=key.id,
@@ -260,7 +264,7 @@ def _handle_requires_management_plan(condition_id, management_plan_id):
     @staticmethod
     def _fetch_all_attributes(requires_management_plan, condition_id):
         """Fetch and format all independent and management plan attributes."""
-        excluded_keys = {AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED}
+        excluded_key_names = {AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED.value}
 
         # Fetch all attributes for this condition, joined with keys, and sort using sort_key
         if requires_management_plan:
@@ -274,7 +278,7 @@ def _fetch_all_attributes(requires_management_plan, condition_id):
                     .filter(
                         ConditionAttribute.condition_id == condition_id,
                         ConditionAttribute.management_plan_id == plan.id,
-                        ~ConditionAttribute.attribute_key_id.in_([key.value for key in excluded_keys])
+                        ~AttributeKey.key_name.in_(excluded_key_names)
                     )
                     .order_by(AttributeKey.sort_order)
                     .all()
@@ -307,7 +311,7 @@ def _fetch_all_attributes(requires_management_plan, condition_id):
             .filter(
                 ConditionAttribute.condition_id == condition_id,
                 ConditionAttribute.management_plan_id.is_(None),
-                ~ConditionAttribute.attribute_key_id.in_([key.value for key in excluded_keys]),
+                ~AttributeKey.key_name.in_(excluded_key_names),
             )
             .order_by(AttributeKey.sort_order)
             .all()

condition-api/src/condition_api/services/condition_service.py

@@ -503,7 +503,8 @@ def upsert_subconditions(condition_id, subconditions, parent_id=None):
                     condition_id, subcond_data["subconditions"], parent_id=subcondition_id)
 
     @staticmethod
-    def create_condition(project_id, document_id, conditions_data, allow_duplicate_condition=None):
+    def create_condition(project_id, document_id, conditions_data,
+                         allow_duplicate_condition=None, check_condition_over_project=None):
         """Create a new condition."""
         amendment = (
             db.session.query(Amendment.document_id)
@@ -548,6 +549,28 @@ def create_condition(project_id, document_id, conditions_data, allow_duplicate_c
                     db.session.add(condition)
         else:
             final_document_id = document_id
+            # Check for duplicate condition number within the same document
+            condition_number = conditions_data.get("condition_number")
+            if condition_number:
+                ConditionService._check_duplicate_condition_number(
+                    condition=Condition(
+                        document_id=final_document_id,
+                        amended_document_id=None
+                    ),
+                    condition_id=None,
+                    condition_number=condition_number
+                )
+
+        # Check for condition number conflict across the project
+        condition_number = conditions_data.get("condition_number")
+        if check_condition_over_project and condition_number:
+            temp_condition = Condition(
+                document_id=final_document_id,
+                amended_document_id=amended_document_id,
+                project_id=project_id
+            )
+            ConditionService._check_condition_conflict_in_project(
+                temp_condition, condition_number)
 
         new_condition = Condition(
             document_id=final_document_id,
@@ -999,23 +1022,23 @@ def _fetch_condition_attributes_external(
         if not include_condition_attributes:
             return []
 
-        excluded_keys = {AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED}
-        formatted_keys = {
-            AttributeKeys.PARTIES_REQUIRED_TO_BE_CONSULTED,
-            AttributeKeys.MILESTONES_RELATED_TO_PLAN_SUBMISSION,
-            AttributeKeys.MILESTONES_RELATED_TO_PLAN_IMPLEMENTATION,
-            AttributeKeys.MANAGEMENT_PLAN_NAME,
+        excluded_key_names = {AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED.value}
+        formatted_key_names = {
+            AttributeKeys.PARTIES_REQUIRED_TO_BE_CONSULTED.value,
+            AttributeKeys.MILESTONES_RELATED_TO_PLAN_SUBMISSION.value,
+            AttributeKeys.MILESTONES_RELATED_TO_PLAN_IMPLEMENTATION.value,
+            AttributeKeys.MANAGEMENT_PLAN_NAME.value,
         }
 
         query = db.session.query(
-            AttributeKey.id,
+            AttributeKey.key_name,
             AttributeKey.external_key,
             ConditionAttribute.attribute_value,
         ).outerjoin(
             AttributeKey, ConditionAttribute.attribute_key_id == AttributeKey.id
         ).filter(
             ConditionAttribute.condition_id == condition_id,
-            ~ConditionAttribute.attribute_key_id.in_([key.value for key in excluded_keys]),
+            ~AttributeKey.key_name.in_(excluded_key_names),
         )
 
         if management_plan_id:
@@ -1029,31 +1052,29 @@ def _fetch_condition_attributes_external(
         requires_iem = False
         deliverables = []
 
-        for attr_id, external_key, raw_value in attributes_data:
+        for key_name, external_key, raw_value in attributes_data:
             if not external_key:
                 continue
 
-            key_enum = AttributeKeys(attr_id)
-
             # Handle requires_iem_terms_of_engagement
-            if key_enum == AttributeKeys.REQUIRES_IEM_TERMS_OF_ENGAGEMENT:
+            if key_name == AttributeKeys.REQUIRES_IEM_TERMS_OF_ENGAGEMENT.value:
                 requires_iem = raw_value
                 result[external_key] = requires_iem
                 continue
 
             # Handle deliverable_name separately
-            if key_enum == AttributeKeys.DELIVERABLE_NAME:
-                deliverables.append((raw_value or "", attr_id))
+            if key_name == AttributeKeys.DELIVERABLE_NAME.value:
+                deliverables.append((raw_value or "", key_name))
                 continue
 
             # Format value
-            value = ConditionService._format_attribute_value(key_enum, raw_value, formatted_keys)
+            value = ConditionService._format_attribute_value(key_name, raw_value, formatted_key_names)
             result[external_key] = value
 
         # Handle deliverables
         if deliverables:
             result.update(
-                ConditionService._process_deliverables(deliverables, requires_iem, formatted_keys)
+                ConditionService._process_deliverables(deliverables, requires_iem, formatted_key_names)
             )
 
         if management_plan_id:
@@ -1063,9 +1084,9 @@ def _fetch_condition_attributes_external(
         return result
 
     @staticmethod
-    def _format_attribute_value(key_enum, raw_value, formatted_keys):
+    def _format_attribute_value(key_name, raw_value, formatted_key_names):
         """Format value"""
-        if key_enum in formatted_keys:
+        if key_name in formatted_key_names:
             return ConditionService.format_attribute_value(raw_value)
         return (
             raw_value.replace("{", "").replace("}", "").replace('"', "")
@@ -1074,7 +1095,7 @@ def _format_attribute_value(key_enum, raw_value, formatted_keys):
         )
 
     @staticmethod
-    def _process_deliverables(deliverables, requires_iem, formatted_keys):
+    def _process_deliverables(deliverables, requires_iem, formatted_key_names):
         deliverable_phrase = IEMTermsConfig.DELIVERABLE_VALUE
         selected_value = None
 
@@ -1089,7 +1110,7 @@ def _process_deliverables(deliverables, requires_iem, formatted_keys):
         if not selected_value:
             return {}
 
-        if AttributeKeys.DELIVERABLE_NAME in formatted_keys:
+        if AttributeKeys.DELIVERABLE_NAME.value in formatted_key_names:
             return {"deliverable_name": [ConditionService.format_attribute_value(selected_value)]}
 
         return {
@@ -1275,7 +1296,7 @@ def _fetch_condition_attributes(requires_management_plan, condition_id):
                 .outerjoin(AttributeKey, ConditionAttribute.attribute_key_id == AttributeKey.id)
                 .filter(
                     ManagementPlan.condition_id == condition_id,
-                    ~ConditionAttribute.attribute_key_id.in_([5])
+                    AttributeKey.key_name != AttributeKeys.PARTIES_REQUIRED_TO_BE_SUBMITTED.value
                 )
                 .order_by(ManagementPlan.id, AttributeKey.sort_order)
                 .all()