validations and dockerfiles are updated

api_events/events/address/address.py

@@ -22,7 +22,7 @@ from api_validations.validations_request import (
     UpdatePostCode,
     SearchAddress,
 )
-from api_validations.core_response import AlchemyJsonResponse
+from ApiServices.api_handlers import AlchemyJsonResponse
 from api_events.events.abstract_class import MethodToEvent, ActionsSchema
 from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
 
@@ -77,9 +77,7 @@ class AddressListEventMethods(MethodToEvent):
         Addresses.filter_attr = list_options
         records = Addresses.filter_all().data
         return AlchemyJsonResponse(
-            completed=True,
-            message="List Address records",
-            result=records,
+            completed=True, message="List Address records", result=records
         )
 
     @classmethod
@@ -89,13 +87,12 @@ class AddressListEventMethods(MethodToEvent):
         token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
     ):
         Addresses.filter_attr = list_options
-        records = Addresses.list_via_employee(
-            token_dict=token_dict,
+        Addresses.pre_query = Addresses.filter_all(
+            Addresses.street_id.in_(get_street_ids),
         )
+        records = Addresses.filter_all().data
         return AlchemyJsonResponse(
-            completed=True,
-            message="List Address records",
-            result=records,
+            completed=True, message="List Address records", result=records
         )
 
 
@@ -135,21 +132,20 @@ class AddressCreateEventMethods(MethodToEvent):
         address.save()
         address.update(is_confirmed=True)
         address.save()
-        return JSONResponse(
-            content={
-                "completed": True,
-                "message": "Create Address record",
-                "data": address.get_dict(),
-            },
-            status_code=200,
+        return AlchemyJsonResponse(
+            completed=True, message="Address created successfully", result=address.get_dict()
         )
 
 
 class AddressSearchEventMethods(MethodToEvent):
-
+    """Event methods for searching addresses.
+    
+    This class handles address search functionality including text search
+    and filtering.
+    """
     event_type = "SEARCH"
-    event_description = ""
-    event_category = ""
+    event_description = "Search for addresses using text and filters"
+    event_category = "Address"
 
     __event_keys__ = {
         "e0ac1269-e9a7-4806-9962-219ac224b0d0": "search_address",
@@ -158,69 +154,132 @@ class AddressSearchEventMethods(MethodToEvent):
         "e0ac1269-e9a7-4806-9962-219ac224b0d0": SearchAddress,
     }
 
+    @classmethod
+    def _build_order_clause(
+        cls,
+        filter_list: Dict[str, Any],
+        schemas: List[str],
+        filter_table: Any
+    ) -> Any:
+        """Build the ORDER BY clause for the query.
+        
+        Args:
+            filter_list: Dictionary of filter options
+            schemas: List of available schema fields
+            filter_table: SQLAlchemy table to query
+            
+        Returns:
+            SQLAlchemy order_by clause
+        """
+        # Default to ordering by UUID if field not in schema
+        if filter_list.get("order_field") not in schemas:
+            filter_list["order_field"] = "uu_id"
+        else:
+            # Extract table and field from order field
+            table_name, field_name = str(filter_list.get("order_field")).split(".")
+            filter_table = getattr(databases.sql_models, table_name)
+            filter_list["order_field"] = field_name
+
+        # Build order clause
+        field = getattr(filter_table, filter_list.get("order_field"))
+        return field.desc() if str(filter_list.get("order_type"))[0] == "d" else field.asc()
+
+    @classmethod
+    def _format_record(cls, record: Any, schemas: List[str]) -> Dict[str, str]:
+        """Format a database record into a dictionary.
+        
+        Args:
+            record: Database record to format
+            schemas: List of schema fields
+            
+        Returns:
+            Formatted record dictionary
+        """
+        result = {}
+        for index, schema in enumerate(schemas):
+            value = str(record[index])
+            # Special handling for UUID fields
+            if "uu_id" in value:
+                value = str(value)
+            result[schema] = value
+        return result
+
     @classmethod
     def search_address(
         cls,
         data: SearchAddress,
         token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
-    ):
-        import databases.sql_models
-        from time import perf_counter
+    ) -> JSONResponse:
+        """Search for addresses using text search and filters.
+        
+        Args:
+            data: Search parameters including text and filters
+            token_dict: Authentication token
+            
+        Returns:
+            JSON response with search results
+            
+        Raises:
+            HTTPException: If search fails
+        """
+        try:
+            # Start performance measurement
+            start_time = perf_counter()
 
-        st = perf_counter()
+            # Get initial query
+            search_result = AddressStreet.search_address_text(search_text=data.search)
+            if not search_result:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="No addresses found matching search criteria"
+                )
 
-        pre_query_first = AddressStreet.search_address_text(search_text=data.search)
-        query, schemas, new_data_list = (
-            pre_query_first.get("query"),
-            pre_query_first.get("schema"),
-            [],
-        )
-        filter_list = data.list_options.dump()
-        filter_table = AddressStreet
-        if filter_list.get("order_field") not in schemas:
-            filter_list["order_field"] = "uu_id"
-        else:
-            filter_table = getattr(
-                databases.sql_models, str(filter_list.get("order_field")).split(".")[0]
+            query = search_result.get("query")
+            schemas = search_result.get("schema")
+            
+            # Apply filters
+            filter_list = data.list_options.dump()
+            filter_table = AddressStreet
+            
+            # Build and apply order clause
+            order = cls._build_order_clause(filter_list, schemas, filter_table)
+            
+            # Apply pagination
+            page_size = int(filter_list.get("size"))
+            offset = (int(filter_list.get("page")) - 1) * page_size
+            
+            # Execute query
+            query = (
+                query.order_by(order)
+                .limit(page_size)
+                .offset(offset)
+                .populate_existing()
             )
-            filter_list["order_field"] = str(filter_list.get("order_field")).split(".")[
-                1
-            ]
+            records = list(query.all())
 
-        order = (
-            getattr(filter_table, filter_list.get("order_field")).desc()
-            if str(filter_list.get("order_type"))[0] == "d"
-            else getattr(filter_table, filter_list.get("order_field")).asc()
-        )
+            # Format results
+            results = [cls._format_record(record, schemas) for record in records]
 
-        query = (
-            query.order_by(order)
-            .limit(int(filter_list.get("size")))
-            .offset(int((filter_list.get("page")) - 1) * int(filter_list.get("size")))
-            .populate_existing()
-        )
+            # Log performance
+            duration = perf_counter() - start_time
+            print(f"Address search completed in {duration:.3f}s")
 
-        records = list(query.all())
-        print(perf_counter() - st)
+            return AlchemyJsonResponse(
+                completed=True, 
+                message="Address search results", 
+                result=results
+            )
 
-        for item in records:
-            new_data_dict = {}
-            for index, schema in enumerate(schemas):
-                new_data_dict[schema] = str(item[index])
-                if "uu_id" in str(item[index]):
-                    new_data_dict[schema] = str(new_data_dict.get(schema))
-            new_data_list.append(new_data_dict)
-
-        return JSONResponse(
-            content={
-                "completed": True,
-                "pagination": filter_list,
-                "count": len(new_data_list),
-                "data": new_data_list,
-                "message": "Search Address records",
-            },
-            status_code=200,
-        )
+        except HTTPException as e:
+            # Re-raise HTTP exceptions
+            raise e
+        except Exception as e:
+            # Log and wrap other errors
+            print(f"Address search error: {str(e)}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to search addresses"
+            ) from e
 
 
 class AddressUpdateEventMethods(MethodToEvent):
@@ -256,13 +315,8 @@ class AddressUpdateEventMethods(MethodToEvent):
             data_dict = data.excluded_dump()
             updated_address = address.update(**data_dict)
             updated_address.save()
-            return JSONResponse(
-                content={
-                    "completed": True,
-                    "message": "Update Address record",
-                    "data": updated_address.get_dict(),
-                },
-                status_code=200,
+            return AlchemyJsonResponse(
+                completed=True, message="Address updated successfully", result=updated_address.get_dict()
             )
         elif isinstance(token_dict, OccupantTokenObject):
             raise HTTPException(
@@ -308,13 +362,8 @@ class AddressPatchEventMethods(MethodToEvent):
         del data_dict["post_code_uu_id"]
 
         patched_address = address.patch(**data_dict)
-        return JSONResponse(
-            content={
-                "completed": True,
-                "message": "Patch Address record",
-                "data": patched_address.get_dict(),
-            },
-            status_code=200,
+        return AlchemyJsonResponse(
+            completed=True, message="Address patched successfully", result=patched_address.get_dict()
         )
 
 
@@ -361,13 +410,8 @@ class AddressPostCodeCreateEventMethods(MethodToEvent):
         post_code.save()
         relation_table.update(is_confirmed=True)
         relation_table.save()
-        return JSONResponse(
-            content={
-                "completed": True,
-                "message": "Create Post Code record",
-                "data": post_code.get_dict(),
-            },
-            status_code=200,
+        return AlchemyJsonResponse(
+            completed=True, message="Post code created successfully", result=post_code.get_dict()
         )
 
 
@@ -407,26 +451,16 @@ class AddressPostCodeUpdateEventMethods(MethodToEvent):
             data_dict = data.excluded_dump()
             updated_post_code = post_code.update(**data_dict)
             updated_post_code.save()
-            return JSONResponse(
-                content={
-                    "completed": True,
-                    "message": "Update Post Code record",
-                    "data": updated_post_code.get_dict(),
-                },
-                status_code=200,
+            return AlchemyJsonResponse(
+                completed=True, message="Post code updated successfully", result=updated_post_code.get_dict()
             )
         elif isinstance(token_dict, OccupantTokenObject):
             raise HTTPException(
                 status_code=403,
                 detail="Occupant can not update post code.",
             )
-        return JSONResponse(
-            content={
-                "completed": True,
-                "message": "Update Post Code record",
-                "data": {},
-            },
-            status_code=404,
+        return AlchemyJsonResponse(
+            completed=True, message="Update Post Code record", result={}
         )
 
 
@@ -459,17 +493,10 @@ class AddressPostCodeListEventMethods(MethodToEvent):
                 detail="User has no post code registered or not yet any post code created.",
             )
 
-        AddressPostcode.pre_query = AddressPostcode.filter_all(
-            AddressPostcode.id.in_(
-                [post_code.member_id for post_code in post_code_list]
-            ),
-        ).query
         AddressPostcode.filter_attr = list_options
-        records = AddressPostcode.filter_all().data
+        post_codes = AddressPostcode.filter_all()
         return AlchemyJsonResponse(
-            completed=True,
-            message="List Address records",
-            result=records,
+            completed=True, message="List Post code records", result=post_codes
         )