fixed deletion of requirements and added modal to see deleted requirements

backend/src/db_models.py

@@ -236,16 +236,25 @@ class Requirement(Base):
         secondary="requirements_groups",
         back_populates="requirements"
     )
-    validations: Mapped[List["Validation"]] = relationship("Validation", back_populates="requirement")
+    validations: Mapped[List["Validation"]] = relationship(
+        "Validation",
+        back_populates="requirement",
+        cascade="all, delete-orphan",
+        passive_deletes=True
+    )
     outgoing_links: Mapped[List["RequirementLink"]] = relationship(
         "RequirementLink",
         foreign_keys="RequirementLink.source_req_id",
-        back_populates="source_requirement"
+        back_populates="source_requirement",
+        cascade="all, delete-orphan",
+        passive_deletes=True
     )
     incoming_links: Mapped[List["RequirementLink"]] = relationship(
         "RequirementLink",
         foreign_keys="RequirementLink.target_req_id",
-        back_populates="target_requirement"
+        back_populates="target_requirement",
+        cascade="all, delete-orphan",
+        passive_deletes=True
     )
     comments: Mapped[List["RequirementComment"]] = relationship(
         "RequirementComment",

backend/src/main.py

@@ -15,7 +15,7 @@ from src.models import (
     RequirementLinkResponse, RequirementLinkCreateRequest, RequirementSearchResult,
     RoleResponse, ProjectMemberResponse, UserRoleUpdateRequest, ROLE_DISPLAY_NAMES,
     CommentResponse, CommentReplyResponse, CommentCreateRequest, ReplyCreateRequest,
-    RequirementStatusResponse
+    RequirementStatusResponse, DeletedRequirementResponse
 )
 from src.controller import AuthController
 from src.config import get_openid, get_settings
@@ -1130,6 +1130,35 @@ async def get_requirement_history(
     return [RequirementHistoryResponse(**h) for h in history]
 
 
+@app.get("/api/projects/{project_id}/deleted-requirements", response_model=List[DeletedRequirementResponse])
+async def get_deleted_requirements(
+    project_id: int,
+    request: Request,
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Get all deleted requirements for a project.
+    Returns requirements that exist in history but have been deleted.
+    User must be a member of the project.
+    
+    Args:
+        project_id: The project to get deleted requirements for
+        
+    Returns:
+        List of deleted requirements with their last known state.
+    """
+    user = await _get_current_user_db(request, db)
+    
+    # Verify user is a member of the project
+    await _verify_project_membership(project_id, user.id, db)
+    
+    # Get deleted requirements
+    req_repo = RequirementRepository(db)
+    deleted = await req_repo.get_deleted_requirements(project_id)
+    
+    return [DeletedRequirementResponse(**d) for d in deleted]
+
+
 # ===========================================
 # Validation Endpoints
 # ===========================================

backend/src/models.py

@@ -275,6 +275,22 @@ class RequirementHistoryResponse(BaseModel):
         from_attributes = True
 
 
+class DeletedRequirementResponse(BaseModel):
+    """Response schema for a deleted requirement from history."""
+    history_id: int
+    original_req_id: int
+    version: Optional[int] = None
+    req_name: Optional[str] = None
+    req_desc: Optional[str] = None
+    tag_code: Optional[str] = None
+    priority_name: Optional[str] = None
+    deleted_by_username: Optional[str] = None
+    deleted_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+
 # Relationship Type schemas
 class RelationshipTypeResponse(BaseModel):
     """Response schema for a relationship type."""

backend/src/repositories/requirement_repository.py

@@ -422,3 +422,73 @@ class RequirementRepository:
             }
             for row in rows
         ]
+
+    async def get_deleted_requirements(self, project_id: int) -> List[Dict[str, Any]]:
+        """
+        Get all deleted requirements for a project.
+        A requirement is considered deleted if it exists in requirements_history
+        but NOT in the requirements table.
+        
+        Args:
+            project_id: The project ID to get deleted requirements for
+            
+        Returns:
+            List of deleted requirements with their last known state
+        """
+        # Find requirements that exist in history but not in the main table
+        # We get the latest version of each deleted requirement
+        query = text("""
+            WITH deleted_req_ids AS (
+                SELECT DISTINCT rh.original_req_id
+                FROM requirements_history rh
+                WHERE rh.project_id = :project_id
+                AND NOT EXISTS (
+                    SELECT 1 FROM requirements r 
+                    WHERE r.id = rh.original_req_id
+                )
+            ),
+            latest_versions AS (
+                SELECT rh.original_req_id, MAX(rh.version) as max_version
+                FROM requirements_history rh
+                INNER JOIN deleted_req_ids d ON rh.original_req_id = d.original_req_id
+                GROUP BY rh.original_req_id
+            )
+            SELECT 
+                rh.history_id,
+                rh.original_req_id,
+                rh.version,
+                rh.req_name,
+                rh.req_desc,
+                t.tag_code,
+                p.priority_name,
+                u.full_name as deleted_by_full_name,
+                u.username as deleted_by_username,
+                rh.valid_from,
+                rh.valid_to
+            FROM requirements_history rh
+            INNER JOIN latest_versions lv 
+                ON rh.original_req_id = lv.original_req_id 
+                AND rh.version = lv.max_version
+            LEFT JOIN tags t ON rh.tag_id = t.id
+            LEFT JOIN priorities p ON rh.priority_id = p.id
+            LEFT JOIN users u ON rh.edited_by = u.id
+            ORDER BY rh.valid_to DESC
+        """)
+        
+        result = await self.session.execute(query, {"project_id": project_id})
+        rows = result.fetchall()
+        
+        return [
+            {
+                "history_id": row.history_id,
+                "original_req_id": row.original_req_id,
+                "version": row.version,
+                "req_name": row.req_name,
+                "req_desc": row.req_desc,
+                "tag_code": row.tag_code,
+                "priority_name": row.priority_name,
+                "deleted_by_username": row.deleted_by_full_name or row.deleted_by_username,
+                "deleted_at": row.valid_to,
+            }
+            for row in rows
+        ]