# Moodia

Moodia est une application Symfony permettant de générer automatiquement des structures de cours Moodle enrichies grâce à l'intelligence artificielle (OpenAI). L'application analyse des documents PDF et génère une structure de cours complète avec sections et activités, prête à être déployée sur votre instance Moodle.

## Fonctionnalités

- **Analyse de PDF** : Upload et analyse de documents PDF pour extraire le contenu pédagogique
- **Génération IA** : Création automatique de structures de cours via l'API OpenAI (GPT-4, GPT-3.5-turbo)
- **Intégration Moodle** : Déploiement automatique des cours sur votre plateforme Moodle via Web Services
- **Interface moderne** : SPA-like avec Stimulus.js et Turbo pour une expérience utilisateur fluide
- **Authentification JWT** : Sécurisation des API avec JSON Web Tokens

## Prérequis

- **PHP** 8.2 ou supérieur
- **Composer** 2.x
- **Base de données** : MySQL 8.0+ / MariaDB 10.11+ / PostgreSQL 16+
- **OpenSSL** (pour la génération des clés JWT)
- **Compte OpenAI** avec clé API
- **Instance Moodle** avec Web Services activés

## Installation

### 1. Cloner le projet

```bash
git clone <url-du-repo>
cd moodia
```

### 2. Installer les dépendances

```bash
composer install
```

### 3. Configuration des variables d'environnement

Copier le fichier `.env` et créer un fichier `.env.local` :

```bash
cp .env .env.local
```

Éditer `.env.local` et configurer les variables suivantes :

```env
# Configuration de l'application
APP_ENV=dev
APP_SECRET=votre_secret_genere_32_caracteres

# Base de données (choisir selon votre SGBD)
# MySQL
DATABASE_URL="mysql://user:password@127.0.0.1:3306/moodia?serverVersion=8.0.32&charset=utf8mb4"

# PostgreSQL (recommandé)
# DATABASE_URL="postgresql://user:password@127.0.0.1:5432/moodia?serverVersion=16&charset=utf8"

# Configuration OpenAI
OPENAI_API_KEY=votre_cle_api_openai
OPENAI_MODEL=gpt-4o-mini

# Configuration JWT (voir section suivante)
JWT_PASSPHRASE=votre_passphrase_securisee
```

**Comment obtenir une clé API OpenAI :**
1. Créer un compte sur https://platform.openai.com/
2. Aller dans https://platform.openai.com/api-keys
3. Créer une nouvelle clé API et la copier dans `OPENAI_API_KEY`

### 4. Générer les clés JWT

Les clés JWT sont nécessaires pour l'authentification par tokens. Exécuter la commande suivante :

```bash
php bin/console lexik:jwt:generate-keypair
```

Cette commande génère automatiquement :
- `config/jwt/private.pem` : Clé privée pour signer les tokens
- `config/jwt/public.pem` : Clé publique pour vérifier les tokens

**Note :** Si vous avez défini `JWT_PASSPHRASE` dans `.env.local`, utilisez-la. Sinon, laissez vide.

Les fichiers JWT sont déjà dans le `.gitignore` pour des raisons de sécurité.

### 5. Créer la base de données

```bash
# Créer la base de données
php bin/console doctrine:database:create

# Exécuter les migrations
php bin/console doctrine:migrations:migrate
```

### 6. Compiler les assets

```bash
# Compiler Tailwind CSS
php bin/console tailwind:build

# Compiler les assets (copie dans public/assets/)
php bin/console asset-map:compile
```

**En production**, utiliser le flag `--minify` pour compresser le CSS :

```bash
php bin/console tailwind:build --minify
php bin/console asset-map:compile
```

### 7. Lancer le serveur de développement

```bash
# Avec Symfony CLI (recommandé)
symfony serve

# Ou avec le serveur PHP intégré
php -S localhost:8000 -t public/
```

L'application est maintenant accessible sur http://localhost:8000

## Configuration Moodle

Pour que Moodia puisse déployer des cours sur votre Moodle, vous devez :

### 1. Activer les Web Services sur Moodle

1. Aller dans **Administration du site > Plugins > Services web > Gérer les protocoles**
2. Activer le protocole **REST**

### 2. Créer un service Web

1. Aller dans **Administration du site > Plugins > Services web > Services externes**
2. Créer un nouveau service (ex: "Moodia API")
3. Ajouter les fonctions suivantes :
   - `core_course_create_courses`
   - `core_course_get_courses`
   - `core_course_get_courses_by_field`
   - Et toutes les fonctions nécessaires pour votre utilisation

### 3. Générer un token

1. Aller dans **Administration du site > Plugins > Services web > Gérer les jetons**
2. Créer un token pour un utilisateur (qui a les droits de créer des cours)
3. Copier le token généré

### 4. Configurer le token dans l'application

Ajouter le token et l'URL Moodle dans les paramètres de l'utilisateur via l'interface Moodia.

## Structure du projet

```
moodia/
├── assets/              # JavaScript (Stimulus) et CSS
│   ├── controllers/     # Stimulus controllers
│   └── styles/          # Fichiers CSS
├── config/              # Configuration Symfony
│   ├── jwt/             # Clés JWT (généré, ignoré par git)
│   └── packages/        # Config des bundles
├── migrations/          # Migrations Doctrine
├── public/              # Point d'entrée web
├── src/
│   ├── Controller/      # Contrôleurs HTTP
│   ├── Entity/          # Entités Doctrine
│   ├── Repository/      # Repositories Doctrine
│   └── Service/         # Services métier
│       ├── Moodle/      # Services API Moodle
│       └── OpenAIService.php  # Service OpenAI
├── templates/           # Templates Twig
└── tests/               # Tests PHPUnit
```

## Utilisation

1. **Créer un compte** ou se connecter
2. **Configurer Moodle** dans les paramètres du profil (URL + Token)
3. **Uploader un PDF** contenant le contenu du cours
4. **Générer la structure** via l'assistant Moodia
5. **Déployer sur Moodle** en un clic

## Commandes utiles

```bash
# Créer une migration après modification des entités
php bin/console make:migration

# Exécuter les migrations
php bin/console doctrine:migrations:migrate

# Vider le cache
php bin/console cache:clear

# Lancer les tests
php bin/phpunit

# Voir toutes les routes
php bin/console debug:router

# Voir les services disponibles
php bin/console debug:container

# Tailwind CSS - Build une fois
php bin/console tailwind:build

# Tailwind CSS - Mode watch (recompile automatiquement)
php bin/console tailwind:build --watch

# Tailwind CSS - Build minifié (production)
php bin/console tailwind:build --minify
```

## Technologies utilisées

- **Backend** : Symfony 7.3, PHP 8.2, Doctrine ORM
- **Frontend** : AssetMapper, Stimulus 3.2, Turbo 7.3, Tailwind CSS 4.1
- **Base de données** : MySQL / PostgreSQL
- **Authentification** : LexikJWTAuthenticationBundle
- **IA** : OpenAI API (gpt-4o-mini, gpt-4)
- **Tests** : PHPUnit 12.4

## Sécurité

- Ne **JAMAIS** committer les fichiers suivants :
  - `.env.local`
  - `config/jwt/*.pem`
  - Clés API et tokens

- Ces fichiers sont déjà dans le `.gitignore`

## Dépannage

### Erreur "Cannot generate JWT"
- Vérifier que les clés JWT sont générées : `ls -la config/jwt/`
- Régénérer si nécessaire : `php bin/console lexik:jwt:generate-keypair`

### Erreur de connexion à la base de données
- Vérifier `DATABASE_URL` dans `.env.local`
- Vérifier que le serveur de base de données est lancé
- Créer la base si nécessaire : `php bin/console doctrine:database:create`

### Erreur OpenAI "Invalid API key"
- Vérifier que `OPENAI_API_KEY` est correct dans `.env.local`
- Vérifier que vous avez des crédits sur votre compte OpenAI

### Erreur Moodle "Invalid token"
- Vérifier que le token est valide dans l'administration Moodle
- Vérifier que les Web Services sont activés
- Vérifier que l'utilisateur a les droits nécessaires

## Licence

Propriétaire

## Support

Pour toute question ou problème, ouvrir une issue sur le dépôt Git.