📁 MonProjet/
├── 📁 app/
│ ├── 📄 controller.py # Pour la route /
│ ├── 📄 service.py # Services
│ ├── 📁 blog/
│ │ ├── 📄 controller.py # Pour /blog
│ │ ├── 📄 service.py # Services du blogLes Contrôleurs
Un contrôleur est simplement un fichier
controller.py qui gère les requêtes de votre application. Il en existe trois types : HTTP pour les requêtes web classiques, WEBSOCKET pour le temps réel, et TEMPLATE pour vos vues. Petit conseil important : écrivez toujours vos fonctions de contrôleur en MAJUSCULES !Routes Statiques : Les Bases
Une route statique, c'est comme une adresse fixe - par exemple / ou /contact. Son contrôleur vit dans un fichier controller.py bien rangé dans son dossier.
Le Contrôleur HTTP : Votre Boîte à Outils Web
Le contrôleur HTTP est comme un chef d'orchestre qui dirige le trafic web avec ses méthodes :
GET (lecture), POST (création), PUT (mise à jour complète), DELETE (suppression), PATCH (mise à jour partielle), HEAD (vérification), OPTIONS (informations), TRACE (débogage).GET
La méthode GET est la méthode fondamentale de récupération de données. Elle permet de lire des informations sans modifier l'état du serveur, ce qui en fait la méthode la plus sécurisée et la plus utilisée. Son utilisation principale concerne l'affichage des pages et la consultation des ressources comme les profils utilisateurs ou les listes de produits.
python
# Exemple simple de GET pour récupérer un utilisateur
from nexy import Request, Depends
from .service import AppService
async def GET(
request: Request,
service: Depends(AppService)
):
return await service.get_user()POST
Complémentaire à GET, la méthode POST est dédiée à la création de nouvelles ressources. Elle assure un transfert sécurisé des données vers le serveur, avec une validation systématique avant sauvegarde. Cette méthode est essentielle pour toutes les opérations d'ajout, que ce soit la création de comptes utilisateurs ou la publication de nouveaux contenus.
python
# Exemple de POST pour créer un nouvel utilisateur
from nexy import Request, Depends
from .service import AppService
async def POST(
request: Request,
service: Depends(AppService)
):
new_user = await request.json()
return await service.create_user(new_user)PUT
La méthode PUT s'inscrit dans la logique de modification en permettant le remplacement complet d'une ressource existante. Contrairement à POST, elle nécessite l'envoi de l'intégralité des données, même celles qui ne changent pas. Cette approche garantit la cohérence des données en évitant les mises à jour partielles.
python
# Exemple de PUT pour mettre à jour un profil complet
from nexy import Request, Depends
from .service import AppService
async def PUT(
request: Request,
service: Depends(AppService)
):
updated_profile = await request.json()
return await service.update_profile(updated_profile)DELETE
Dans la continuité des opérations de modification, la méthode DELETE assure la suppression définitive des ressources. Elle complète le cycle de vie des données en permettant leur retrait du système. Cette méthode requiert une attention particulière et souvent une confirmation de l'utilisateur pour prévenir les suppressions accidentelles.
python
# Exemple de DELETE pour supprimer un compte
from nexy import Request, Depends
from .service import AppService
async def DELETE(
request: Request,
service: Depends(AppService)
):
return await service.delete_account()OPTIONS
La méthode OPTIONS joue un rôle crucial dans l'architecture des API en fournissant des métadonnées sur les opérations disponibles. Elle est particulièrement importante pour la sécurité CORS et permet aux clients de découvrir les capacités d'un endpoint. Les navigateurs l'utilisent automatiquement pour vérifier les autorisations avant d'effectuer certaines requêtes.
python
# Exemple d'OPTIONS avec configuration CORS
from nexy import Request, Depends
from .service import AppService
async def OPTIONS(
request: Request,
service: Depends(AppService)
):
return await service.get_cors_config()HEAD
La méthode HEAD est une variante optimisée de GET qui ne retourne que les en-têtes HTTP. Cette approche permet de vérifier l'existence ou les métadonnées d'une ressource sans transférer son contenu, optimisant ainsi la consommation de bande passante et les performances du système.
python
# Exemple de HEAD pour vérifier une ressource
from nexy import Request, Depends
from .service import AppService
async def HEAD(
request: Request,
service: Depends(AppService)
):
return await service.get_resource_headers()PATCH
Complétant les capacités de PUT, la méthode PATCH permet des modifications partielles et ciblées des ressources. Cette approche plus flexible optimise les performances en ne transmettant que les données nécessaires. Elle est particulièrement adaptée pour les mises à jour fréquentes de champs spécifiques.
python
# Exemple de PATCH pour modifier partiellement
from nexy import Request, Depends
from .service import AppService
async def PATCH(
request: Request,
service: Depends(AppService)
):
changes = await request.json()
return await service.update_partial(changes)TRACE
La méthode TRACE complète la suite des outils de diagnostic en permettant de suivre le parcours exact d'une requête à travers le réseau. Cette fonctionnalité est essentielle pour le débogage des problèmes de routage et la compréhension des transformations appliquées aux requêtes.
python
# Exemple de TRACE pour suivre une requête
from nexy import Request, Depends
from .service import AppService
async def TRACE(
request: Request,
service: Depends(AppService)
):
return await service.trace_request(request)Le Contrôleur WebSocket : Communication en Temps Réel
Les WebSockets, c'est la magie du temps réel ! Avec la méthode
SOCKET, créez des applications interactives qui réagissent instantanément.SOCKET
Le contrôleur WebSocket établit une communication bidirectionnelle persistante entre le client et le serveur. Cette technologie est fondamentale pour les applications nécessitant des mises à jour en temps réel, comme les systèmes de messagerie instantanée ou les tableaux de bord dynamiques.
python
# Exemple de WebSocket pour un chat en direct
from nexy import WebSocket, Depends
from .service import AppService
async def SOCKET(
ws: WebSocket,
service: Depends(AppService)
):
await service.handle_websocket(ws)Le Contrôleur Template : L'Art de la Présentation
Les templates donnent vie à votre interface avec deux méthodes magiques :
VIEW pour vos pages et LAYOUT pour la structure globale.VIEW
La méthode VIEW transforme les données en interfaces utilisateur structurées. Cette méthode, enrichie par le décorateur @component, permet la création de pages web dynamiques en combinant logique métier et présentation. Elle représente une évolution naturelle de la méthode GET en retournant du contenu HTML formaté.
python
# Exemple de VIEW pour une page de profil
from nexy import component, Depends
from .service import AppService
from components import Profile, UserStats
@component(
import = [Profile, UserStats]
)
def VIEW(
service: Depends(AppService)
):
return service.get_profile_data()LAYOUT
La méthode LAYOUT définit la structure globale de l'application. Elle gère les éléments communs comme l'en-tête, le pied de page et la navigation. Cette méthode, utilisée conjointement avec le décorateur @component, assure une cohérence visuelle à travers l'application.
python
# Exemple de LAYOUT avec navigation et footer
from nexy import component, Depends
from .service import AppService
from components import Navbar, Footer, Sidebar
@component(
import = [Navbar, Footer, Sidebar]
)
def LAYOUT(
service: Depends(AppService)
):
return service.get_layout_data()Routes Dynamiques : La Flexibilité en Action
Les routes dynamiques sont comme des variables dans votre URL ! Par exemple : /utilisateurs/alice ou /produits/42. Elles s'adaptent à vos besoins !
📁 MonProjet/
├── 📁 app/
│ ├── 📁 [slug]/
│ │ ├── 📄 controller.py
│ │ └── 📄 service.py
│ └── 📁 produits/
│ └── 📁 [id]/
│ ├── 📄 controller.py
│ └── 📄 service.pyGET
Dans une route dynamique, la méthode GET acquiert une dimension supplémentaire grâce au paramètre 'slug'. Cette approche permet une identification précise des ressources, essentielle pour la récupération de contenus spécifiques comme des articles de blog ou des profils utilisateurs individuels.
python
# Exemple de GET dynamique pour un article de blog
from nexy import Request, Depends
from .service import AppService
async def GET(
slug: str,
request: Request,
service: Depends(AppService)
):
return await service.get_article(slug)POST
La méthode POST en contexte dynamique permet la création de ressources dans des contextes spécifiques. Cette fonctionnalité est particulièrement utile pour l'ajout d'éléments liés à une ressource existante, comme des commentaires sur un article ou des sous-éléments dans une collection.
python
# Exemple de POST pour ajouter un commentaire
from nexy import Request, Depends
from .service import AppService
async def POST(
slug: str,
request: Request,
service: Depends(AppService)
):
comment_data = await request.json()
return await service.add_comment(slug, comment_data)WebSockets Dynamiques : Communication Personnalisée
SOCKET
Les WebSockets dynamiques étendent les capacités des WebSockets standards en permettant des connexions contextuelles via le paramètre slug. Cette approche permet la création de canaux de communication dédiés, particulièrement adaptés pour les salles de discussion privées ou les flux de données personnalisés.
python
# Exemple de WebSocket pour une salle de chat privée
from nexy import WebSocket, Depends
from .service import AppService
async def SOCKET(
slug: str,
ws: WebSocket,
service: Depends(AppService)
):
await service.handle_dynamic_websocket(slug, ws)Templates Dynamiques : Interfaces Sur Mesure
VIEW
La méthode VIEW en contexte dynamique permet la création de pages personnalisées basées sur le paramètre slug. Cette approche permet d'adapter la présentation en fonction du contexte, idéale pour les profils utilisateurs ou les articles de contenu spécifiques.
python
# Exemple de VIEW pour un profil utilisateur spécifique
from nexy import component, Depends
from .service import AppService
from components import UserProfile, ActivityFeed
@component(
import = [UserProfile, ActivityFeed]
)
def VIEW(
slug: str,
service: Depends(AppService)
):
return service.get_dynamic_profile_data(slug)LAYOUT
Le LAYOUT dynamique étend les capacités de mise en page en fonction du contexte fourni par le slug. Cette flexibilité permet d'adapter la structure globale selon les besoins spécifiques, comme des thèmes personnalisés ou des dispositions sectorielles.
python
# Exemple de LAYOUT dynamique pour différentes sections
from nexy import component, Depends
from .service import AppService
from components import DynamicNav, Footer
@component(
import = [DynamicNav, Footer]
)
def LAYOUT(
slug: str,
service: Depends(AppService)
):
return service.get_dynamic_layout_data(slug)Bravo ! 🎉 Vous venez de découvrir la puissance des contrôleurs Nexy. Rappelez-vous : les fonctions en MAJUSCULES, des routes bien organisées, et vous voilà prêt à créer des applications web incroyables ! Continuez votre voyage dans la documentation pour devenir un véritable maître de Nexy. 🚀