Atelier Pro — CanisPro Éducation

Outils & Technologies

PHP — langage backend

Symfony — framework MVC

Doctrine ORM — mapping objet-relationnel

MySQL — base de données relationnelle

Twig — moteur de templates (vues)

Git / GitHub — versioning et collaboration

ClickUp — gestion des tâches (GANTT)

Canva — maquettage des interfaces

Contexte

Le centre CanisPro Éducation, spécialisé dans l'accompagnement personnalisé (cours individuels, collectifs et agility), souhaitait effectuer sa transition numérique en remplaçant ses outils de gestion rudimentaires par une application web moderne.

En tant qu'équipe de développeurs juniors, notre mission consistait à maintenir et faire évoluer une application web développée sous le framework Symfony. Le projet vise à centraliser la gestion des chiens, des propriétaires et des inscriptions, tout en garantissant une sécurité stricte des accès via différents rôles.

L'intervention, prévue sur un volume de 24 heures, imposait une méthodologie rigoureuse : méthode agile, GANTT (ClickUp), branches GitHub dédiées, validation par fixtures et production de documentation.

Équipe du projet

Annaëlle CHAMPIAU — GANTT · Entités Cours & Séance · CSS membre

Yohan IRIBARREN — Installation Symfony · Entités Utilisateur/Chien · Fixtures

Calixta DELAGE — Diagrammes UML · Entités Propriétaire/Inscription · Relations

Marina RENAUD — Maquettage Canva · VisiteurController · Templates accueil

Organisation du projet

Le projet a été piloté avec une méthode agile : tableau Kanban sur ClickUp, GANTT pour la répartition des tâches par membre, et versioning GitHub avec des commits réguliers et des branches par fonctionnalité.

Tableau Kanban — ClickUp

Suivi de versions — GitHub

Historique des versions GitHub — Historique des commits GitHub — versioning collaboratif

Architecture technique — MVC Symfony

L'application repose sur l'architecture MVC Symfony : les Modèles correspondent aux entités Doctrine (Utilisateur, Propriétaire, Chien, Race, NiveauxApprentissage, Cours, Séance, Inscription), les Vues aux fichiers Twig (templates/), et les Contrôleurs aux classes PHP dans src/Controller/.

Structure du projet — Entity / Form / Repository / Controller

Structure Entity Form Repository — Arborescence `src/` — Entity · Form · Repository

Controllers · DataFixtures · Documentation phpDoc

Controllers DataFixtures phpDoc — Contrôleurs, Fixtures et documentation phpDoc

Templates Twig — vues par rôle

Templates Twig — arborescence par rôle (1/3)

Templates Twig — espace membre & admin (2/3)

Templates Twig — suite (3/3)

Modèles de données

La base de données MySQL est gérée par Doctrine ORM. Les entités principales sont : Utilisateur, Propriétaire, Chien, Race, NiveauxApprentissage, Cours, Séance et Inscription.

Modèle Conceptuel de Données (MCD)

Diagramme de classe

Relations entre les entités

Chien → Race : ManyToOne

Chien → Propriétaire : ManyToOne

Chien → NiveauxApprentissage : ManyToOne

Cours → NiveauxApprentissage : ManyToOne

Cours → Séance : OneToMany

Séance ↔ Inscription : ManyToMany

Chien ↔ Inscription : ManyToMany

Propriétaire → Utilisateur : OneToOne

Vues Visiteur

Un visiteur non connecté peut consulter l'accueil, le catalogue des cours (Socialisation, Obéissance, Agilité), les séances disponibles, les informations du centre et la page de contact. Il peut aussi s'inscrire ou se connecter.

Contrôleur associé — VisiteurController.php

// Routes publiques — accessibles sans authentification
#[Route('/', name: 'accueil')]         accueil()
#[Route('/cours', name: 'cours')]           listeCours()
#[Route('/seances', name: 'seances')]       listeSeances()
#[Route('/informations', name: 'infos')]   informations()
#[Route('/contact', name: 'contact')]       contact()
    

Captures d'écran — vue visiteur

Page d'accueil — CanisPro Éducation

Menu de navigation — visiteur non connecté

Catalogue des cours — Socialisation · Obéissance · Agilité

Séances disponibles — créneaux individuels et collectifs

Page informations — présentation du centre

Page contact — formulaire de contact

Connexion — authentification membre

Inscription — création d'un compte propriétaire

Espace Membre

Un membre connecté accède à son espace personnel : consulter et modifier son profil propriétaire, gérer ses chiens (ajout, modification, voir les séances inscrites) et inscrire un chien à une séance.

Contrôleur associé — MembreController.php

#[Route('/espace-personnel', name: 'espace_personnel')]
public function espaceProprietaire(): Response {
    $proprietaire = $this->getUser()->getProprietaire();
    return $this->render('membre/espace_personnel.html.twig', ['proprietaire' => $proprietaire]);
}

#[Route('/espace-chien', name: 'espace_chien')]
public function espaceChien(): Response {
    $chiens = $this->getUser()->getProprietaire()->getChiens();
    return $this->render('membre/espace_chien.html.twig', ['chiens' => $chiens]);
}

#[Route('/espace-chien/seances/{id}', name: 'chien_inscrit_seance')]
public function voirSeancesChien(ChienRepository $repo, int $id): Response {
    $chien = $repo->find($id);
    return $this->render('membre/chien_seances.html.twig', [
        'chien'        => $chien,
        'inscriptions' => $chien->getInscriptions(),
    ]);
}
    

Captures d'écran — espace membre

Accès à l'espace membre après connexion

Menu de navigation — membre connecté

Mon espace — profil du propriétaire

Modifier le profil propriétaire

Espace chien — liste des compagnons

Formulaire — ajouter un compagnon

Modifier le profil d'un chien

Inscrire un chien à une séance

Navigation entre les séances

Séances inscrites — chien Pica

Séances inscrites — chien Suki

Séances inscrites — chien Pinto

Espace Administration

L'administrateur dispose d'un accès complet en CRUD sur toutes les entités : chiens, propriétaires, cours, séances et inscriptions.

Contrôleur associé — AdminController.php

// Accès restreint au rôle ADMIN — gestion CRUD complète
#[IsGranted('ROLE_ADMIN')]
class AdminController extends AbstractController
{
    #[Route('/admin/chiens')]     gererChiens()       // liste + CRUD
    #[Route('/admin/cours')]      gererCours()        // liste + CRUD
    #[Route('/admin/proprietaires')] gererProprietaires() // liste + CRUD
    #[Route('/admin/inscriptions')] gererInscriptions() // liste + CRUD
    #[Route('/admin/seances')]    gererSeances()      // liste + CRUD
}
    

Captures d'écran — back-office admin

Admin — gestion des chiens (liste + CRUD)

Admin — gestion des cours

Admin — gestion des propriétaires

Admin — gestion des inscriptions

Admin — gestion des séances

Ma contribution

Planification GANTT — création et gestion du tableau de tâches ClickUp, répartition des responsabilités et suivi de l'avancement
Entité Doctrine Cours — champs typeEntrainement, description, prix, esCollectif, nbChienMax, durée ; relation OneToMany → Séance ; relation ManyToOne → NiveauxApprentissage
Entité Doctrine Séance — champs date, heure ; relation ManyToOne → Cours ; relation ManyToMany ↔ Inscription
CSS espace membre — correction et amélioration du bouton « Modifier un propriétaire »

Résultats & Apprentissages

8

Entités Doctrine créées

3

Rôles gérés (Visiteur · Membre · Admin)

24h

Volume de travail en équipe

4

Membres dans l'équipe

Ce projet m'a permis de découvrir le framework Symfony et l'ORM Doctrine, en travaillant sur une architecture MVC complète avec gestion des rôles. La collaboration en équipe de 4, organisée via ClickUp et des branches GitHub dédiées, m'a appris à coordonner le développement et à gérer les conflits de fusion.

J'ai pris en charge la planification (GANTT), la création des entités Cours et Séance avec leurs relations ManyToMany et OneToMany, ainsi que des corrections CSS sur l'espace membre.

Documentation

Documentation personnelle CanisPro (PDF) Contexte, choix techniques, base de données, vues utilisateur — 37 pages

Compétences BTS SIO validées

B1.3 Développer la présence en ligne de l'organisation

B1.4 Travailler en mode projet (agile, GANTT, GitHub)

B1.1 Gérer le patrimoine informatique (versioning Git)

B2.2 Concevoir et développer une solution applicative

B2.4 Concevoir et réaliser une base de données