Update main.py

main.py

@@ -115,81 +115,198 @@ def google_signin():
         return jsonify({'success': True, 'user': {'uid': uid, **user_data}}), 200
     except Exception as e: return jsonify({'error': str(e)}), 400
 
+import logging
+
+# Configure console logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
 # -----------------------------------------------------------------------------
-# 4. SOZO BUSINESS STUDIO API ENDPOINTS
+# 4. SOZO BUSINESS STUDIO API ENDPOINTS WITH LOGGING
 # -----------------------------------------------------------------------------
 
 @app.route('/api/sozo/projects', methods=['POST'])
 def create_sozo_project():
+    logger.info("POST /api/sozo/projects - Creating new project")
+    
     try:
         token = request.headers.get('Authorization', '').split(' ')[1]
         uid = verify_token(token)
-        if not uid: return jsonify({'error': 'Unauthorized'}), 401
-        if 'file' not in request.files: return jsonify({'error': 'No file part'}), 400
+        if not uid:
+            logger.warning("Unauthorized access attempt to create project")
+            return jsonify({'error': 'Unauthorized'}), 401
+        
+        logger.info(f"User {uid} creating project")
+        
+        if 'file' not in request.files:
+            logger.warning(f"User {uid} - No file provided")
+            return jsonify({'error': 'No file part'}), 400
+        
         file = request.files['file']
-        if file.filename == '': return jsonify({'error': 'No selected file'}), 400
+        if file.filename == '':
+            logger.warning(f"User {uid} - Empty filename")
+            return jsonify({'error': 'No selected file'}), 400
+        
+        logger.info(f"User {uid} - Processing file: {file.filename}")
+        
         context = request.form.get('context', '')
         project_id = uuid.uuid4().hex
+        
+        logger.info(f"Generated project ID: {project_id}")
+        
         file_bytes = file.read()
         file.seek(0)
         ext = Path(file.filename).suffix
+        
+        logger.info(f"File size: {len(file_bytes)} bytes, extension: {ext}")
+        
         blob_name = f"sozo_projects/{uid}/{project_id}/data{ext}"
         blob = bucket.blob(blob_name)
         blob.upload_from_string(file_bytes, content_type=file.content_type)
+        
+        logger.info(f"File uploaded to storage: {blob_name}")
+        
         project_ref = db.reference(f'sozo_projects/{project_id}')
-        project_data = {'uid': uid, 'status': 'uploaded', 'createdAt': datetime.utcnow().isoformat(), 'userContext': context, 'originalDataUrl': blob.public_url, 'originalFilename': file.filename}
+        project_data = {
+            'uid': uid,
+            'status': 'uploaded',
+            'createdAt': datetime.utcnow().isoformat(),
+            'userContext': context,
+            'originalDataUrl': blob.public_url,
+            'originalFilename': file.filename
+        }
         project_ref.set(project_data)
+        
+        logger.info(f"Project data saved to database: {project_id}")
+        
         df = load_dataframe_safely(io.BytesIO(file_bytes), file.filename)
         preview_json = df.head().to_json(orient='records')
-        return jsonify({'success': True, 'project_id': project_id, 'preview': json.loads(preview_json)}), 201
+        
+        logger.info(f"Project {project_id} created successfully for user {uid}")
+        
+        return jsonify({
+            'success': True,
+            'project_id': project_id,
+            'preview': json.loads(preview_json)
+        }), 201
+        
     except Exception as e:
-        traceback.print_exc()
+        logger.error(f"Error creating project: {str(e)}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/sozo/projects/<string:project_id>/generate-report', methods=['POST'])
 def generate_sozo_report(project_id):
+    logger.info(f"POST /api/sozo/projects/{project_id}/generate-report - Generating report")
+    
     try:
         token = request.headers.get('Authorization', '').split(' ')[1]
         uid = verify_token(token)
-        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+        if not uid:
+            logger.warning(f"Unauthorized access attempt to generate report for project {project_id}")
+            return jsonify({'error': 'Unauthorized'}), 401
+        
+        logger.info(f"User {uid} generating report for project {project_id}")
+        
         project_ref = db.reference(f'sozo_projects/{project_id}')
         project_data = project_ref.get()
-        if not project_data or project_data.get('uid') != uid: return jsonify({'error': 'Project not found or unauthorized'}), 404
+        
+        if not project_data or project_data.get('uid') != uid:
+            logger.warning(f"Project {project_id} not found or unauthorized for user {uid}")
+            return jsonify({'error': 'Project not found or unauthorized'}), 404
+        
+        logger.info(f"Project {project_id} validated for user {uid}")
         
         blob_path = "/".join(project_data['originalDataUrl'].split('/')[4:])
         blob = bucket.blob(blob_path)
         file_bytes = blob.download_as_bytes()
         
-        draft_data = generate_report_draft(io.BytesIO(file_bytes), project_data['originalFilename'], project_data['userContext'], uid, project_id, bucket)
-        update_data = {'status': 'draft', 'rawMarkdown': draft_data['raw_md'], 'chartUrls': draft_data['chartUrls']}
+        logger.info(f"Downloaded file data for project {project_id}, size: {len(file_bytes)} bytes")
+        
+        draft_data = generate_report_draft(
+            io.BytesIO(file_bytes),
+            project_data['originalFilename'],
+            project_data['userContext'],
+            uid,
+            project_id,
+            bucket
+        )
+        
+        logger.info(f"Report draft generated for project {project_id}")
+        
+        update_data = {
+            'status': 'draft',
+            'rawMarkdown': draft_data['raw_md'],
+            'chartUrls': draft_data['chartUrls']
+        }
         project_ref.update(update_data)
-        return jsonify({'success': True, 'project': {**project_data, **update_data}}), 200
+        
+        logger.info(f"Project {project_id} updated with draft data")
+        
+        return jsonify({
+            'success': True,
+            'project': {**project_data, **update_data}
+        }), 200
+        
     except Exception as e:
-        db.reference(f'sozo_projects/{project_id}').update({'status': 'failed', 'error': str(e)})
-        traceback.print_exc()
+        logger.error(f"Error generating report for project {project_id}: {str(e)}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        db.reference(f'sozo_projects/{project_id}').update({
+            'status': 'failed',
+            'error': str(e)
+        })
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/sozo/projects', methods=['GET'])
 def get_sozo_projects():
+    logger.info("GET /api/sozo/projects - Fetching user projects")
+    
     try:
         token = request.headers.get('Authorization', '').split(' ')[1]
         uid = verify_token(token)
-        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+        if not uid:
+            logger.warning("Unauthorized access attempt to fetch projects")
+            return jsonify({'error': 'Unauthorized'}), 401
+        
+        logger.info(f"User {uid} fetching projects")
+        
         all_projects = db.reference('sozo_projects').order_by_child('uid').equal_to(uid).get()
+        
+        project_count = len(all_projects) if all_projects else 0
+        logger.info(f"Found {project_count} projects for user {uid}")
+        
         return jsonify(all_projects or {}), 200
+        
     except Exception as e:
+        logger.error(f"Error fetching projects: {str(e)}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/sozo/projects/<string:project_id>', methods=['GET'])
 def get_sozo_project(project_id):
+    logger.info(f"GET /api/sozo/projects/{project_id} - Fetching project")
+    
     try:
         token = request.headers.get('Authorization', '').split(' ')[1]
         uid = verify_token(token)
-        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+        if not uid:
+            logger.warning(f"Unauthorized access attempt to fetch project {project_id}")
+            return jsonify({'error': 'Unauthorized'}), 401
+        
+        logger.info(f"User {uid} fetching project {project_id}")
+        
         project_data = db.reference(f'sozo_projects/{project_id}').get()
-        if not project_data or project_data.get('uid') != uid: return jsonify({'error': 'Project not found or unauthorized'}), 404
+        
+        if not project_data or project_data.get('uid') != uid:
+            logger.warning(f"Project {project_id} not found or unauthorized for user {uid}")
+            return jsonify({'error': 'Project not found or unauthorized'}), 404
+        
+        logger.info(f"Project {project_id} fetched successfully for user {uid}")
+        
         return jsonify(project_data), 200
-    except Exception as e: return jsonify({'error': str(e)}), 500
+        
+    except Exception as e:
+        logger.error(f"Error fetching project {project_id}: {str(e)}")
+        return jsonify({'error': str(e)}), 500
 
 @app.route('/api/sozo/projects/<string:project_id>/markdown', methods=['PUT'])
 def update_sozo_markdown(project_id):