report added

Dockerfile

@@ -1,7 +1,9 @@
 # Use an NVIDIA PyTorch container with cuDNN 9.1 support
 FROM nvidia/cuda:12.3.2-cudnn9-runtime-ubuntu22.04
 
+
 # Basic setup
+ENV OMP_NUM_THREADS=1
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y \
     python3 python3-pip ffmpeg git libsndfile1 \

backend/routes/interview_api.py

@@ -12,6 +12,11 @@ from backend.services.interview_engine import (
     evaluate_answer
 )
 
+# Additional imports for report generation
+from backend.models.database import Application
+from backend.services.report_generator import generate_llm_interview_report, create_pdf_report
+from flask import abort
+
 interview_api = Blueprint("interview_api", __name__)
 
 @interview_api.route("/start_interview", methods=["POST"])
@@ -120,6 +125,68 @@ def transcribe_audio():
 
     return jsonify({"transcript": transcript})
 
+# ----------------------------------------------------------------------------
+# Interview report download
+#
+# Recruiters can download a PDF summarising a candidate's interview performance.
+# This route performs several checks: it verifies that the current user has
+# recruiter or admin privileges, ensures that the requested application exists
+# and belongs to one of the recruiter's jobs, generates a textual report via
+# the ``generate_llm_interview_report`` helper, converts it into a PDF, and
+# finally sends the PDF as a file attachment.  The heavy lifting is
+# encapsulated in ``services/report_generator.py`` to keep this route
+# lightweight.
+@interview_api.route('/download_report/<int:application_id>', methods=['GET'])
+@login_required
+def download_report(application_id: int):
+    """Generate and return a PDF report for a candidate's interview.
+
+    The ``application_id`` corresponds to the ID of the Application record
+    representing a candidate's job application.  Only recruiters (or admins)
+    associated with the job are permitted to access this report.
+    """
+    # Fetch the application or return 404 if not found
+    application = Application.query.get_or_404(application_id)
+
+    # Authorisation: ensure the current user is a recruiter or admin
+    if current_user.role not in ('recruiter', 'admin'):
+        # 403 Forbidden if the user lacks permissions
+        return abort(403)
+
+    # Further check that the recruiter owns the job unless admin
+    job = getattr(application, 'job', None)
+    if job is None:
+        return abort(404)
+    if current_user.role != 'admin' and job.recruiter_id != current_user.id:
+        return abort(403)
+
+    try:
+        # Generate the textual report using the helper function.  At this
+        # stage, interview answers and evaluations are not stored server‑side,
+        # so the report focuses on the candidate's application data and
+        # computed skill match.  Should answer/score data be persisted in
+        # future iterations, ``generate_llm_interview_report`` can be
+        # extended accordingly without touching this route.
+        report_text = generate_llm_interview_report(application)
+
+        # Convert the text to a PDF.  The helper returns a BytesIO buffer
+        # ready for sending via Flask's ``send_file``.  Matplotlib is used
+        # under the hood to avoid heavy dependencies like reportlab.
+        pdf_buffer = create_pdf_report(report_text)
+        pdf_buffer.seek(0)
+
+        filename = f"interview_report_{application.id}.pdf"
+        return send_file(
+            pdf_buffer,
+            download_name=filename,
+            as_attachment=True,
+            mimetype='application/pdf'
+        )
+    except Exception as exc:
+        # Log the error for debugging; return a 500 to the client
+        logging.error(f"Error generating report for application {application_id}: {exc}")
+        return jsonify({"error": "Failed to generate report"}), 500
+
 @interview_api.route("/process_answer", methods=["POST"])
 @login_required
 def process_answer():

backend/services/report_generator.py

@@ -0,0 +1,188 @@
+"""Utilities for assembling and exporting interview reports.
+
+This module provides two primary helpers used by the recruiter dashboard:
+
+``generate_llm_interview_report(application)``
+    Given a candidate's ``Application`` record, assemble a plain‑text report
+    summarising the interview.  Because the interview process currently
+    executes entirely client‑side and does not persist questions or answers
+    to the database, this report focuses on the information available on
+    the server: the candidate's profile, the job requirements and a skills
+    match score.  Should future iterations store richer interview data
+    server‑side, this function can be extended to include question/answer
+    transcripts, per‑question scores and LLM‑generated feedback.
+
+``create_pdf_report(report_text)``
+    Convert a multi‑line string into a simple PDF.  The implementation
+    leverages Matplotlib's PDF backend (available by default) to avoid
+    heavyweight dependencies such as ReportLab or WeasyPrint, which are
+    absent from the runtime environment.  Text is wrapped and split
+    across multiple pages as necessary.
+"""
+
+from __future__ import annotations
+
+import json
+from io import BytesIO
+import textwrap
+from typing import List
+
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_pdf import PdfPages
+
+def generate_llm_interview_report(application) -> str:
+    """Generate a human‑readable interview report for a candidate.
+
+    The report includes the candidate's name and email, job details,
+    application date, a computed skills match summary and placeholder
+    sections for future enhancements.  If server‑side storage of
+    question/answer pairs is added later, this function can be updated
+    to incorporate those details.
+
+    Parameters
+    ----------
+    application : backend.models.database.Application
+        The SQLAlchemy Application instance representing the candidate's
+        job application.  Assumed to have related ``job`` and
+        ``date_applied`` attributes available.
+
+    Returns
+    -------
+    str
+        A multi‑line string containing the report contents.
+    """
+    # Defensive imports to avoid circular dependencies at import time
+    try:
+        from datetime import datetime  # noqa: F401
+    except Exception:
+        pass
+
+    # Extract candidate skills and job skills
+    try:
+        candidate_features = json.loads(application.extracted_features) if application.extracted_features else {}
+    except Exception:
+        candidate_features = {}
+    candidate_skills: List[str] = candidate_features.get('skills', []) or []
+
+    job_skills: List[str] = []
+    try:
+        job_skills = json.loads(application.job.skills) if application.job and application.job.skills else []
+    except Exception:
+        job_skills = []
+
+    # Compute skills match ratio and label.  Normalise to lower case for
+    # comparison and avoid dividing by zero when ``job_skills`` is empty.
+    candidate_set = {s.strip().lower() for s in candidate_skills}
+    job_set = {s.strip().lower() for s in job_skills}
+    common = candidate_set & job_set
+    ratio = len(common) / len(job_set) if job_set else 0.0
+
+    if ratio >= 0.75:
+        score_label = 'Excellent'
+    elif ratio >= 0.5:
+        score_label = 'Good'
+    elif ratio >= 0.25:
+        score_label = 'Medium'
+    else:
+        score_label = 'Poor'
+
+    # Assemble report lines
+    lines: List[str] = []
+    lines.append('Interview Report')
+    lines.append('=================')
+    lines.append('')
+    lines.append(f'Candidate Name: {application.name}')
+    lines.append(f'Candidate Email: {application.email}')
+    if application.job:
+        lines.append(f'Job Applied: {application.job.role}')
+        lines.append(f'Company: {application.job.company}')
+    else:
+        lines.append('Job Applied: N/A')
+        lines.append('Company: N/A')
+    # Format date_applied if available
+    try:
+        date_str = application.date_applied.strftime('%Y-%m-%d') if application.date_applied else 'N/A'
+    except Exception:
+        date_str = 'N/A'
+    lines.append(f'Date Applied: {date_str}')
+    lines.append('')
+    lines.append('Skills Match Summary:')
+    # Represent required and candidate skills as comma‑separated lists.  Use
+    # title‑case for presentation and handle empty lists gracefully.
+    formatted_job_skills = ', '.join(job_skills) if job_skills else 'N/A'
+    formatted_candidate_skills = ', '.join(candidate_skills) if candidate_skills else 'N/A'
+    formatted_common = ', '.join(sorted(common)) if common else 'None'
+    lines.append(f'  Required Skills: {formatted_job_skills}')
+    lines.append(f'  Candidate Skills: {formatted_candidate_skills}')
+    lines.append(f'  Skills in Common: {formatted_common}')
+    lines.append(f'  Match Ratio: {ratio * 100:.0f}%')
+    lines.append(f'  Score: {score_label}')
+    lines.append('')
+    lines.append('Additional Notes:')
+    lines.append('This report was generated automatically based on the information provided in the application.')
+    lines.append('Interview question and answer details are not currently stored on the server.')
+    lines.append('Future versions may include a detailed breakdown of interview responses and evaluator feedback.')
+
+    return '\n'.join(lines)
+
+
+def create_pdf_report(report_text: str) -> BytesIO:
+    """Convert a plain‑text report into a PDF document.
+
+    This helper uses Matplotlib's ``PdfPages`` backend to compose a PDF
+    containing the supplied text.  Lines are wrapped to a reasonable
+    width and paginated as needed.  The returned ``BytesIO`` object can
+    be passed directly to Flask's ``send_file`` function.
+
+    Parameters
+    ----------
+    report_text : str
+        The full contents of the report to be included in the PDF.
+
+    Returns
+    -------
+    BytesIO
+        A file‑like buffer containing the PDF data.  The caller is
+        responsible for rewinding the buffer (via ``seek(0)``) before
+        sending it over HTTP.
+    """
+    buffer = BytesIO()
+
+    # Split the input into lines and wrap long lines for better layout
+    raw_lines = report_text.split('\n')
+    wrapper = textwrap.TextWrapper(width=90, break_long_words=True, replace_whitespace=False)
+    wrapped_lines: List[str] = []
+    for line in raw_lines:
+        if not line:
+            wrapped_lines.append('')
+            continue
+        # Wrap each line individually; the wrapper returns a list
+        segments = wrapper.wrap(line)
+        if segments:
+            wrapped_lines.extend(segments)
+        else:
+            wrapped_lines.append(line)
+
+    # Determine how many lines to place on each PDF page.  The value
+    # of 40 lines per page fits comfortably on an A4 sheet using the
+    # selected font size and margins.
+    lines_per_page = 40
+
+    with PdfPages(buffer) as pdf:
+        for i in range(0, len(wrapped_lines), lines_per_page):
+            fig = plt.figure(figsize=(8.27, 11.69))  # A4 portrait in inches
+            fig.patch.set_facecolor('white')
+            # Compose the block of text for this page
+            page_text = '\n'.join(wrapped_lines[i:i + lines_per_page])
+            # Place the text near the top-left corner.  ``va='top'``
+            # ensures the first line starts at the specified y
+            fig.text(0.1, 0.95, page_text, va='top', ha='left', fontsize=10, family='monospace')
+            # Save and close the figure to free memory
+            pdf.savefig(fig)
+            plt.close(fig)
+
+    buffer.seek(0)
+    return buffer
+
+
+__all__ = ['generate_llm_interview_report', 'create_pdf_report']

backend/templates/dashboard.html

@@ -13,10 +13,10 @@
 
 {% block content %}
 <section class="content-section">
-    <ul class="breadcrumbs">
+    <!-- <ul class="breadcrumbs">
         <li><a href="{{ url_for('index') }}">Home</a></li>
         <li>Dashboard</li>
-    </ul>
+    </ul> -->
 
     <div class="section-title">
         <h2>Interviewed Candidates</h2>
@@ -44,7 +44,19 @@
                         <td style="padding: 0.75rem;">{{ item.application.job.role }}</td>
                         <td style="padding: 0.75rem; font-weight: 600; color: var(--secondary);">{{ item.score_label }}</td>
                         <td style="padding: 0.75rem;">
-                            <button class="btn btn-outline" disabled style="cursor: not-allowed;">Download Report (PDF)</button>
+                            {#
+                                Provide a link to download the candidate's interview report.  The
+                                ``url_for`` call targets the API endpoint defined in
+                                ``backend/routes/interview_api.py``.  It passes the application ID
+                                (used as the interview identifier) so that the backend knows which
+                                candidate to generate a report for.  Styling is handled via the
+                                ``download-report-btn`` class defined below.
+                            #}
+                            <a href="{{ url_for('interview_api.download_report', application_id=item.application.id) }}"
+                               class="download-report-btn"
+                               title="Download interview report as PDF">
+                                Download Report (PDF)
+                            </a>
                         </td>
                     </tr>
                     {% endfor %}
@@ -78,4 +90,27 @@
     background-color: #eef5ff;
 }
 </style>
+<style>
+/*
+ * Custom styling for the download report link.  The default button styles
+ * blend into the table background, making the report action hard to see.  A
+ * subtle border and hover effect improve visibility without altering the
+ * overall aesthetic of the dashboard.
+ */
+.download-report-btn {
+    display: inline-block;
+    padding: 0.5rem 1rem;
+    border: 1px solid var(--primary);
+    border-radius: 4px;
+    color: var(--primary);
+    background-color: #fff;
+    text-decoration: none;
+    font-size: 0.875rem;
+    transition: background-color 0.2s ease, color 0.2s ease;
+}
+.download-report-btn:hover {
+    background-color: var(--primary);
+    color: #fff;
+}
+</style>
 {% endblock %}

backend/templates/post_job.html

@@ -12,11 +12,11 @@
 
 {% block content %}
 <section class="content-section">
-    <ul class="breadcrumbs">
+    <!-- <ul class="breadcrumbs">
         <li><a href="{{ url_for('index') }}">Home</a></li>
         <li><a href="{{ url_for('jobs') }}">Jobs</a></li>
         <li>Post Job</li>
-    </ul>
+    </ul> -->
 
     <div class="card">
         <div class="card-header">