Update main.py

main.py

@@ -615,170 +615,158 @@ def view_videos():
 
 
 #download archives endpoint
+
+# Configure logging to a file
+
 @app.route('/api/download/story_archive/<story_id>', methods=['GET'])
 def download_story_archive(story_id):
     try:
+        logging.info(f"🔹 [START] Processing story {story_id}")
+
         # --- Authentication ---
         auth_header = request.headers.get('Authorization', '')
         if not auth_header.startswith('Bearer '):
+            logging.warning("❌ Missing or invalid token")
             return jsonify({'error': 'Missing or invalid token'}), 401
+        
         token = auth_header.split(' ')[1]
         uid = verify_token(token)
         if not uid:
+            logging.warning("❌ Invalid or expired token")
             return jsonify({'error': 'Invalid or expired token'}), 401
 
         # --- Fetch the Story ---
         stories_ref = db.reference('stories')
         story_record = stories_ref.child(story_id).get()
         if not story_record:
+            logging.error(f"❌ Story {story_id} not found")
             return jsonify({'error': 'Story not found'}), 404
         if story_record.get('uid') != uid:
+            logging.warning(f"❌ Unauthorized access attempt for story {story_id}")
             return jsonify({'error': 'Unauthorized'}), 403
 
-        # Prepare data
+        # Extract story details
         full_text = story_record.get("full_story", "")
         sections = story_record.get("sections", [])
-        
-        # Derive a title from the first sentence
         split_sentences = full_text.split('.', 1)
         title = split_sentences[0].strip() if split_sentences and split_sentences[0].strip() else "Untitled"
+        logging.info(f"📌 Story title: {title}")
 
-        # ------------------------------------------------------------------
-        # Create an in-memory ZIP
-        # ------------------------------------------------------------------
+        # Create ZIP buffer
         zip_buffer = io.BytesIO()
         with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zipf:
 
             # ======================
             # 1) Generate PDF
             # ======================
+            logging.info(f"📄 Generating PDF for {story_id}")
             pdf = FPDF()
             pdf.set_auto_page_break(auto=True, margin=15)
             pdf.add_page()
             pdf.set_font("Arial", size=12)
 
-            # Basic info
-            pdf.cell(0, 10, f"Story ID: {story_id}")
-            pdf.ln()
-            pdf.cell(0, 10, f"Title: {title}")
-            pdf.ln(15)
-            
-            # Add the full story text with proper line breaks
+            # Add story details
+            pdf.multi_cell(0, 10, f"Story ID: {story_id}")
+            pdf.multi_cell(0, 10, f"Title: {title}")
+            pdf.ln(10)
             pdf.multi_cell(0, 10, "Full Story:")
-            pdf.ln(5)
             pdf.multi_cell(0, 10, full_text)
-            pdf.ln(10)
 
-            # For each section, create a new page
+            # Add sections with images
+            bucket = storage.bucket()
             for idx, section_obj in enumerate(sections):
-                # Each section is a dict with "section_text" and "image_url"
                 section_text = section_obj.get("section_text", "")
                 image_url = section_obj.get("image_url", "")
 
                 pdf.add_page()
                 pdf.set_font("Arial", style='B', size=14)
-                pdf.cell(0, 10, f"Section {idx + 1}")
-                pdf.ln(15)
+                pdf.multi_cell(0, 10, f"Section {idx + 1}")
                 pdf.set_font("Arial", size=12)
                 pdf.multi_cell(0, 10, section_text)
-                pdf.ln(10)
 
-                # If there's an image URL, download & embed in PDF
+                # Download & embed images
                 if image_url:
                     try:
-                        # Initialize Firebase Storage bucket
-                        bucket = storage.bucket()
-                        
-                        # Get the image file path from the URL
-                        # Firebase Storage URLs are in the format:
-                        # https://firebasestorage.googleapis.com/v0/b/[bucket]/o/[file_path]?[params]
-                        file_path = ""
-                        if '/o/' in image_url and '?' in image_url:
-                            file_path = image_url.split('/o/')[1].split('?')[0]
-                            file_path = urllib.parse.unquote(file_path)
-                        
-                        # Create a temporary file to hold the image
+                        logging.info(f"📷 Downloading image for section {idx + 1}")
+                        file_path = image_url.split('/o/')[1].split('?')[0]
+                        file_path = urllib.parse.unquote(file_path)
+
                         with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
                             temp_img_path = temp_file.name
-                        
-                        # Download the image to temp file
+
                         blob = bucket.blob(file_path)
                         blob.download_to_filename(temp_img_path)
                         
-                        # Calculate appropriate image width and place it on the page
-                        page_width = pdf.w - 2*pdf.l_margin
-                        image_width = min(page_width - 20, 160)  # Keep some margin
-                        pdf.image(temp_img_path, x=(pdf.w - image_width)/2, w=image_width)
-                        
-                        # Clean up temp file
+                        pdf.image(temp_img_path, x=10, w=100)
                         os.unlink(temp_img_path)
+                        logging.info(f"✅ Image embedded in PDF for section {idx + 1}")
                     except Exception as img_error:
-                        print(f"PDF image error: {str(img_error)}")
-                        pdf.ln(5)
-                        pdf.multi_cell(0, 10, f"[Image could not be included]")
+                        logging.error(f"❌ Error embedding image for section {idx + 1}: {str(img_error)}")
 
             # Save PDF to memory
             pdf_buffer = io.BytesIO()
             pdf.output(pdf_buffer)
             pdf_buffer.seek(0)
-            # Add PDF to the ZIP
             zipf.writestr(f"{story_id}.pdf", pdf_buffer.read())
+            logging.info(f"✅ PDF added to ZIP for {story_id}")
 
             # ======================
             # 2) Generate a TXT file
             # ======================
+            logging.info(f"📄 Generating TXT for {story_id}")
             txt_content = f"Story ID: {story_id}\nTitle: {title}\n\nFull Story:\n\n{full_text}\n\n"
             for idx, section_obj in enumerate(sections):
                 section_text = section_obj.get("section_text", "")
                 txt_content += f"\n\nSection {idx + 1}:\n{section_text}"
             zipf.writestr(f"{story_id}.txt", txt_content)
+            logging.info(f"✅ TXT added to ZIP for {story_id}")
 
             # ======================
-            # 3) Download each section's image file to the ZIP
+            # 3) Download section images
             # ======================
-            bucket = storage.bucket()
             for idx, section_obj in enumerate(sections):
                 image_url = section_obj.get("image_url", "")
                 if image_url:
                     try:
-                        # Extract file path from Firebase Storage URL
-                        file_path = ""
-                        if '/o/' in image_url and '?' in image_url:
-                            file_path = image_url.split('/o/')[1].split('?')[0]
-                            file_path = urllib.parse.unquote(file_path)
-                        
-                        # Get the blob and download as bytes
+                        logging.info(f"📷 Downloading image for ZIP (section {idx + 1})")
+                        file_path = image_url.split('/o/')[1].split('?')[0]
+                        file_path = urllib.parse.unquote(file_path)
+
                         blob = bucket.blob(file_path)
                         image_data = blob.download_as_bytes()
                         zipf.writestr(f"image_section_{idx + 1}.jpg", image_data)
-                        print(f"Added image for section {idx + 1}")
+                        logging.info(f"✅ Image added to ZIP for section {idx + 1}")
                     except Exception as img_error:
-                        print(f"Error downloading image for section {idx + 1}: {str(img_error)}")
+                        logging.error(f"❌ Error downloading image for section {idx + 1}: {str(img_error)}")
 
             # ======================
-            # 4) Download each section's audio file to the ZIP
+            # 4) Download section audios
             # ======================
             for idx, section_obj in enumerate(sections):
                 audio_url = section_obj.get("audio_url", "")
                 if audio_url:
                     try:
-                        # Extract file path from Firebase Storage URL
-                        file_path = ""
-                        if '/o/' in audio_url and '?' in audio_url:
-                            file_path = audio_url.split('/o/')[1].split('?')[0]
-                            file_path = urllib.parse.unquote(file_path)
-                        
-                        # Get the blob and download as bytes
+                        logging.info(f"🔊 Downloading audio for ZIP (section {idx + 1})")
+                        file_path = audio_url.split('/o/')[1].split('?')[0]
+                        file_path = urllib.parse.unquote(file_path)
+
                         blob = bucket.blob(file_path)
                         audio_data = blob.download_as_bytes()
                         zipf.writestr(f"audio_section_{idx + 1}.mp3", audio_data)
-                        print(f"Added audio for section {idx + 1}")
+                        logging.info(f"✅ Audio added to ZIP for section {idx + 1}")
                     except Exception as audio_error:
-                        print(f"Error downloading audio for section {idx + 1}: {str(audio_error)}")
+                        logging.error(f"❌ Error downloading audio for section {idx + 1}: {str(audio_error)}")
+
+        # ------------------------
+        # Upload log to Firebase
+        # ------------------------
+        log_url = upload_log()
+        if log_url:
+            logging.info(f"📤 Log uploaded: {log_url}")
+        else:
+            logging.error("❌ Failed to upload log")
 
-        # ------------------------------------------------------------------
         # Serve ZIP File
-        # ------------------------------------------------------------------
         zip_buffer.seek(0)
         return send_file(
             zip_buffer, 
@@ -788,7 +776,7 @@ def download_story_archive(story_id):
         )
 
     except Exception as e:
-        import traceback
+        logging.error(f"❌ ERROR: {str(e)}")
         traceback.print_exc()
         return jsonify({'error': str(e)}), 500