Team

.gitignore

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

MicroPython/moteur.py

@@ -0,0 +1,116 @@
+from machine import Pin, PWM
+import time
+
+# Définition des broches pour les moteurs
+PWM_LEFT = 18  # Broche PWM pour le moteur gauche
+DIR_LEFT = 19  # Direction pour le moteur gauche
+
+PWM_RIGHT = 20  # Broche PWM pour le moteur droit
+DIR_RIGHT = 21  # Direction pour le moteur droit
+
+# Configuration des broches
+pwm_left = PWM(Pin(PWM_LEFT))
+pwm_right = PWM(Pin(PWM_RIGHT))
+
+pwm_left.freq(1000)  # 1 kHz
+pwm_right.freq(1000)  # Même fréquence pour éviter les conflits
+
+dir_left = Pin(DIR_LEFT, Pin.OUT)
+dir_right = Pin(DIR_RIGHT, Pin.OUT)
+
+from machine import Pin, PWM
+import time
+
+# Configuration des broches pour les moteurs
+PWM_A = PWM(Pin(18))  # Contrôle de vitesse moteur A
+DIR_A = Pin(19, Pin.OUT)  # Direction moteur A
+
+PWM_B = PWM(Pin(20))  # Contrôle de vitesse moteur B
+DIR_B = Pin(21, Pin.OUT)  # Direction moteur B
+
+# Définition de la fréquence PWM (1 kHz)
+PWM_A.freq(1000)
+PWM_B.freq(1000)
+
+def set_motor(motor, speed, direction):
+    """ 
+    Contrôle un moteur donné.
+    - motor: 'A' ou 'B'
+    - speed: 0 à 100 (vitesse en %)
+    - direction: 1 = avant, 0 = arrière
+    """
+    duty = int(speed * 65535 / 100)  # Conversion en 16 bits (0-65535)
+
+    if motor == 'A':
+        PWM_A.duty_u16(duty)
+        DIR_A.value(direction)
+    elif motor == 'B':
+        PWM_B.duty_u16(duty)
+        DIR_B.value(direction)
+
+def avancer():
+    """ Fait avancer le robot en mettant les deux moteurs en marche avant. """
+    set_motor('A', 70, 1)
+    set_motor('B', 70, 1)
+
+def reculer():
+    """ Fait reculer le robot en mettant les deux moteurs en marche arrière. """
+    set_motor('A', 70, 0)
+    set_motor('B', 70, 0)
+
+def tourner_gauche():
+    """ Fait tourner le robot à gauche (moteur droit actif). """
+    set_motor('A', 0, 1)
+    set_motor('B', 70, 1)
+
+def tourner_droite():
+    """ Fait tourner le robot à droite (moteur gauche actif). """
+    set_motor('A', 70, 1)
+    set_motor('B', 0, 1)
+
+def stop():
+    """ Arrête les deux moteurs. """
+    set_motor('A', 0, 0)
+    set_motor('B', 0, 0)
+
+
+# Test des moteurs
+avancer()
+time.sleep(3)
+stop()
+
+def set_motor(pwm, direction, direction_state, speed):
+    """ Active un moteur avec une direction et une vitesse donnée. """
+    direction.value(direction_state)
+    duty_cycle = int(speed * 65535 / 100)  # Conversion pour PWM 16 bits
+    pwm.duty_u16(duty_cycle)
+
+def avancer():
+    """ Fait avancer les deux moteurs en même temps. """
+    set_motor(pwm_left, dir_left, True, 50)
+    set_motor(pwm_right, dir_right, True, 50)
+
+def reculer():
+    """ Fait reculer les deux moteurs en même temps. """
+    set_motor(pwm_left, dir_left, False, 50)
+    set_motor(pwm_right, dir_right, False, 50)
+
+def tourner_droite():
+    """ Tourne à droite (un moteur en avant, l'autre en arrière). """
+    set_motor(pwm_left, dir_left, True, 50)
+    set_motor(pwm_right, dir_right, False, 50)
+
+def tourner_gauche():
+    """ Tourne à gauche (un moteur en arrière, l'autre en avant). """
+    set_motor(pwm_left, dir_left, False, 50)
+    set_motor(pwm_right, dir_right, True, 50)
+
+def stop():
+    """ Arrête les moteurs. """
+    pwm_left.duty_u16(0)
+    pwm_right.duty_u16(0)
+
+# Test : avancer pendant 3 secondes puis s'arrêter
+
+
+stop()

api_backend/controller/controller.ecole.js

@@ -0,0 +1,28 @@
+import Ecole from "../models/ecole.model.js"; 
+import Joueur from "../models/joueur.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 Joueur.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,27 @@
+// controllers/controller.joueur.js
+import Joueur from "../models/joueur.model.js";
+import Team from "../models/team.model.js";
+
+
+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" });
+  }
+};

api_backend/controller/controller.team.js

@@ -0,0 +1,132 @@
+import Team from "../models/team.model.js";
+import Joueur from "../models/joueur.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 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('joueurs');
+
+    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/models/ecole.model.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+
+const ecoleSchema = new mongoose.Schema({
+  nom: {
+    type: String,
+    required: true
+  },
+  adresse: {
+    type: String,
+    required: true
+  },
+
+});
+
+const Ecole = mongoose.model('Ecole', ecoleSchema);
+
+export default Ecole;

api_backend/models/joueur.model.js

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+
+const joueurScheama = new mongoose.Schema({
+    nom:{
+        type: String,
+        required: true
+    },
+    prenom:{
+        type: String,
+        required: true
+    },
+    ecole_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Ecole',
+        required: true
+    },
+    niveau:{
+        type: Number,
+    },
+    email:{
+        type: String,
+        required: true
+    },
+}, {timestamps: true }  // à chaque modif y a la date
+
+);
+
+const Joueur = mongoose.model("Joueur", joueurScheama); //creation d'une collection Local basé sur le modèle localSchema, chaque local suit le modele 
+//moongose prend le nom des collection avec Maj et sg --> locals
+export default Joueur;

api_backend/models/match.model.js

@@ -0,0 +1,34 @@
+import mongoose from "mongoose";
+const Team = require('./team.model.js');
+const Tournois = require('./tournois.model.js');
+
+
+const matchScheama = new mongoose.Schema({
+    tournois_id:{
+        type: String,
+        ref: 'Tournois',
+        required: true
+    },
+    team1_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Team',
+        required: true
+    },
+    team2_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Team',
+        required: true
+    },
+    winner_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Team',
+        required: true
+    },
+
+}, {timestamps: true }  // à chaque modif y a la date
+
+);
+
+const Match = mongoose.model("Match", matchScheama); //creation d'une collection Local basé sur le modèle localSchema, chaque local suit le modele 
+//moongose prend le nom des collection avec Maj et sg --> locals
+export default Match;