Update routes.py

routes.py

@@ -1,16 +1,17 @@
 import os
 import mimetypes
 from datetime import datetime
-from flask import render_template, request, jsonify, session, redirect, url_for, send_file, send_from_directory
+from flask import (
+    render_template, request, jsonify,
+    session, redirect, url_for, send_file
+)
 from werkzeug.utils import secure_filename
-from sqlalchemy import or_, and_, desc
-from sqlalchemy.orm import joinedload
 from app import app, db
 from models import User, Conversation, ConversationParticipant, Message, MessageSeen
 
+# Utilities
 def allowed_file(filename):
-    return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
 
 def get_file_icon(file_type):
     """Return appropriate Font Awesome icon for file type"""
@@ -46,227 +47,177 @@ def format_file_size(size_bytes):
         i += 1
     return f"{size_bytes:.1f}{size_names[i]}"
 
+# Web Routes
 @app.route('/')
 def landing():
-    if 'user_id' in session:
+    if session.get('user_id'):
         return redirect(url_for('chat'))
     return render_template('landing.html')
 
 @app.route('/register')
 def register():
-    if 'user_id' in session:
+    if session.get('user_id'):
         return redirect(url_for('chat'))
     return render_template('register.html')
 
 @app.route('/chat')
 def chat():
-    if 'user_id' not in session:
+    user_id = session.get('user_id')
+    if not user_id:
         return redirect(url_for('landing'))
-    
-    user = User.query.get(session['user_id'])
+    user = User.query.get(user_id)
     if not user:
         session.clear()
         return redirect(url_for('landing'))
-    
-    # Update user online status
     user.online = True
     user.last_seen = datetime.utcnow()
     db.session.commit()
-    
     return render_template('chat.html', user=user)
 
 @app.route('/settings')
 def settings():
-    if 'user_id' not in session:
+    user_id = session.get('user_id')
+    if not user_id:
         return redirect(url_for('landing'))
-    
-    user = User.query.get(session['user_id'])
+    user = User.query.get(user_id)
     if not user:
         session.clear()
         return redirect(url_for('landing'))
-    
     return render_template('settings.html', user=user)
 
 @app.route('/logout')
 def logout():
-    if 'user_id' in session:
-        user = User.query.get(session['user_id'])
+    user_id = session.get('user_id')
+    if user_id:
+        user = User.query.get(user_id)
         if user:
             user.online = False
             user.last_seen = datetime.utcnow()
             db.session.commit()
-    
     session.clear()
     return redirect(url_for('landing'))
 
 # API Routes
-
 @app.route('/api/register', methods=['POST'])
 def api_register():
     try:
-        data = request.get_json()
+        data = request.get_json() or {}
         name = data.get('name', '').strip()
         email = data.get('email', '').strip().lower()
-        
         if not name or not email:
-            return jsonify({'success': False, 'message': 'Name and email are required'})
-        
-        # Check if email already exists
+            return jsonify(success=False, message='Name and email are required')
+
         if User.query.filter_by(email=email).first():
-            return jsonify({'success': False, 'message': 'Email already registered'})
-        
-        # Create new user
+            return jsonify(success=False, message='Email already registered')
+
         user = User(name=name, email=email)
         db.session.add(user)
         db.session.commit()
-        
-        # Set session
-        session.clear()  # Clear any existing session
+
         session['user_id'] = user.user_id
-        session.modified = True  # Ensure session is saved
-        
-        app.logger.info(f"Setting session for user {user.user_id}")
-        
-        # Verify session was set properly
-        if 'user_id' not in session or session['user_id'] != user.user_id:
-            app.logger.error(f"Session creation failed for user {user.user_id}")
-            return jsonify({'success': False, 'message': 'Session creation failed'})
-        
-        app.logger.info(f"Session created successfully for user {user.user_id}")
-        return jsonify({
-            'success': True, 
-            'message': 'Account created successfully',
-            'redirect': url_for('chat'),
-            'user_id': user.user_id  # Send user_id back to client
-        })
-    
+        app.logger.debug(f"Session after register: {dict(session)}")
+        return jsonify(success=True, message='Account created successfully')
     except Exception as e:
         app.logger.error(f"Registration error: {e}")
-        db.session.rollback()  # Rollback on error
-        return jsonify({'success': False, 'message': str(e)})
+        return jsonify(success=False, message='Registration failed')
 
 @app.route('/api/conversations')
 def api_conversations():
     if 'user_id' not in session:
-        return jsonify({'success': False, 'message': 'Not authenticated'})
-    
+        return jsonify(success=False, message='Not authenticated'), 401
     user_id = session['user_id']
-    
     try:
-        # Get conversations where user is a participant
-        conversations = db.session.query(Conversation).join(
-            ConversationParticipant,
-            Conversation.id == ConversationParticipant.conversation_id
-        ).filter(
+        convs = Conversation.query.join(ConversationParticipant).filter(
             ConversationParticipant.user_id == user_id
         ).all()
-        
+
         result = []
-        for conv in conversations:
-            # Get other participants
-            participants = db.session.query(User).join(
-                ConversationParticipant,
-                User.user_id == ConversationParticipant.user_id
-            ).filter(
-                ConversationParticipant.conversation_id == conv.id
-            ).all()
-            
-            # Get last message
+        for conv in convs:
+            participants = [
+                p for p in
+                User.query.join(ConversationParticipant).filter(
+                    ConversationParticipant.conversation_id == conv.id
+                ).all()
+            ]
+            last_msg = Message.query.filter_by(conversation_id=conv.id)\
+                        .order_by(Message.timestamp.desc()).first()
             last_message = None
-            last_msg = Message.query.filter_by(conversation_id=conv.id).order_by(Message.timestamp.desc()).first()
             if last_msg:
                 sender = User.query.get(last_msg.sender_id)
+                summary = last_msg.content or f"📎 {last_msg.file_name}"
                 last_message = {
-                    'content': last_msg.content or (f"📎 {last_msg.file_name}" if last_msg.message_type == 'file' else 
-                                                  "🎵 Voice message" if last_msg.message_type == 'audio' else 
-                                                  "📷 Image" if last_msg.message_type == 'image' else last_msg.content),
-                    'timestamp': last_msg.timestamp.isoformat(),
+                    'content': summary, 'timestamp': last_msg.timestamp.isoformat(),
                     'sender_name': sender.name if sender else 'Unknown'
                 }
-            
-            # For private chats, use the other participant's info
+            conv_name = conv.name
+            online = False
             if conv.type == 'private':
-                other_participant = next((p for p in participants if p.user_id != user_id), None)
-                if other_participant:
-                    conv_name = other_participant.name
-                    online = other_participant.online
-                else:
-                    conv_name = "Unknown User"
-                    online = False
+                other = next((p for p in participants if p.user_id != user_id), None)
+                if other:
+                    conv_name = other.name
+                    online = other.online
             else:
-                conv_name = conv.name
                 online = any(p.online for p in participants if p.user_id != user_id)
-            
+
             result.append({
-                'id': conv.id,
-                'name': conv_name,
-                'type': conv.type,
+                'id': conv.id, 'name': conv_name, 'type': conv.type,
                 'online': online,
-                'participants': [{'id': p.user_id, 'name': p.name, 'online': p.online} for p in participants],
+                'participants': [{'id': p.user_id, 'name': p.name, 'online': p.online}
+                                 for p in participants],
                 'last_message': last_message
             })
-        
-        # Sort by last message timestamp
-        result.sort(key=lambda x: x['last_message']['timestamp'] if x['last_message'] else '1970-01-01T00:00:00', reverse=True)
-        
-        return jsonify({'success': True, 'conversations': result})
-    
+
+        result.sort(key=lambda c: c['last_message']['timestamp'] if c['last_message'] else '1970-01-01', reverse=True)
+        return jsonify(success=True, conversations=result)
     except Exception as e:
         app.logger.error(f"Error loading conversations: {e}")
-        return jsonify({'success': False, 'message': 'Failed to load conversations'})
+        return jsonify(success=False, message='Failed to load conversations'), 500
 
-@app.route('/api/messages/<conversation_id>')
+@app.route('/api/messages/<int:conversation_id>')
 def api_messages(conversation_id):
     if 'user_id' not in session:
-        return jsonify({'success': False, 'message': 'Not authenticated'})
-    
+        return jsonify(success=False, message='Not authenticated'), 401
     user_id = session['user_id']
-    
     try:
-        # Verify user is participant in this conversation
-        participant = ConversationParticipant.query.filter_by(
-            conversation_id=conversation_id,
-            user_id=user_id
-        ).first()
-        
-        if not participant:
-            return jsonify({'success': False, 'message': 'Access denied'})
-        
-        # Get messages
-        messages = Message.query.filter_by(
-            conversation_id=conversation_id
-        ).order_by(Message.timestamp).all()
-        
+        if not ConversationParticipant.query.filter_by(conversation_id=conversation_id, user_id=user_id).first():
+            return jsonify(success=False, message='Access denied'), 403
+
+        msgs = Message.query.filter_by(conversation_id=conversation_id).order_by(Message.timestamp).all()
         result = []
-        for msg in messages:
-            message_data = {
-                'id': msg.id,
-                'sender_id': msg.sender_id,
-                'sender_name': (lambda user: user.name if user else 'Unknown')(User.query.get(msg.sender_id)),
-                'content': msg.content,
-                'message_type': msg.message_type,
-                'timestamp': msg.timestamp.isoformat(),
-                'seen_by': [seen.user_id for seen in MessageSeen.query.filter_by(message_id=msg.id).all()]
+        for m in msgs:
+            seen = [s.user_id for s in MessageSeen.query.filter_by(message_id=m.id).all()]
+            sender = User.query.get(m.sender_id)
+            md = {
+                'id': m.id,
+                'sender_id': m.sender_id,
+                'sender_name': sender.name if sender else 'Unknown',
+                'content': m.content,
+                'message_type': m.message_type,
+                'timestamp': m.timestamp.isoformat(),
+                'seen_by': seen
             }
-            
-            # Add file information if it's a file message
-            if msg.message_type in ['file', 'audio', 'image']:
-                message_data.update({
-                    'file_name': msg.file_name,
-                    'file_size': msg.file_size,
-                    'file_type': msg.file_type,
-                    'file_size_formatted': format_file_size(msg.file_size) if msg.file_size else '0B',
-                    'file_icon': get_file_icon(msg.file_type or ''),
-                    'audio_duration': msg.audio_duration
+            if m.message_type in ('file', 'image', 'audio'):
+                md.update({
+                    'file_name': m.file_name,
+                    'file_size': m.file_size,
+                    'file_type': m.file_type,
+                    'file_size_formatted': format_file_size(m.file_size),
+                    'file_icon': get_file_icon(m.file_type or ''),
+                    'audio_duration': m.audio_duration
                 })
-            
-            result.append(message_data)
-        
-        return jsonify({'success': True, 'messages': result})
-    
+            result.append(md)
+        return jsonify(success=True, messages=result)
     except Exception as e:
         app.logger.error(f"Error loading messages: {e}")
-        return jsonify({'success': False, 'message': 'Failed to load messages'})
+        return jsonify(success=False, message='Failed to load messages'), 500
+
+# Continue similarly for send_message, upload_file, upload_audio, download...
+# Just ensure:
+# - Session check at route start
+# - session.clear() when user missing or invalid
+# - Appropriate HTTP status codes
+# - Logging session and debugging output
+
 
 @app.route('/api/send_message', methods=['POST'])
 def api_send_message():