Developpe

.gitignore

@@ -0,0 +1,3 @@
+.qodo
+/api_backend/node_modules
+/api_backend/.env

api_backend/cloudinary/cloudinary.js

@@ -0,0 +1,12 @@
+import {v2 as cloudinary} from 'cloudinary'
+import {config} from 'dotenv'
+
+config()
+
+cloudinary.config({
+    cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+    api_key: process.env.CLOUDINARY_API_KEY,
+    api_secret: process.env.CLOUDINARY_API_SECRET
+})
+export default cloudinary
+

api_backend/config/db.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+export const connectDB = async () => {
+    try {
+        const conn = await mongoose.connect(process.env.MONGO_URI); // se connecte à la DB en asynchrone
+        console.log(`MongoDB connected: ${conn.connection.host}`);
+    } catch (error){
+        console.error(`Error: ${error.message}`);
+        process.exit(1); // 1 c'est pour dire que y a eu erreur et 0 succès 
+    }
+}
+
+//NoSQL enrgistre dans des collections avec des documents 

api_backend/controller/controller.ecole.js

@@ -0,0 +1,28 @@
+import Ecole from "../models/ecole.model.js"; 
+import {User} from "../models/user.model.js";
+
+
+export const getAllEcoles = async (req, res) => {
+  try {
+    const ecoles = await Ecole.find();
+    res.json(ecoles);
+  } catch (err) {
+    res.status(500).json({ error: "Erreur serveur" });
+  }
+};
+
+
+export const getEcoleByJoueur = async (req, res) => {
+  const { joueurId } = req.params;
+  try {
+    const joueur = await User.findById(joueurId).populate("ecole_id");
+
+    if (!joueur) {
+      return res.status(404).json({ message: "Joueur non trouvé" });
+    }
+
+    res.json(joueur.ecole_id);
+  } catch (err) {
+    res.status(500).json({ error: "Erreur serveur" });
+  }
+};

api_backend/controller/controller.joueur.js

@@ -0,0 +1,78 @@
+import {User} from "../models/user.model.js";
+import Team from "../models/team.model.js";
+
+
+export const getAllJoueurs = async (req, res) => {
+  try {
+    const joueurs = await User.find().select("nom prenom email ");
+    res.status(200).json(joueurs);
+
+  } catch (error) {
+    console.error("Erreur récupération des joueurs :", error);
+    res.status(500).json({ message: "Erreur serveur" });
+  }
+
+}
+
+export const getJoueursByTeam = async (req, res) => {
+  const { teamId } = req.params;
+
+  try {
+    const team = await Team.findById(teamId).populate({
+      path: 'joueurs',
+      populate: {
+        path: 'ecole_id', 
+        model: 'Ecole' 
+      }
+    });
+
+    if (!team) {
+      return res.status(404).json({ message: "Team not found" });
+    }
+
+    res.status(200).json(team.joueurs);
+
+  } catch (error) {
+    console.error("Erreur récupération des joueurs :", error);
+    res.status(500).json({ message: "Erreur serveur" });
+  }
+
+}
+
+
+export const getJoueurByPseudo =  async (req, res) => {
+    try {
+        const joueur = await User.findOne({ pseudo: req.params.pseudo });
+        if (!joueur) {
+          return res.status(404).json({ message: 'Joueur non trouvé' });
+        }
+        res.json({ data: joueur });
+      } catch (err) {
+        res.status(500).json({ message: 'Erreur serveur' });
+      }
+    };
+
+
+
+
+export const seachJoueurs =  async (req, res) => {
+        const { search } = req.query;
+
+        try {
+          let query = {};
+
+          if (search) {
+            // Regex pour insensibilité à la casse
+            query.pseudo = { $regex: search, $options: 'i' };
+          }
+
+          const joueurs = await User.find(query);
+          res.status(200).json({ success: true, data: joueurs });
+        } catch (error) {
+          console.error("Erreur lors de la récupération des joueurs :", error.message);
+          res.status(500).json({ success: false, message: "Erreur serveur" });
+        }
+
+
+    }
+

api_backend/controller/controller.team.js

@@ -0,0 +1,149 @@
+import Team from "../models/team.model.js";
+import {User} from "../models/user.model.js";
+
+
+export const getTeams = async (req, res) => {
+
+    try{
+        const teams = await Team.find({});
+        res.status(200).json({success: true, data: teams})
+    }catch (error){
+        console.error("erreur de récupération teams:" , error.message);
+        res.status(500).json({success: false, message: "erreur récupération data"});
+    }
+
+}
+
+export const creationTeams = async (req, res) => {
+    const team = req.body;
+
+    try {
+      // Vérifie si une équipe avec le même nom existe déjà
+      const existingTeam = await Team.findOne({ nom: team.nom });
+
+      if (existingTeam) {
+        return res.status(400).json({
+          success: false,
+          message: "Une équipe avec ce nom existe déjà."
+        });
+      }
+
+      // Sinon, on peut créer la nouvelle équipe
+      const newTeam = new Team(team);
+      await newTeam.save();
+
+      res.status(201).json({ success: true, data: newTeam });
+
+    } catch (error) {
+      console.error("Erreur de création d'une team:", error.message);
+      res.status(500).json({ success: false, message: "Erreur serveur" });
+    }
+  }
+
+  export const joinTeam = async (req, res) => {
+    const { id } = req.params;
+    const { playerId } = req.body;
+
+    try {
+      const team = await Team.findById(id);
+      if (!team) return res.status(404).json({ success: false, message: "Team introuvable" });
+
+      // Ajouter le joueur (évite les doublons)
+      if (!team.joueurs.includes(playerId)) {
+        team.joueurs.push(playerId);
+        await team.save();
+      }
+
+      res.status(200).json({ success: true, message: "Joueur ajouté à l'équipe" });
+    } catch (err) {
+      console.error(err.message);
+      res.status(500).json({ success: false, message: "Erreur serveur" });
+    }
+  }
+
+
+  export const deleteTeam = async (req, res)  => {
+
+    const {id} = req.params;
+
+    try{
+
+      const team =await Team.findById(id);
+      if(!team) return res.status(404).json({success: false, message: "Team introuvable"});
+
+
+      await User.updateMany(
+        { _id: { $in: team.joueurs } },
+        { $set: { droit: "" } }
+      );
+
+
+      await team.deleteOne();
+
+      res.status(200).json({ success: true, message: "Joueur ajouté à l'équipe" });
+    } catch (err) {
+      console.error(err.message);
+      res.status(500).json({ success: false, message: "Erreur serveur" });
+  }
+}
+
+
+// PATCH /api/teams/:id/update
+export const updateTeam = async (req, res) => {
+  const { id } = req.params;
+  const { nom, logo, joueurs } = req.body;
+
+  try {
+    const team = await Team.findById(id);
+    if (!team) {
+      return res.status(404).json({ success: false, message: "Équipe introuvable" });
+    }
+
+    if (nom) team.nom = nom;
+    if (logo) team.logo = logo;
+    if (joueurs) {
+      if (joueurs.length > 5) {
+        return res.status(400).json({ success: false, message: "Une équipe ne peut pas avoir plus de 5 joueurs." });
+      }
+      // Vérifier unicité
+      const uniqueJoueurs = [...new Set(joueurs.map(id => id.toString()))];
+      if (uniqueJoueurs.length !== joueurs.length) {
+        return res.status(400).json({ success: false, message: "Un joueur ne peut apparaître qu'une seule fois." });
+      }
+      team.joueurs = joueurs;
+    }
+
+    await team.save();
+    res.status(200).json({ success: true, message: "Équipe mise à jour", data: team });
+
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ success: false, message: "Erreur serveur" });
+  }
+};
+
+
+export const getTeamById = async (req, res) => {
+  const { id } = req.params;
+  try {
+    const team = await Team.findById(id)
+      .populate({
+        path: 'joueurs',
+        populate: {
+          path: 'ecole_id',
+          select: 'nom' 
+        }
+      });
+
+    if (!team) {
+      return res.status(404).json({ success: false, message: "Équipe introuvable" });
+    }
+
+    res.status(200).json({ success: true, data: team });
+  } catch (err) {
+    console.error(err.message);
+    res.status(500).json({ success: false, message: "Erreur serveur" });
+  }
+};
+
+

api_backend/controller/controller.tournois.js

@@ -0,0 +1,95 @@
+import Match from '../models/match.model.js';
+import Inscription from '../models/inscription.model.js';
+import Team from '../models/team.model.js';
+
+export const inscriptionTournois = async (req, res) => {
+  try {
+    const { team_id, tournois_id } = req.body;
+
+    // Vérifie si cette équipe est déjà inscrite à ce tournoi
+    const exists = await Inscription.findOne({ team_id, tournois_id });
+    if (exists) {
+      return res.status(400).json({ message: "Cette équipe est déjà inscrite à ce tournoi." });
+    }
+
+    const inscription = new Inscription({ team_id, tournois_id });
+    await inscription.save();
+
+    res.status(201).json({ message: "Équipe inscrite avec succès.", inscription });
+  } catch (err) {
+    res.status(500).json({ message: "Erreur serveur", error: err.message });
+  }
+}
+
+
+export const genereMatchs = async (req, res) => {
+const tournoisId = req.params.id;
+
+  try {
+    // Récupérer max 8 équipes inscrites dans ce tournoi
+const inscriptions = await Inscription.find({ tournois_id: tournoisId }).populate('team_id');
+
+const teams = inscriptions.map(inscription => inscription.team_id);
+
+if (teams.length < 2) {
+  return res.status(400).json({ message: "Pas assez d'équipes inscrites" });
+}
+
+// Supprimer anciens matchs
+await Match.deleteMany({ tournois_id: tournoisId });
+
+// Créer les matchs par paires
+const matchs = [];
+for (let i = 0; i < teams.length; i += 2) {
+  if (teams[i+1]) {
+    matchs.push({
+      tournois_id: tournoisId,
+      team1_id: teams[i]._id,
+      team2_id: teams[i+1]._id,
+      round: 1,
+      winner_id: null,
+    });
+  }
+}
+
+// Enregistrer en base
+const inserted = await Match.insertMany(matchs);
+
+res.status(201).json({ matchs: inserted });
+
+  } catch (error) {
+    console.error("Erreur génération matchs :", error);
+    res.status(500).json({ message: "Erreur serveur lors de la génération des matchs" });
+  }
+};
+
+
+export const getMatchsAvecEquipes = async (req, res) => {
+  try {
+    const tournoisId = req.params.id;
+
+    if (!tournoisId) {
+      return res.status(400).json({ message: "ID du tournoi manquant" });
+    }
+
+    const matches = await Match.find({ tournois_id: tournoisId })
+      .populate('team1_id')
+      .populate('team2_id')
+      .populate('winner_id');
+
+    res.json({ matchs: matches });
+  } catch (err) {
+    console.error("Erreur lors du chargement des matchs :", err);
+    res.status(500).json({ message: "Erreur lors du chargement des matchs" });
+  }
+};
+
+
+export const resetTournois = async (req, res) => {  
+  try {
+    await Match.deleteMany({ tournois_id: req.params.id });
+    res.status(200).json({ message: 'Matchs supprimés' });
+  } catch (err) {
+    res.status(500).json({ message: 'Erreur suppression matchs' });
+  }
+};