initial commit - LeDiscord plateforme des copains

2025-08-21 00:28:21 +02:00
commit b7a84a53aa
93 changed files with 16247 additions and 0 deletions
--- a/backend/api/routers/posts.py
+++ b/backend/api/routers/posts.py
@@ -0,0 +1,347 @@
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime
+import os
+import uuid
+from pathlib import Path
+from PIL import Image
+from config.database import get_db
+from config.settings import settings
+from models.post import Post, PostMention, PostLike, PostComment
+from models.user import User
+from models.notification import Notification, NotificationType
+from utils.notification_service import NotificationService
+from schemas.post import PostCreate, PostUpdate, PostResponse, PostCommentCreate
+from utils.security import get_current_active_user
+from utils.settings_service import SettingsService
+
+router = APIRouter()
+
+@router.post("/", response_model=PostResponse)
+async def create_post(
+    post_data: PostCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Create a new post."""
+    post = Post(
+        author_id=current_user.id,
+        content=post_data.content,
+        image_url=post_data.image_url
+    )
+    db.add(post)
+    db.flush()  # Get the post ID before creating mentions
+    
+    # Create mentions
+    for user_id in post_data.mentioned_user_ids:
+        mentioned_user = db.query(User).filter(User.id == user_id).first()
+        if mentioned_user:
+            mention = PostMention(
+                post_id=post.id,
+                mentioned_user_id=user_id
+            )
+            db.add(mention)
+            
+            # Create notification for mentioned user
+            NotificationService.create_mention_notification(
+                db=db,
+                mentioned_user_id=user_id,
+                author=current_user,
+                content_type="post",
+                content_id=post.id
+            )
+    
+    db.commit()
+    db.refresh(post)
+    return format_post_response(post, db)
+
+@router.get("/", response_model=List[PostResponse])
+async def get_posts(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user),
+    limit: int = 50,
+    offset: int = 0
+):
+    """Get all posts."""
+    posts = db.query(Post).order_by(Post.created_at.desc()).limit(limit).offset(offset).all()
+    return [format_post_response(post, db) for post in posts]
+
+@router.get("/{post_id}", response_model=PostResponse)
+async def get_post(
+    post_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Get a specific post."""
+    post = db.query(Post).filter(Post.id == post_id).first()
+    if not post:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Post not found"
+        )
+    return format_post_response(post, db)
+
+@router.put("/{post_id}", response_model=PostResponse)
+async def update_post(
+    post_id: int,
+    post_update: PostUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Update a post."""
+    post = db.query(Post).filter(Post.id == post_id).first()
+    if not post:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Post not found"
+        )
+    
+    if post.author_id != current_user.id and not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to update this post"
+        )
+    
+    for field, value in post_update.dict(exclude_unset=True).items():
+        setattr(post, field, value)
+    
+    post.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(post)
+    return format_post_response(post, db)
+
+@router.delete("/{post_id}")
+async def delete_post(
+    post_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Delete a post."""
+    post = db.query(Post).filter(Post.id == post_id).first()
+    if not post:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Post not found"
+        )
+    
+    if post.author_id != current_user.id and not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to delete this post"
+        )
+    
+    db.delete(post)
+    db.commit()
+    return {"message": "Post deleted successfully"}
+
+@router.post("/upload-image")
+async def upload_post_image(
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Upload an image for a post."""
+    # Validate file type
+    if not SettingsService.is_file_type_allowed(db, file.content_type or "unknown"):
+        allowed_types = SettingsService.get_setting(db, "allowed_image_types", 
+            ["image/jpeg", "image/png", "image/gif", "image/webp"])
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Invalid file type. Allowed types: {', '.join(allowed_types)}"
+        )
+    
+    # Check file size
+    contents = await file.read()
+    file_size = len(contents)
+    max_size = SettingsService.get_max_upload_size(db, file.content_type or "image/jpeg")
+    if file_size > max_size:
+        max_size_mb = max_size // (1024 * 1024)
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f"File too large. Maximum size: {max_size_mb}MB"
+        )
+    
+    # Create posts directory
+    posts_dir = Path(settings.UPLOAD_PATH) / "posts" / str(current_user.id)
+    posts_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Generate unique filename
+    file_extension = file.filename.split(".")[-1]
+    filename = f"{uuid.uuid4()}.{file_extension}"
+    file_path = posts_dir / filename
+    
+    # Save file
+    with open(file_path, "wb") as f:
+        f.write(contents)
+    
+    # Resize image if it's REALLY too large (4K support)
+    try:
+        img = Image.open(file_path)
+        if img.size[0] > 3840 or img.size[1] > 2160:  # 4K threshold
+            img.thumbnail((3840, 2160), Image.Resampling.LANCZOS)
+            img.save(file_path, quality=95, optimize=True)  # High quality
+    except Exception as e:
+        print(f"Error processing image: {e}")
+    
+    # Return the image URL
+    image_url = f"/posts/{current_user.id}/{filename}"
+    
+    return {"image_url": image_url}
+
+@router.post("/{post_id}/like")
+async def toggle_post_like(
+    post_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Toggle like on a post."""
+    post = db.query(Post).filter(Post.id == post_id).first()
+    if not post:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Post not found"
+        )
+    
+    # Check if user already liked the post
+    existing_like = db.query(PostLike).filter(
+        PostLike.post_id == post_id,
+        PostLike.user_id == current_user.id
+    ).first()
+    
+    if existing_like:
+        # Unlike
+        db.delete(existing_like)
+        post.likes_count = max(0, post.likes_count - 1)
+        message = "Like removed"
+        is_liked = False
+    else:
+        # Like
+        like = PostLike(post_id=post_id, user_id=current_user.id)
+        db.add(like)
+        post.likes_count += 1
+        message = "Post liked"
+        is_liked = True
+    
+    db.commit()
+    return {"message": message, "is_liked": is_liked, "likes_count": post.likes_count}
+
+@router.post("/{post_id}/comment")
+async def add_post_comment(
+    post_id: int,
+    comment_data: PostCommentCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Add a comment to a post."""
+    post = db.query(Post).filter(Post.id == post_id).first()
+    if not post:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Post not found"
+        )
+    
+    comment = PostComment(
+        post_id=post_id,
+        author_id=current_user.id,
+        content=comment_data.content
+    )
+    db.add(comment)
+    db.commit()
+    db.refresh(comment)
+    
+    return {
+        "message": "Comment added successfully",
+        "comment": {
+            "id": comment.id,
+            "content": comment.content,
+            "author_id": comment.author_id,
+            "author_name": current_user.full_name,
+            "author_avatar": current_user.avatar_url,
+            "created_at": comment.created_at
+        }
+    }
+
+@router.delete("/{post_id}/comment/{comment_id}")
+async def delete_post_comment(
+    post_id: int,
+    comment_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_active_user)
+):
+    """Delete a comment from a post."""
+    comment = db.query(PostComment).filter(
+        PostComment.id == comment_id,
+        PostComment.post_id == post_id
+    ).first()
+    
+    if not comment:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Comment not found"
+        )
+    
+    if comment.author_id != current_user.id and not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to delete this comment"
+        )
+    
+    db.delete(comment)
+    db.commit()
+    return {"message": "Comment deleted successfully"}
+
+def format_post_response(post: Post, db: Session) -> dict:
+    """Format post response with author and mentions information."""
+    mentioned_users = []
+    for mention in post.mentions:
+        user = mention.mentioned_user
+        mentioned_users.append({
+            "id": user.id,
+            "username": user.username,
+            "full_name": user.full_name,
+            "avatar_url": user.avatar_url
+        })
+    
+    # Get likes and comments
+    likes = []
+    for like in post.likes:
+        user = db.query(User).filter(User.id == like.user_id).first()
+        if user:
+            likes.append({
+                "id": like.id,
+                "user_id": user.id,
+                "username": user.username,
+                "full_name": user.full_name,
+                "avatar_url": user.avatar_url,
+                "created_at": like.created_at
+            })
+    
+    comments = []
+    for comment in post.comments:
+        user = db.query(User).filter(User.id == comment.author_id).first()
+        if user:
+            comments.append({
+                "id": comment.id,
+                "content": comment.content,
+                "author_id": user.id,
+                "author_name": user.full_name,
+                "author_avatar": user.avatar_url,
+                "created_at": comment.created_at
+            })
+    
+    return {
+        "id": post.id,
+        "author_id": post.author_id,
+        "content": post.content,
+        "image_url": post.image_url,
+        "likes_count": post.likes_count,
+        "comments_count": post.comments_count,
+        "created_at": post.created_at,
+        "updated_at": post.updated_at,
+        "author_name": post.author.full_name,
+        "author_avatar": post.author.avatar_url,
+        "mentioned_users": mentioned_users,
+        "likes": likes,
+        "comments": comments
+    }