Refactor backend to adopt async patterns across services, API routes, and CRUD operations

- Migrated database sessions and operations to `AsyncSession` for full async support.
- Updated all service methods and dependencies (`get_db` to `get_async_db`) to support async logic.
- Refactored admin, user, organization, session-related CRUD methods, and routes with await syntax.
- Improved consistency and performance with async SQLAlchemy patterns.
- Enhanced logging and error handling for async context.

backend/app/crud/base_async.py

@@ -179,10 +179,25 @@ class CRUDBaseAsync(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
             raise
 
     async def get_multi_with_total(
-        self, db: AsyncSession, *, skip: int = 0, limit: int = 100
+        self,
+        db: AsyncSession,
+        *,
+        skip: int = 0,
+        limit: int = 100,
+        sort_by: Optional[str] = None,
+        sort_order: str = "asc",
+        filters: Optional[Dict[str, Any]] = None
     ) -> Tuple[List[ModelType], int]:
         """
-        Get multiple records with total count for pagination.
+        Get multiple records with total count, filtering, and sorting.
+
+        Args:
+            db: Database session
+            skip: Number of records to skip
+            limit: Maximum number of records to return
+            sort_by: Field name to sort by (must be a valid model attribute)
+            sort_order: Sort order ("asc" or "desc")
+            filters: Dictionary of filters (field_name: value)
 
         Returns:
             Tuple of (items, total_count)
@@ -196,16 +211,35 @@ class CRUDBaseAsync(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
             raise ValueError("Maximum limit is 1000")
 
         try:
-            # Get total count
-            count_result = await db.execute(
-                select(func.count(self.model.id))
-            )
+            # Build base query
+            query = select(self.model)
+
+            # Exclude soft-deleted records by default
+            if hasattr(self.model, 'deleted_at'):
+                query = query.where(self.model.deleted_at.is_(None))
+
+            # Apply filters
+            if filters:
+                for field, value in filters.items():
+                    if hasattr(self.model, field) and value is not None:
+                        query = query.where(getattr(self.model, field) == value)
+
+            # Get total count (before pagination)
+            count_query = select(func.count()).select_from(query.alias())
+            count_result = await db.execute(count_query)
             total = count_result.scalar_one()
 
-            # Get paginated items
-            items_result = await db.execute(
-                select(self.model).offset(skip).limit(limit)
-            )
+            # Apply sorting
+            if sort_by and hasattr(self.model, sort_by):
+                sort_column = getattr(self.model, sort_by)
+                if sort_order.lower() == "desc":
+                    query = query.order_by(sort_column.desc())
+                else:
+                    query = query.order_by(sort_column.asc())
+
+            # Apply pagination
+            query = query.offset(skip).limit(limit)
+            items_result = await db.execute(query)
             items = list(items_result.scalars().all())
 
             return items, total
@@ -226,3 +260,92 @@ class CRUDBaseAsync(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
         """Check if a record exists by ID."""
         obj = await self.get(db, id=id)
         return obj is not None
+
+    async def soft_delete(self, db: AsyncSession, *, id: str) -> Optional[ModelType]:
+        """
+        Soft delete a record by setting deleted_at timestamp.
+
+        Only works if the model has a 'deleted_at' column.
+        """
+        from datetime import datetime, timezone
+
+        # Validate UUID format and convert to UUID object if string
+        try:
+            if isinstance(id, uuid.UUID):
+                uuid_obj = id
+            else:
+                uuid_obj = uuid.UUID(str(id))
+        except (ValueError, AttributeError, TypeError) as e:
+            logger.warning(f"Invalid UUID format for soft deletion: {id} - {str(e)}")
+            return None
+
+        try:
+            result = await db.execute(
+                select(self.model).where(self.model.id == uuid_obj)
+            )
+            obj = result.scalar_one_or_none()
+
+            if obj is None:
+                logger.warning(f"{self.model.__name__} with id {id} not found for soft deletion")
+                return None
+
+            # Check if model supports soft deletes
+            if not hasattr(self.model, 'deleted_at'):
+                logger.error(f"{self.model.__name__} does not support soft deletes")
+                raise ValueError(f"{self.model.__name__} does not have a deleted_at column")
+
+            # Set deleted_at timestamp
+            obj.deleted_at = datetime.now(timezone.utc)
+            db.add(obj)
+            await db.commit()
+            await db.refresh(obj)
+            return obj
+        except Exception as e:
+            await db.rollback()
+            logger.error(f"Error soft deleting {self.model.__name__} with id {id}: {str(e)}", exc_info=True)
+            raise
+
+    async def restore(self, db: AsyncSession, *, id: str) -> Optional[ModelType]:
+        """
+        Restore a soft-deleted record by clearing the deleted_at timestamp.
+
+        Only works if the model has a 'deleted_at' column.
+        """
+        # Validate UUID format
+        try:
+            if isinstance(id, uuid.UUID):
+                uuid_obj = id
+            else:
+                uuid_obj = uuid.UUID(str(id))
+        except (ValueError, AttributeError, TypeError) as e:
+            logger.warning(f"Invalid UUID format for restoration: {id} - {str(e)}")
+            return None
+
+        try:
+            # Find the soft-deleted record
+            if hasattr(self.model, 'deleted_at'):
+                result = await db.execute(
+                    select(self.model).where(
+                        self.model.id == uuid_obj,
+                        self.model.deleted_at.isnot(None)
+                    )
+                )
+                obj = result.scalar_one_or_none()
+            else:
+                logger.error(f"{self.model.__name__} does not support soft deletes")
+                raise ValueError(f"{self.model.__name__} does not have a deleted_at column")
+
+            if obj is None:
+                logger.warning(f"Soft-deleted {self.model.__name__} with id {id} not found for restoration")
+                return None
+
+            # Clear deleted_at timestamp
+            obj.deleted_at = None
+            db.add(obj)
+            await db.commit()
+            await db.refresh(obj)
+            return obj
+        except Exception as e:
+            await db.rollback()
+            logger.error(f"Error restoring {self.model.__name__} with id {id}: {str(e)}", exc_info=True)
+            raise