updated Postgres Service

Controllers/Postgres/filter.py

@@ -14,7 +14,7 @@ from sqlalchemy import ColumnExpressionArgument
 from sqlalchemy.orm import Query, Session
 from sqlalchemy.sql.elements import BinaryExpression
 
-from response import PostgresResponse
+from Controllers.Postgres.response import PostgresResponse
 
 
 T = TypeVar("T", bound="QueryModel")
@@ -28,7 +28,10 @@ class QueryModel:
     @classmethod
     def _query(cls: Type[T], db: Session) -> Query:
         """Returns the query to use in the model."""
-        return cls.pre_query if cls.pre_query else db.query(cls)
+        if cls.pre_query is not None:
+            # Return the pre_query directly as it's already a Query object
+            return cls.pre_query
+        return db.query(cls)
 
     @classmethod
     def add_new_arg_to_args(
@@ -82,11 +85,21 @@ class QueryModel:
         """
         try:
             current_time = str(arrow.now())
-            starts = cls.expiry_starts <= current_time
-            ends = cls.expiry_ends > current_time
-            
-            args = cls.add_new_arg_to_args(args, "expiry_ends", ends)
-            args = cls.add_new_arg_to_args(args, "expiry_starts", starts)
+            # Only add expiry filters if they don't already exist
+            if not any(
+                getattr(getattr(arg, "left", None), "key", None) == "expiry_ends" 
+                for arg in args
+            ):
+                ends = cls.expiry_ends > current_time
+                args = cls.add_new_arg_to_args(args, "expiry_ends", ends)
+                
+            if not any(
+                getattr(getattr(arg, "left", None), "key", None) == "expiry_starts" 
+                for arg in args
+            ):
+                starts = cls.expiry_starts <= current_time
+                args = cls.add_new_arg_to_args(args, "expiry_starts", starts)
+                
             return args
             
         except AttributeError as e:
@@ -95,9 +108,10 @@ class QueryModel:
             ) from e
 
     @classmethod
-    def produce_query_to_add(cls: Type[T], filter_list, args):
+    def produce_query_to_add(cls: Type[T], filter_list: dict, args: tuple) -> tuple:
         """
         Adds query to main filter options
+        
         Args:
             filter_list: Dictionary containing query parameters
             args: Existing query arguments to add to
@@ -105,11 +119,25 @@ class QueryModel:
         Returns:
             Updated query arguments tuple
         """
-        if filter_list.get("query"):
-            for smart_iter in cls.filter_expr(**filter_list["query"]):
-                if key := getattr(getattr(smart_iter, "left", None), "key", None):
-                    args = cls.add_new_arg_to_args(args, key, smart_iter)
-        return args
+        try:
+            if not filter_list or not isinstance(filter_list, dict):
+                return args
+                
+            query_params = filter_list.get("query")
+            if not query_params or not isinstance(query_params, dict):
+                return args
+                
+            for key, value in query_params.items():
+                if hasattr(cls, key):
+                    # Create a new filter expression
+                    filter_expr = getattr(cls, key) == value
+                    # Add it to args if it doesn't exist
+                    args = cls.add_new_arg_to_args(args, key, filter_expr)
+            return args
+            
+        except Exception as e:
+            print(f"Error in produce_query_to_add: {str(e)}")
+            return args
 
     @classmethod
     def convert(
@@ -151,13 +179,30 @@ class QueryModel:
         Returns:
             Query response with single record
         """
-        if "is_confirmed" not in kwargs and not system:
-            kwargs["is_confirmed"] = True
-        kwargs.pop("system", None)
-        query = cls._query(db).filter_by(**kwargs)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add keyword filters first
+        query = query.filter_by(**kwargs)
+            
+        # Add status filters if not system query
+        if not system:
+            query = query.filter(
+                cls.is_confirmed == True,
+                cls.deleted == False,
+                cls.active == True
+            )
+            
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=False
         )
@@ -178,11 +223,29 @@ class QueryModel:
         Returns:
             Query response with single record
         """
-        args = cls.get_not_expired_query_arg(args)
-        query = cls._query(db).filter(*args)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add expression filters first
+        query = query.filter(*args)
+        
+        # Add status filters
+        query = query.filter(
+            cls.is_confirmed == True,
+            cls.deleted == False,
+            cls.active == True
+        )
+        
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=False
         )
@@ -203,10 +266,22 @@ class QueryModel:
         Returns:
             Query response with single record
         """
-        query = cls._query(db).filter(*args)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add expression filters first
+        query = query.filter(*args)
+        
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=False
         )
@@ -227,10 +302,22 @@ class QueryModel:
         Returns:
             Query response with matching records
         """
-        query = cls._query(db).filter(*args)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add expression filters first
+        query = query.filter(*args)
+        
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=True
         )
@@ -251,11 +338,29 @@ class QueryModel:
         Returns:
             Query response with matching records
         """
-        args = cls.get_not_expired_query_arg(args)
-        query = cls._query(db).filter(*args)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add expression filters first
+        query = query.filter(*args)
+        
+        # Add status filters
+        query = query.filter(
+            cls.is_confirmed == True,
+            cls.deleted == False,
+            cls.active == True
+        )
+        
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=True
         )
@@ -267,7 +372,7 @@ class QueryModel:
         **kwargs: Any
     ) -> PostgresResponse[T]:
         """
-        Filter multiple records by keyword arguments.
+        Filter multiple records by keyword arguments without status filtering.
 
         Args:
             db: Database session
@@ -276,10 +381,41 @@ class QueryModel:
         Returns:
             Query response with matching records
         """
-        query = cls._query(db).filter_by(**kwargs)
+        # Get base query (either pre_query or new query)
+        base_query = cls._query(db)
+        
+        # Create the final query by applying filters
+        query = base_query
+        
+        # Add keyword filters first
+        query = query.filter_by(**kwargs)
+        
+        # Add expiry filters last
+        args = cls.get_not_expired_query_arg(())
+        query = query.filter(*args)
+        
         return PostgresResponse(
             model=cls, 
-            pre_query=cls._query(db), 
+            pre_query=base_query,  # Use the base query for pre_query
             query=query, 
             is_array=True
         )
+
+    @classmethod
+    def filter_by_one_system(
+        cls: Type[T], 
+        db: Session, 
+        **kwargs: Any
+    ) -> PostgresResponse[T]:
+        """
+        Filter single record by keyword arguments without status filtering.
+
+        Args:
+            db: Database session
+            **kwargs: Filter criteria
+
+        Returns:
+            Query response with single record
+        """
+        # Use filter_by_one with system=True to avoid code duplication
+        return cls.filter_by_one(db=db, system=True, **kwargs)