# Configuration - NationsGlory Web Admin

Guide de configuration complète du panel d'administration web.

## 📋 Prérequis

### Logiciels Requis
- **Docker** : Version 20.10 ou supérieure
- **Docker Compose** : Version 2.0 ou supérieure
- **Serveur Minecraft 1.6.4** avec RCON activé
- **Ports disponibles** : 4001 (Web), 25575 (RCON)

### Vérification
```bash
# Vérifier Docker
docker --version

# Vérifier Docker Compose
docker-compose --version

# Vérifier les ports
netstat -tuln | grep -E '4001|25575'
```

## ⚙️ Configuration du Serveur Minecraft

### 1. Activer RCON

Éditez `server.properties` du serveur Minecraft :

```properties
# RCON Configuration
enable-rcon=true
rcon.port=25575
rcon.password=VotreMotDePasseSecurise

# Autres paramètres recommandés
server-ip=
server-port=25565
max-players=20
motd=NationsGlory Server
```

**Important** : Le mot de passe RCON doit être identique dans `server.properties` et `docker-compose.yml`.

### 2. Redémarrer le Serveur

```bash
# Arrêter le serveur
docker stop mc-nationsglory

# Démarrer le serveur
docker start mc-nationsglory

# Vérifier les logs
docker logs mc-nationsglory | grep RCON
# Vous devriez voir : "RCON running on 0.0.0.0:25575"
```

### 3. Configurer les OPs

Seuls les opérateurs peuvent se connecter au panel web.

```bash
# Dans le serveur Minecraft (console ou RCON)
op VotreNomDeJoueur

# Vérifier le fichier ops.txt
cat /chemin/vers/serveur/ops.txt
```

## 🐳 Configuration Docker

### 1. Fichier docker-compose.yml

Le fichier principal de configuration :

```yaml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "4001:4001"
    environment:
      NODE_ENV: production
      PORT: 4001
      SERVER_DIR: /mc-server
      RCON_HOST: localhost
      RCON_PORT: 25575
      SESSION_SECRET: change-this-in-production
    volumes:
      - /chemin/vers/serveur/minecraft:/mc-server
      - web-admin:/mc-server/.web-admin
    restart: unless-stopped
    network_mode: host

volumes:
  web-admin:
```

### 2. Variables d'Environnement

| Variable | Description | Valeur par Défaut | Obligatoire |
|----------|-------------|-------------------|-------------|
| `NODE_ENV` | Mode d'exécution | `production` | Oui |
| `PORT` | Port du panel web | `4001` | Oui |
| `SERVER_DIR` | Chemin vers le serveur MC (dans Docker) | `/mc-server` | Oui |
| `RCON_HOST` | Hôte RCON | `localhost` | Oui |
| `RCON_PORT` | Port RCON | `25575` | Oui |
| `RCON_PASSWORD` | Mot de passe RCON | - | Oui (via .env) |
| `SESSION_SECRET` | Secret pour les sessions | - | Oui |

### 3. Configuration des Volumes

**Volume mc-server** : Serveur Minecraft (lecture/écriture)
```yaml
volumes:
  - /home/user/minecraft-server:/mc-server
```

**Volume web-admin** : Données persistantes du panel
```yaml
volumes:
  - web-admin:/mc-server/.web-admin
```

Ce volume stocke :
- `rcon-history.json` - Historique des commandes RCON

### 4. Network Mode

```yaml
network_mode: host
```

Le mode `host` permet au conteneur d'accéder directement au RCON sur `localhost:25575`.

**Alternative** (si vous n'utilisez pas host) :
- Changer `RCON_HOST` vers l'IP du serveur Minecraft
- Exposer le port RCON dans le réseau Docker

## 🔐 Configuration de Sécurité

### 1. Générer un SESSION_SECRET

```bash
# Générer une clé aléatoire
openssl rand -base64 32

# Ou avec Node.js
node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"
```

Ajoutez-le dans `docker-compose.yml` ou créez un fichier `.env` :

```env
SESSION_SECRET=VotreClefAleatoireSecurisee
RCON_PASSWORD=VotreMotDePasseRCON
```

### 2. Mot de Passe RCON

**Recommandations** :
- Minimum 12 caractères
- Mélange de majuscules, minuscules, chiffres, symboles
- Ne pas utiliser de mots du dictionnaire
- Différent du mot de passe serveur

**Exemple de mot de passe fort** :
```
Fx98dd82&*KmP!qZ7
```

### 3. Permissions Fichiers

```bash
# Serveur Minecraft
chmod 755 /chemin/vers/serveur/minecraft
chmod 644 /chemin/vers/serveur/minecraft/server.properties
chmod 644 /chemin/vers/serveur/minecraft/ops.txt

# Panel Web
chmod 755 WebNationsGlory_ServeurBuild_Red
chmod 644 docker-compose.yml
```

## 🎨 Configuration Frontend

### 1. Personnalisation de l'Interface

Le style est défini dans `frontend/public/css/style.css`.

**Variables CSS principales** :
```css
:root {
  --primary-color: #3498db;
  --danger-color: #e74c3c;
  --success-color: #2ecc71;
  --warning-color: #f39c12;
}
```

### 2. Console RCON

La console est stylée comme un terminal Linux :

**Couleurs par défaut** :
- Fond : `#1e1e1e` (noir)
- Texte : `#0f0` (vert)
- Prompt : Nom d'utilisateur + serveur

Pour modifier :
```css
.terminal {
  background-color: #1e1e1e;
  color: #0f0;
}
```

## ⚡ Configuration Backend

### 1. Fichier .env (Optionnel)

Créez `backend/.env` pour le développement local :

```env
NODE_ENV=development
PORT=4001
SERVER_DIR=/chemin/absolu/vers/serveur/minecraft
RCON_HOST=localhost
RCON_PORT=25575
RCON_PASSWORD=VotreMotDePasse
SESSION_SECRET=VotreSecret
```

### 2. Configuration Express

Dans `backend/src/server.js`, les paramètres principaux :

```javascript
// Session
app.use(session({
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false,
  cookie: { 
    secure: false,  // true en HTTPS
    httpOnly: true,
    maxAge: 1000 * 60 * 60 * 24  // 24 heures
  }
}));

// CORS
app.use(cors({
  origin: true,
  credentials: true
}));
```

### 3. Gestion des Sessions

**En production**, utilisez Redis au lieu de MemoryStore :

```javascript
const RedisStore = require('connect-redis')(session);
const redis = require('redis');
const redisClient = redis.createClient();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  // ...autres options
}));
```

## 🔧 Configuration Avancée

### 1. Cooldown Serveur

Temps d'attente avant arrêt/redémarrage (dans `frontend/public/js/app.js`) :

```javascript
const cooldownSeconds = 60;  // 60 secondes par défaut
```

### 2. Historique RCON

Nombre maximum de commandes sauvegardées :

```javascript
// Dans backend/src/routes/rcon.js
const MAX_HISTORY = 100;
```

### 3. Timeout RCON

Délai d'attente pour les commandes RCON :

```javascript
// Dans backend/src/utils/rcon.js
const TIMEOUT = 5000;  // 5 secondes
```

## 📊 Configuration des Logs

### 1. Logs du Panel

```bash
# Voir les logs en temps réel
docker-compose logs -f app

# Dernières 100 lignes
docker-compose logs --tail=100 app

# Logs avec timestamp
docker-compose logs -t app
```

### 2. Logs du Serveur Minecraft

Accessible via le panel : Menu **Logs** → `latest.log`

## 🌐 Configuration Réseau

### 1. Pare-feu

Ouvrir les ports nécessaires :

```bash
# UFW (Ubuntu/Debian)
sudo ufw allow 4001/tcp
sudo ufw allow 25575/tcp

# Firewalld (CentOS/RHEL)
sudo firewall-cmd --permanent --add-port=4001/tcp
sudo firewall-cmd --permanent --add-port=25575/tcp
sudo firewall-cmd --reload
```

### 2. Accès Distant

Pour accéder au panel depuis l'extérieur :

1. Modifier `ports` dans docker-compose.yml :
```yaml
ports:
  - "0.0.0.0:4001:4001"
```

2. Configurer le pare-feu
3. Utiliser un reverse proxy (Nginx/Apache) pour HTTPS

## ✅ Vérification de la Configuration

### Checklist

- [ ] RCON activé dans `server.properties`
- [ ] Mot de passe RCON identique dans les deux fichiers
- [ ] `SERVER_DIR` pointe vers le bon dossier
- [ ] Au moins un joueur dans `ops.txt`
- [ ] Ports 4001 et 25575 disponibles
- [ ] Docker et Docker Compose installés
- [ ] `SESSION_SECRET` généré et sécurisé
- [ ] Volumes Docker correctement montés

### Test de Connexion

```bash
# Test RCON avec Docker
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse

# Test du panel web
curl http://localhost:4001

# Vérifier les volumes
docker volume ls | grep web
```

## 🆘 Problèmes Courants

### Le panel ne se connecte pas au RCON

1. Vérifier que RCON est actif : `docker logs mc-nationsglory | grep RCON`
2. Vérifier le mot de passe dans les deux configs
3. Tester manuellement : `docker exec -it mc-nationsglory rcon-cli`

### Les joueurs ne s'affichent pas

1. Vérifier que `/world/players/` existe
2. Vérifier que `usercache.json` est présent
3. Vérifier les permissions du volume

### Impossible de se connecter

1. Vérifier que vous êtes dans `ops.txt`
2. Vider le cache du navigateur
3. Vérifier les logs : `docker-compose logs app`

---

Pour plus d'informations : [README.md](README.md) | [DEPLOYMENT.md](DEPLOYMENT.md) | [MAINTENANCE.md](MAINTENANCE.md)