# Algorithme et Implémentations pour un Système d'Alerte de Résultats
## Algorithme Principal
```
FONCTION EnvoyerAlertesPublicationResultats()
// 1. Vérifier les nouveaux résultats publiés
nouveaux_resultats = BDD.Requête("SELECT * FROM resultats WHERE date_publication = aujourdhui()
AND NOTifié = false")
// 2. Pour chaque nouvel résultat trouvé
POUR CHAQUE resultat IN nouveaux_resultats FAIRE
// 3. Récupérer l'étudiant concerné
etudiant = BDD.Requête("SELECT * FROM etudiants WHERE id = ?", resultat.etudiant_id)
// 4. Récupérer les préférences de notification
preferences = BDD.Requête("SELECT * FROM preferences_notification WHERE etudiant_id = ?",
etudiant.id)
// 5. Envoyer les notifications selon les préférences
SI preferences.email THEN
EnvoyerEmail(etudiant.email, "Nouveau résultat disponible", GenererMessageResultat(resultat))
FIN SI
SI preferences.sms THEN
EnvoyerSMS(etudiant.telephone, "Résultat disponible: " + resultat.cours)
FIN SI
SI preferences.push THEN
EnvoyerNotificationMobile(etudiant.device_token, "Nouveau résultat", resultat.cours)
FIN SI
// 6. Marquer comme notifié
BDD.Maj("UPDATE resultats SET notifié = true WHERE id = ?", resultat.id)
FIN POUR
FIN FONCTION
FONCTION GenererMessageResultat(resultat)
RETOURNER "Bonjour " + resultat.etudiant_nom +
", votre résultat pour " + resultat.cours +
" est maintenant disponible: " + resultat.note +
"\nAccédez à votre espace: " + URL_PORTAL
FIN FONCTION
```
## Implémentations
### 1. Java (Spring Boot)
```java
@Service
public class NotificationService {
@Autowired
private ResultatRepository resultatRepo;
@Autowired
private EtudiantRepository etudiantRepo;
@Autowired
private EmailService emailService;
@Autowired
private SMSService smsService;
@Scheduled(cron = "0 0 18 * * ?") // Tous les jours à 18h
public void envoyerAlertesResultats() {
List<Resultat> nouveauxResultats =
resultatRepo.findByNotifieFalseAndDatePublication(LocalDate.now());
nouveauxResultats.forEach(resultat -> {
Etudiant etudiant = etudiantRepo.findById(resultat.getEtudiantId()).orElseThrow();
if (etudiant.getPreferences().isEmail()) {
String message = String.format(
"Bonjour %s, votre résultat pour %s est maintenant disponible: %s",
etudiant.getNom(), resultat.getCours(), resultat.getNote());
emailService.envoyer(etudiant.getEmail(), "Nouveau résultat disponible", message);
if (etudiant.getPreferences().isSms()) {
smsService.envoyer(etudiant.getTelephone(),
"Résultat disponible: " + resultat.getCours());
resultat.setNotifie(true);
resultatRepo.save(resultat);
});
```
### 2. Python (Django)
```python
from django.core.mail import send_mail
from .models import Resultat, Etudiant
import requests # Pour les SMS
def envoyer_alertes():
nouveaux_resultats = Resultat.objects.filter(
date_publication=date.today(),
notifie=False
for resultat in nouveaux_resultats:
etudiant = Etudiant.objects.get(pk=resultat.etudiant_id)
if etudiant.preferences.email:
message = f"""Bonjour {etudiant.nom},
Votre résultat pour {resultat.cours} est disponible: {resultat.note}
Accédez à votre espace: https://votreecole.edu"""
send_mail(
'Nouveau résultat disponible',
message,
'[email protected]',
[etudiant.email],
fail_silently=False,
if etudiant.preferences.sms:
sms_data = {
'api_key': 'VOTRE_CLE_API',
'to': etudiant.telephone,
'message': f'Résultat {resultat.cours} disponible'
}
requests.post('https://api.sms-provider.com/send', data=sms_data)
resultat.notifie = True
resultat.save()
```
### 3. HTML (Page de Préférences)
```html
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Préférences de notification</title>
</head>
<body>
<h1>Gérer vos préférences de notification</h1>
<form id="preferencesForm">
<div>
<input type="checkbox" id="emailNotif" name="email" checked>
<label for="emailNotif">Recevoir les alertes par email</label>
</div>
<div>
<input type="checkbox" id="smsNotif" name="sms">
<label for="smsNotif">Recevoir les alertes par SMS</label>
<input type="tel" id="phoneNumber" name="phone" placeholder="Votre numéro">
</div>
<div>
<input type="checkbox" id="pushNotif" name="push" checked>
<label for="pushNotif">Notifications push sur mobile</label>
</div>
<button type="submit">Enregistrer les préférences</button>
</form>
<script>
document.getElementById('preferencesForm').addEventListener('submit', async (e) => {
e.preventDefault();
const formData = {
email: document.getElementById('emailNotif').checked,
sms: document.getElementById('smsNotif').checked,
phone: document.getElementById('phoneNumber').value,
push: document.getElementById('pushNotif').checked
};
try {
const response = await fetch('/api/preferences', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(formData)
});
if (response.ok) {
alert('Préférences enregistrées avec succès!');
} catch (error) {
console.error('Erreur:', error);
});
</script>
</body>
</html>
```
### 4. C (Version Simplifiée)
```c
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
typedef struct {
int id;
char nom[100];
char email[100];
char telephone[20];
bool prefer_email;
bool prefer_sms;
} Etudiant;
typedef struct {
int id;
int etudiant_id;
char cours[50];
char note[10];
bool notifie;
} Resultat;
void envoyer_email(const char* email, const char* sujet, const char* message) {
printf("Envoi email à %s\nSujet: %s\nMessage: %s\n", email, sujet, message);
void envoyer_sms(const char* telephone, const char* message) {
printf("Envoi SMS à %s\nMessage: %s\n", telephone, message);
}
void notifier_resultats(Resultat resultats[], int nb_resultats, Etudiant etudiants[], int nb_etudiants) {
for (int i = 0; i < nb_resultats; i++) {
if (!resultats[i].notifie) {
for (int j = 0; j < nb_etudiants; j++) {
if (etudiants[j].id == resultats[i].etudiant_id) {
if (etudiants[j].prefer_email) {
char message[256];
snprintf(message, sizeof(message),
"Bonjour %s, votre résultat pour %s est %s",
etudiants[j].nom, resultats[i].cours, resultats[i].note);
envoyer_email(etudiants[j].email, "Nouveau résultat", message);
if (etudiants[j].prefer_sms) {
char sms[100];
snprintf(sms, sizeof(sms), "Résultat %s: %s",
resultats[i].cours, resultats[i].note);
envoyer_sms(etudiants[j].telephone, sms);
resultats[i].notifie = true;
break;
}
}
int main() {
// Exemple d'utilisation
Etudiant etudiants[2] = {
{1, "Jean Dupont", "[email protected]", "0612345678", true, false},
{2, "Marie Martin", "[email protected]", "0698765432", true, true}
};
Resultat resultats[3] = {
{1, 1, "Mathématiques", "A", false},
{2, 2, "Physique", "B+", false},
{3, 1, "Informatique", "A-", false}
};
notifier_resultats(resultats, 3, etudiants, 2);
return 0;
```
## Architecture Complémentaire
Pour un système complet, vous auriez besoin de :
1. **Base de données** avec tables :
- Etudiants (id, nom, email, telephone, etc.)
- Resultats (id, etudiant_id, cours, note, date_publication, notifié)
- Preferences_notification (etudiant_id, email, sms, push)
2. **API endpoints** (REST) pour :
- Publier de nouveaux résultats
- Gérer les préférences
- Consulter les résultats
3. **Services externes** pour :
- Envoi d'emails (SendGrid, Mailgun)
- Envoi de SMS (Twilio, Infobip)
- Notifications push (Firebase)
