Introduction

Bienvenue dans mon parcours de création d'une application de blog à l'aide de Django sans utiliser ChatGPT. Cette semaine, je me suis concentré sur la mise en œuvre de fonctionnalités clés pour améliorer mon application de blog. J'ai ajouté une fonctionnalité qui permet aux utilisateurs de créer des publications, de commenter des publications et d'aimer les publications d'autres utilisateurs.

Voici un aperçu détaillé de ce que j'ai fait :

Créer une application de publications Django

python manage.py startapp posts

Concevoir le modèle de poste

J'ai commencé par concevoir le modèle Post. Ce modèle stockera les articles de blog créés par les utilisateurs :

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone


class Post(models.Model):
    title = models.CharField(max_length=100)
    description = models.CharField(max_length=200, help_text="Excerpt of the post...")
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    publication_date = models.DateTimeField(default=timezone.now)

    def __str__(self):
        return self.title

Conception du modèle de commentaire et de like

Ensuite, j'ai également créé les modèles Comment et Like pour permettre aux utilisateurs de laisser des commentaires et d'aimer les publications :

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name="comments", on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_at = models.DateTimeField(default=timezone.now)

    def __str__(self):
        return f"Comment by {self.author} on {self.post}"


class Like(models.Model):
    post = models.ForeignKey(Post, related_name="likes", on_delete=models.CASCADE)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    created_at = models.DateTimeField(default=timezone.now)

    def __str__(self):
        return f"Like by {self.user} on {self.post}"

Création de vues

Je n'inclurai pas non plus les modèles. J'ai créé des vues pour créer, répertorier tous les messages et afficher des messages individuels :

from django.shortcuts import render, redirect, get_object_or_404
from rest_framework import generics
from django.contrib.auth.decorators import login_required
from .serializer import PostSerializer
from .forms import *
from .models import *

def create_post(request):
    if request.method == "POST":
        form = PostForm(request.POST)
        if form.is_valid():
            newPost = form.save(commit=False)
            newPost.author = request.user
            newPost.save()
            return redirect("posts:my-posts")
    else:
        form = PostForm()
    return render(request, "create_post.html", {"form": form, "show_header": True})

@login_required
def myPosts(request):
    '''
    List the user created posts
    '''
    posts = Post.objects.filter(author=request.user)
    return render(request, "posts_list.html", {"posts": posts, "show_header": True})

def postDetails(request, pk):
    '''
    List all posts in the dashboard and display the comments and likes
    '''
    post = get_object_or_404(Post, pk=pk)
    comment = post.comments.all()
    likes = post.likes.count()
    user_has_liked = post.likes.filter(user=request.user).exists()

    if request.method == "POST":
        comment_form = CommentForm(request.POST)
        if comment_form.is_valid():
            comment = comment_form.save(commit=False)
            comment.post = post
            comment.author = request.user
            comment.save()
            return redirect("posts:post-detail", pk=post.pk)
    else:
        comment_form = CommentForm()
    return render(
        request,
        "main_post.html",
        {
            "post": post,
            "comments": comment,
            "comment_form": comment_form,
            "likes": likes,
            "user_has_liked": user_has_liked,
        },
    )

@login_required
def like_post(request, pk):
    '''
    Handle liking posts
    '''
    post = get_object_or_404(Post, pk=pk)
    like, created = Like.objects.get_or_create(post=post, user=request.user)
    if not created:
        like.delete()
    return redirect("posts:post-detail", pk=post.pk)

Vient ensuite la création d'urls.py dans une application de publication

from django.urls import path
from .views import *

app_name = "posts"

urlpatterns = [
    path("createpost/", create_post, name="create-post"),
    path("post//", postDetails, name="post-detail"),
    path("post//like/", like_post, name="like-post"),
    path("myposts/", myPosts, name="my-posts"),
]

Défis et apprentissages

Cette semaine, j'ai rencontré des difficultés avec :

• Assurer que le bouton J'aime permette aux utilisateurs d'aimer une publication une fois.
• Création de soumissions de formulaires pour les commentaires dans la vue détaillée de la publication.

Malgré ces défis, j'ai beaucoup appris sur la gestion des interactions des utilisateurs et sur l'utilisation de l'ORM de Django pour gérer les relations entre les modèles.

Et cela fait mon application Simple Blog. Consultez mon Github pour plus de détails et une démo en direct de l'application.

Objectifs de la semaine prochaine

Je prévois de créer un autre projet Django pour améliorer mes compétences et mes connaissances.

Si vous avez une idée de ce qu'est un bon projet sur lequel travailler ou une collaboration sur un projet Django, n'hésitez pas à laisser un commentaire.

Restez à l'écoute pour plus de mises à jour sur mon voyage !