Semaine de démarrage avec l'application My Blog

On dit que lorsque vous documentez votre apprentissage, vos difficultés, etc., vous acquerrez davantage de connaissances. Ainsi, à partir de ce jour, le 15 juillet 2024, j'ai décidé de documenter mes progrès dans l'apprentissage de Django en développant Blog App sans utiliser ChatGPT, Gemini et autres chatbots IA capables de générer du code.

Ces dernières années, j'ai créé des applications avec l'aide de ChatGPT pour générer du code pour moi, et le résultat a été excellent, j'ai pu créer les applications. cependant, je dépends trop de ChatGPT et je n'arrive pas à comprendre en profondeur les concepts de programmation. J'ai l'impression que je ne sais pas coder à partir de zéro et que je suis inutile sans l'aide de ChatGPT lors du développement d'applications. Donc, à partir de maintenant, je ferai de mon mieux pour lire et comprendre la documentation pour créer cette application de blog simple.

Cette semaine, j'ai commencé mon parcours d'apprentissage de Django en créant une simple application de blog. Mon objectif est de documenter chaque étape du processus et de montrer mes expériences et mes apprentissages.

Mise en place du projet

Étape 1 : Créer un environnement virtuel
Tout d'abord, j'ai créé un environnement virtuel pour gérer les dépendances du projet :

python -m venv <myenv> 
source myenv/bin/activate # On Windows use `myenv\Scripts\activate`

Étape 2 : Installer Django et créer un nouveau projet Django
Ensuite, j'ai installé Django et créé un nouveau projet appelé blog_app

pip install django
# Create new django project
django-admin startproject blog_app
cd blog_app

Créer l'application de l'utilisateur

Étape 1 : configuration de l'application
J'ai créé d'abord l'Authentification utilisateur

# Either of the two
django-admin startapp user
python manage.py startapp user

J'ai ensuite ajouté la nouvelle application à la liste INSTALLED_APPS dans le fichier settings.py.

Étape 2 : Création des formulaires de connexion et d'inscription de l'utilisateur
J'ai créé le fichier Forms.py dans le dossier de l'application des utilisateurs. J'utilise les AuthenticationForm et UserCreationForm intégrés à Django en en héritant de la classe personnalisée. Je pense que de cette façon, je pourrai personnaliser plus tard les informations des utilisateurs.

# user/forms.py
from django.contrib.auth.forms import AuthenticationForm, UserCreationForm
from django.forms.widgets import PasswordInput, TextInput
from django.forms.fields import EmailField
from django import forms


class LoginForm(AuthenticationForm):
    username = forms.CharField(widget=TextInput())
    password = forms.CharField(widget=PasswordInput())


class SignUpForm(UserCreationForm):
    username = forms.CharField(max_length=150, required=True)
    email = forms.EmailField(required=True)
    password1 = forms.CharField(widget=forms.PasswordInput, required=True)
    password2 = forms.CharField(widget=forms.PasswordInput, required=True)

    def save(self, commit=True):
        user = super().save(commit=False)
        user.email = self.cleaned_data["email"]
        if commit:
            user.save()
        return user

Étape 3 : Créer des vues.py
J'ai ensuite créé une vue pour l'accueil, la connexion, la déconnexion et l'inscription. Je n'inclurai pas comment j'ai créé le html, le css et le javascript dans ce projet. Si vous souhaitez vérifier, je relierai mon référentiel Github ci-dessous.

# user/views.py
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from django.contrib.auth import logout, authenticate, login
from .forms import *
from django.contrib.auth.models import auth

# I use the decorator `login_required` in order for the application to navigate to the login page if the user has not login or sign up yet.
@login_required
def homeView(request):
    return render(request, "home.html")

def loginView(request):
    '''
    First, I initialized my custom LoginForm then it will check the request of the user. 
    The user will then input it's username and password. Then it will check if the form is valid then it will get the user's input credential and it will authenticate it by using the built-in Django `authenticate` method. It will then check if the user correctly input it's credential and it will call the `login` method of Django and redirect the user to the homepage.
    '''
    form = LoginForm()
    if request.method == "POST":
       form = LoginForm(request, data=request.POST)
        if form.is_valid():
            username = request.POST.get("username")
            password = request.POST.get("password")
            user = authenticate(request, username=username, password=password)
            if user is not None:
                auth.login(request, user)
                return redirect("user:home")
    return render(request, "login.html", {"form": form})

def signupView(request):
    '''
    We will get the request from the user and check if the form is valid the we wills ave the user information in our SignUpForm
    '''
    if request.method == "POST":
        form = SignUpForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect("user:login")
    else:
        form = SignUpForm()
    return render(request, "signup.html", {"form": form})

def logoutView(request):
    '''
    I use the Django built-in `logout` method to logut the user
    '''
    logout(request)
    return redirect("user:login")

Étape 4 : Ajout d'une URL
J'ai ensuite ajouté les URL de l'utilisateur. J'ai d'abord ajouté une URL d'accueil/vide dans le blog_app/urls.py.

# blog_app/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("", include("user.urls", "user")),
    path("admin/", admin.site.urls),
]

Ensuite, j'ai ajouté un fichier urls.py dans le répertoire utilisateur.

# user/urls.py
from django.urls import path, include
from .views import *

app_name = "user"

urlpatterns = [
    path("", homeView, name="home"),
    path("signup/", signupView, name="sign-up"),
    path("login/", loginView, name="login"),
    path("logout/", logoutView, name="logout"),
]

J'ai créé une variable app_name et attribué l'utilisateur. En cela, comme vous pouvez le voir dans le view.py ci-dessus, au lieu de templates/html.py, j'utilise user:login. J'ai appris qu'avec cela, si je crée un projet à grande échelle, je peux facilement déterminer dans quelle application la fonction des vues vers laquelle je redirige.

Défis et enseignements

Cette semaine, j'ai rencontré quelques défis, tels que :

• Comprendre la structure du projet Django
• Création de l'application Django et personnalisation des formulaires

Cependant, j'ai beaucoup appris sur les bases de Django et sur la manière de structurer un projet. Je réalise également l’importance de lire attentivement la documentation. Eh bien, je ne peux toujours pas arrêter d'utiliser ChatGPT pour poser des questions sur l'erreur que j'ai rencontrée, mais je l'invite pour qu'il ne me donne pas un exemple de code mais simplement des explications simples.

Objectifs de la semaine prochaine

Je prévois de :

1. Configurer le panneau d'administration pour les articles du blog
2. Créer des vues et des modèles pour répertorier et afficher les articles de blog
3. Mettre en œuvre pour que l'utilisateur puisse publier un blog.

Restez à l'écoute pour la mise à jour de la semaine prochaine !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!