updated

backend/models/database.py

@@ -61,6 +61,7 @@ class Application(db.Model):
     extracted_features = db.Column(db.Text, nullable=True)
     status = db.Column(db.String(50), default='applied')
     date_applied = db.Column(db.DateTime, default=datetime.utcnow)
+    interview_log = Column(Text)
 
     user = db.relationship('User', backref='applications')
 

backend/routes/interview_api.py

@@ -177,7 +177,7 @@ def download_report(application_id: int):
         pdf_buffer = create_pdf_report(report_text)
         pdf_buffer.seek(0)
 
-        filename = f"interview_report_{application.id}.pdf"
+        filename = f"{application.name.replace(' ', '_')}_interview_report.pdf"
         return send_file(
             pdf_buffer,
             download_name=filename,
@@ -215,6 +215,32 @@ def process_answer():
         # Evaluate the answer
         evaluation_result = evaluate_answer(current_question, answer)
 
+                # 🔥 Save Q&A in interview_log for report
+        try:
+            application = Application.query.filter_by(
+                user_id=current_user.id,
+                job_id=job_id
+            ).first()
+
+            if application:
+                log_data = []
+                if application.interview_log:
+                    try:
+                        log_data = json.loads(application.interview_log)
+                    except Exception:
+                        log_data = []
+
+                log_data.append({
+                    "question": current_question,
+                    "answer": answer,
+                    "evaluation": evaluation_result
+                })
+
+                application.interview_log = json.dumps(log_data, ensure_ascii=False)
+                db.session.commit()
+        except Exception as log_err:
+            logging.error(f"Error saving interview log: {log_err}")
+
         # Determine the number of questions configured for this job
         total_questions = 3
         if job_id is not None:

backend/services/report_generator.py

@@ -118,66 +118,72 @@ def generate_llm_interview_report(application) -> str:
     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.')
+    lines.append('Interview Transcript & Evaluation:')
+    try:
+        if application.interview_log:
+            try:
+                qa_log = json.loads(application.interview_log)
+             except Exception:
+                qa_log = []
+
+            if qa_log:
+                for idx, entry in enumerate(qa_log, 1):
+                    q = entry.get("question", "N/A")
+                    a = entry.get("answer", "N/A")
+                    eval_score = entry.get("evaluation", {}).get("score", "N/A")
+                    eval_feedback = entry.get("evaluation", {}).get("feedback", "N/A")
+
+                    lines.append(f"\nQuestion {idx}: {q}")
+                    lines.append(f"Answer: {a}")
+                    lines.append(f"Score: {eval_score}")
+                    lines.append(f"Feedback: {eval_feedback}")
+            else:
+                lines.append("No interview log data recorded.")
+        else:
+            lines.append("No interview log data recorded.")
+    except Exception as e:
+        lines.append(f"Error loading interview log: {e}")
 
     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.
-    """
+    """Convert a formatted report into a visually clear PDF with bold Qs and indented As."""
     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] = []
+    # Prepare wrapped lines
+    raw_lines = report_text.split("\n")
+    wrapper = textwrap.TextWrapper(width=85, break_long_words=True, replace_whitespace=False)
+    formatted_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)
+        # Highlight Questions
+        if line.strip().startswith("Question"):
+            formatted_lines.append("")  # Extra spacing before new question
+            formatted_lines.append(f"**{line.strip()}**")  # Bold style marker
+        elif line.strip().startswith("Answer:"):
+            # Indent answers for clarity
+            answer_text = line.replace("Answer:", "").strip()
+            wrapped_answer = wrapper.wrap(answer_text)
+            formatted_lines.append(f"  Answer: {wrapped_answer[0]}")
+            for extra in wrapped_answer[1:]:
+                formatted_lines.append(f"         {extra}")
+        elif line.strip().startswith("Score:") or line.strip().startswith("Feedback:"):
+            # Keep score & feedback on separate lines
+            formatted_lines.append(f"  {line.strip()}")
         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
+            # Wrap other lines normally
+            wrapped = wrapper.wrap(line)
+            formatted_lines.extend(wrapped if wrapped else [""])
 
+    # PDF creation
+    lines_per_page = 38
     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
+        for i in range(0, len(formatted_lines), lines_per_page):
+            fig = plt.figure(figsize=(8.27, 11.69))  # A4
             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
+            page_text = "\n".join(formatted_lines[i:i + lines_per_page])
+            fig.text(0.1, 0.95, page_text, va="top", ha="left", fontsize=10, family="monospace")
             pdf.savefig(fig)
             plt.close(fig)