backup commit

Author: nikgreg99

.env.sample

@@ -35,6 +35,11 @@ ANALYTICQ_DB_URL=postgresql+asyncpg://${POSTGRES_NON_ROOT_USER}:${POSTGRES_NON_R
 # Secondary storage URL
 ANALYTICQ_DB_MONGO_URL=mongodb://${MONGO_INITDB_USERNAME}:${MONGO_INITDB_PASSWORD}@${MONGO_HOST}:${MONGO_PORT}/${MONGO_INITDB_DATABASE}/?authSource=${MONGO_AUTH_SOURCE}
 
+FRONTEND_CORS_HOST=localhost
+FRONTEND_CORS_HOST=5173
+
+ANALYTICQ_FRONTEND_CORS_URL=http://${FRONTEND_CORS_HOST}:${FRONTEND_CORS_PORT}
+
 # ============================
 # RabbitMQ Configuration
 # ============================

analyticq-backend/analyticq/api/contexts.py

@@ -4,18 +4,24 @@
 from analyticq.repository.context_repository import (
     AnalyticQContextModel, AnalyticQContextRepository,
     AnalyticQSASTScanResultModel)
+from analyticq.repository.stats_repository import AnalyticQStatsRepository
 from analyticq.schemas.context_dto import PaginatedContextResponse
+from analyticq.schemas.error_dto import ErrorResponse
 from analyticq.service.context_service import AnalyticQContextService
+from analyticq.service.stats_service import (AnalyticQStatsModel,
+                                             AnalyticQStatsService)
 from fastapi import APIRouter, Depends, Query, status
-from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
 context_router = APIRouter(prefix="/contexts", tags=["Context Management"])
 
 
-class ErrorResponse(BaseModel):
-    detail: str
+def get_stats_service(
+    repo: AnalyticQStatsRepository = Depends(AnalyticQStatsRepository)
+) -> AnalyticQStatsService:
+    """Dependency provider for stats service."""
+    return AnalyticQStatsService(repo)
 
 
 def get_context_service(
@@ -68,23 +74,45 @@ async def get_all_contexts(
         }
 
 
-def get_context_service(
-    repo: AnalyticQContextRepository = Depends(AnalyticQContextRepository)
-) -> AnalyticQContextService:
-    """Dependency provider for context service."""
-    return AnalyticQContextService(repo)
+@context_router.get(
+    "/repo/prefix/{prefix}",
+    response_model=List[AnalyticQContextModel],
+    summary="Get contexts by repository name prefix",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": ErrorResponse, "description": "No matching contexts found"},
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"}
+    }
+)
+async def get_contexts_by_repo_prefix(
+    prefix: str,
+    service: AnalyticQContextService = Depends(get_context_service)
+):
+    """
+    Get all contexts whose repository name starts with the given prefix.
+
+    Args:
+        prefix (str): The prefix to filter repository names.
+        service (AnalyticQContextService): The service to handle context operations (injected dependency).
+
+    Returns:
+        list[Context]: A list of contexts matching the repository name prefix.
+
+    Raises:
+        HTTPException: If there's an error retrieving the contexts.
+    """
+    return await service.get_contexts_by_repo_prefix(prefix)
 
 
 @context_router.get(
-    "/{repo_name}",
+    "/repo/{repo_name}",
     response_model=AnalyticQContextModel,
     summary="Get context by repository name",
     responses={
         status.HTTP_404_NOT_FOUND: {"model": ErrorResponse, "description": "Context not found"},
         status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"},
     },
 )
-async def get_context(
+async def get_context_by_repo_name(
     repo_name: str,
     service: AnalyticQContextService = Depends(get_context_service)
 ):
@@ -94,9 +122,48 @@ async def get_context(
     - **repo_name**: Name of the repository to get context for.
     - **returns**: Complete context information including repository metadata.
     """
+    logger.info(repo_name)
     return await service.get_context_by_repo_name(repo_name)
 
 
+@context_router.get(
+    "/{context_id}/stats",
+    response_model=AnalyticQStatsModel,
+    summary="Get stats by context id",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": ErrorResponse, "description": " Stats not found"},
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"},
+    }
+)
+async def get_stats_by_context_id(
+    context_id: int,
+    stats_service: AnalyticQStatsService = Depends(get_stats_service)
+):
+    """
+    Retrieve statistics analysis by its context ID.
+
+    - **context_id**: ID of the context to get stats for.
+    - **returns**: Statistics data associated with the context.
+    """
+    return await stats_service.get_stats_by_context_id(context_id)
+
+
+@context_router.get(
+    "/{id}",
+    response_model=AnalyticQContextModel,
+    summary="Get context by its id",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": ErrorResponse, "description": "Context not found"},
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"},
+    }
+)
+async def get_context_by_id(
+    id: int,
+    context_service: AnalyticQContextService = Depends(get_context_service)
+):
+    return await context_service.get_context_by_id(id)
+
+
 @context_router.get(
     "/{repo_name}/scans",
     response_model=List[AnalyticQSASTScanResultModel],

analyticq-backend/analyticq/api/issues.py

@@ -1,28 +1,61 @@
 import logging
+from typing import Optional
 
 from analyticq.repository.issue_repository import (
     AnalyticQSASTIssueModel, AnalyticQSASTIssueRepository)
-from analyticq.schemas.issue_dto import IssueUpdateRequest
+from analyticq.schemas.error_dto import ErrorResponse
+from analyticq.schemas.issue_dto import (IssueUpdateRequest,
+                                         PaginatedIssueResponse)
 from analyticq.service import AnalyticQSASTIssueService
-from fastapi import APIRouter, Depends, status
-from pydantic import BaseModel
+from fastapi import APIRouter, Depends, Query, status
 
 logger = logging.getLogger(__name__)
 
 issue_router = APIRouter(prefix="/issues", tags=["Issue Management"])
 
 
-class ErrorResponse(BaseModel):
-    detail: str
-
-
 def get_issue_service(
     repo: AnalyticQSASTIssueRepository = Depends(AnalyticQSASTIssueRepository)
 ) -> AnalyticQSASTIssueService:
     """Dependency provider for issue service."""
     return AnalyticQSASTIssueService(repo)
 
 
+@issue_router.get(
+    "/",
+    summary="Get all issue paginated",
+    response_model=PaginatedIssueResponse,
+    responses={
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"},
+    },
+)
+async def get_all_contexts(
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: Optional[int] = Query(10, ge=1, le=100, description="Number of items per page, set to 0 for all items"),
+    service: AnalyticQSASTIssueService = Depends(get_issue_service)
+):
+    if page_size == 0:
+        # Get all contexts without pagination
+        issues = await service.get_all_issues()
+        return {
+            "items": issues,
+            "total": len(issues),
+            "page": 1,
+            "page_size": len(issues),
+            "has_more": False
+        }
+    else:
+        # Get contexts with pagination
+        issues, total = await service.get_all_issues_paginated(page, page_size)
+        return {
+            "items": issues,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "has_more": (page * page_size) < total
+        }
+
+
 @issue_router.get(
     "/{issue_id}",
     response_model=AnalyticQSASTIssueModel,

analyticq-backend/analyticq/api/scans.py

@@ -1,86 +1,76 @@
 import logging
-from enum import Enum
 from typing import List, Optional
 
 from analyticq.repository.scan_repository import (
-    AnalyticQSASTIssueModel, AnalyticQSASTScanResultModel,
-    AnalyticQScanResultRepository)
-from analyticq.schemas.scan_dto import ScanCreateRequest
+    AnalyticQSASTScanResultModel, AnalyticQScanResultRepository)
+from analyticq.schemas.error_dto import ErrorResponse
+from analyticq.schemas.scan_dto import PaginatedScanResponse
 from analyticq.service import AnalyticQScanService
 from fastapi import APIRouter, Depends, Query, status
-from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
 scan_router = APIRouter(prefix="/scans", tags=["Scan Management"])
 
 
-class ErrorResponse(BaseModel):
-    detail: str
-
-
-class Severity(str, Enum):
-    CRITICAL = "CRITICAL"
-    HIGH = "HIGH"
-    MEDIUM = "MEDIUM"
-    LOW = "LOW"
-    UNKNOWN = "UNKNOWN"
-
-
-class Confidence(str, Enum):
-    CRITICAL = "CRITICAL"
-    HIGH = "HIGH"
-    MEDIUM = "MEDIUM"
-    LOW = "LOW"
-    UNKNOWN = "UNKNOWN"
-
-
 def get_scan_service(
     repo: AnalyticQScanResultRepository = Depends(AnalyticQScanResultRepository)
 ) -> AnalyticQScanService:
     """Dependency provider for scan service."""
     return AnalyticQScanService(repo)
 
 
-@scan_router.post(
+@scan_router.get(
     "/",
-    response_model=AnalyticQSASTScanResultModel,
-    status_code=status.HTTP_201_CREATED,
+    summary="Get all scans paginated",
+    response_model=PaginatedScanResponse,
     responses={
-        status.HTTP_201_CREATED: {"description": "Scan created successfully"},
-        status.HTTP_400_BAD_REQUEST: {"model": ErrorResponse},
-        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse, "description": "Internal server error"},
     },
 )
-async def create_scan(
-    scan_data: ScanCreateRequest,
+async def get_all_scans_paginated(
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: Optional[int] = Query(10, ge=1, le=100, description="Number of items per page, set to 0 for all items"),
     service: AnalyticQScanService = Depends(get_scan_service)
 ):
-    """
-    Create a new scan record in the system.
-    """
-    return await service.create_scan(scan_data)
+    if page_size == 0:
+        scans = await service.get_all_scan()
+        return {
+            "items": scans,
+            "total": len(scans),
+            "page": 1,
+            "page_size": len(scans),
+            "has_more": False
+        }
+    else:
+        # Get scans with pagination
+        scans, total = await service.get_all_scans_paginated(page, page_size)
+        return {
+            "items": scans,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "has_more": (page * page_size) < total
+        }
 
 
 @scan_router.get(
-    "/{scan_id}/issues",
-    response_model=List[AnalyticQSASTIssueModel],
+    "/{scan_id}",
+    response_model=AnalyticQSASTScanResultModel,
+    summary="Get a scans by ID",
     responses={
-        status.HTTP_200_OK: {"description": "List of filtered issues"},
         status.HTTP_404_NOT_FOUND: {"model": ErrorResponse},
         status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
     },
 )
-async def get_filtered_scan_issues(
-    scan_id: str,
-    severity: Optional[Severity] = Query(None, description="Filter issues by severity"),
-    confidence: Optional[Confidence] = Query(None, description="Filter issues by confidence"),
+async def get_scan_by_id(
+    scan_id: int,
     service: AnalyticQScanService = Depends(get_scan_service)
 ):
     """
     Retrieve a list of issues for a specific scan, optionally filtered by severity and confidence.
     """
-    return await service.filter_scan_issues(scan_id, severity, confidence)
+    return await service.get_scan_by_id(scan_id)
 
 
 @scan_router.get(
@@ -98,25 +88,7 @@ async def get_scans_by_tool_name(
     """
     Retrieve a list of scan results for a specific SAST tool.
     """
-    return await service.get_scans_by_tool_name(tool_name)
-
-
-@scan_router.get(
-    "/tool/{tool_name}/issues",
-    response_model=List[AnalyticQSASTIssueModel],
-    responses={
-        status.HTTP_200_OK: {"description": "List of issues for the specified tool"},
-        status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
-    },
-)
-async def get_scan_issues_by_tool_name(
-    tool_name: str,
-    service: AnalyticQScanService = Depends(get_scan_service)
-):
-    """
-    Retrieve all issues found by a specific security analysis tool.
-    """
-    return await service.get_issues_by_tool_name(tool_name)
+    return await service.get_scans_by_tool_name(tool_name.lower())
 
 
 @scan_router.delete(