# Guide de Déploiement en Production - StayManager

**Version:** 1.0  
**Date:** Novembre 2025

---

## Table des Matières

1. [Vue d'ensemble](#vue-densemble)
2. [Prérequis](#prérequis)
3. [Configuration de la Base de Données](#configuration-de-la-base-de-données)
4. [Configuration de l'Application](#configuration-de-lapplication)
5. [Déploiement des Fichiers](#déploiement-des-fichiers)
6. [Configuration du Serveur](#configuration-du-serveur)
7. [Sécurité](#sécurité)
8. [Vérification Post-Déploiement](#vérification-post-déploiement)
9. [Maintenance](#maintenance)

---

## Vue d'ensemble

StayManager est conçu pour fonctionner aussi bien en environnement local qu'en production. L'architecture MVC et l'utilisation de chemins relatifs permettent un déploiement facile sur un hébergeur distant.

### Points Clés

- ✅ **Architecture portable** : Utilisation de chemins relatifs (`__DIR__`, `dirname(__DIR__)`)
- ✅ **Configuration centralisée** : Tous les paramètres dans `config/`
- ✅ **Base de données configurable** : Paramètres de connexion modifiables
- ✅ **URLs dynamiques** : Fonction `getBaseUrl()` pour adapter les URLs
- ✅ **Sécurité** : Mode debug désactivable en production

---

## Prérequis

### Serveur Web

- **PHP** : Version 8.0 ou supérieure
- **MySQL** : Version 8.0 ou supérieure
- **Apache** ou **Nginx** avec mod_rewrite activé
- **Extensions PHP requises** :
  - `pdo`
  - `pdo_mysql`
  - `json`
  - `mbstring`
  - `openssl`
  - `gd` (pour les images)
  - `zip` (pour les exports)

### Hébergeur

- Hébergement web standard (shared hosting, VPS, cloud)
- Accès FTP/SFTP ou SSH
- Accès à phpMyAdmin ou ligne de commande MySQL
- Support PHP 8.0+

---

## Configuration de la Base de Données

### Étape 1 : Créer la Base de Données sur le Serveur

1. Connectez-vous à votre panneau d'hébergement (cPanel, Plesk, etc.)
2. Accédez à **phpMyAdmin** ou utilisez la ligne de commande MySQL
3. Créez une nouvelle base de données :
   ```sql
   CREATE DATABASE staymanager_prod CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
   ```
4. Créez un utilisateur MySQL avec tous les privilèges sur cette base :
   ```sql
   CREATE USER 'staymanager_user'@'localhost' IDENTIFIED BY 'mot_de_passe_fort';
   GRANT ALL PRIVILEGES ON staymanager_prod.* TO 'staymanager_user'@'localhost';
   FLUSH PRIVILEGES;
   ```

### Étape 2 : Importer la Structure de la Base de Données

1. Exportez votre base de données locale :
   - Via phpMyAdmin : Sélectionnez la base → **Exporter** → **SQL**
   - Ou utilisez la commande : `mysqldump -u root -p staymanager_db > staymanager_backup.sql`
2. Importez sur le serveur de production :
   - Via phpMyAdmin : Sélectionnez la base → **Importer** → Choisissez le fichier SQL
   - Ou via ligne de commande : `mysql -u staymanager_user -p staymanager_prod < staymanager_backup.sql`

### Étape 3 : Configurer la Connexion

1. Copiez le fichier `config/database.production.php.example` vers `config/database.production.php`
2. Modifiez les paramètres :

```php
<?php
class Database {
    private $host = 'localhost'; // Ou l'adresse IP de votre serveur MySQL
    private $db_name = 'staymanager_prod'; // Nom de votre base de données
    private $username = 'staymanager_user'; // Votre utilisateur MySQL
    private $password = 'votre_mot_de_passe_fort'; // Mot de passe fort
    // ... reste du code
}
```

3. **Important** : Modifiez `config/database.php` pour qu'il détecte l'environnement :

```php
<?php
// Détecter l'environnement
$environment = getenv('APP_ENV') ?: 'development';

if ($environment === 'production' && file_exists(__DIR__ . '/database.production.php')) {
    require_once __DIR__ . '/database.production.php';
} else {
    // Configuration de développement (actuelle)
    class Database {
        private $host = 'localhost';
        private $db_name = 'staymanager_db';
        private $username = 'root';
        private $password = '';
        // ... reste du code
    }
}
?>
```

---

## Configuration de l'Application

### Étape 1 : Configurer l'URL de Production

1. Copiez `config/config.production.php.example` vers `config/config.production.php`
2. Modifiez l'URL de l'application :

```php
define('APP_URL', 'https://votre-domaine.com'); // URL complète avec HTTPS
```

### Étape 2 : Désactiver le Mode Debug

Dans `config/config.production.php`, assurez-vous que :

```php
define('DEBUG_MODE', false); // Toujours false en production
define('DISPLAY_ERRORS', false); // Toujours false en production
define('LOG_LEVEL', 'ERROR'); // Seulement les erreurs en production
```

### Étape 3 : Modifier la Clé Secrète JWT

**IMPORTANT** : Changez la clé secrète JWT :

```php
define('JWT_SECRET', 'GENERER_UNE_CLE_SECRETE_FORTE_ET_UNIQUE_ICI');
```

Générez une clé forte avec :
```bash
php -r "echo bin2hex(random_bytes(32));"
```

### Étape 4 : Adapter config.php pour la Production

Modifiez `config/config.php` pour détecter l'environnement :

```php
<?php
// Détecter l'environnement
$environment = getenv('APP_ENV') ?: 'development';

if ($environment === 'production' && file_exists(__DIR__ . '/config.production.php')) {
    require_once __DIR__ . '/config.production.php';
} else {
    // Configuration de développement (actuelle)
    // ... votre configuration actuelle
}
?>
```

---

## Déploiement des Fichiers

### Étape 1 : Préparer les Fichiers

1. **Exclure les fichiers de développement** :
   - Tous les fichiers `test_*.php`
   - Tous les fichiers `debug_*.php`
   - Tous les fichiers `check_*.php`
   - Les fichiers `.backup.*`
   - Le dossier `vendor/` si vous utilisez Composer (sera régénéré)

2. **Créer un fichier `.gitignore`** (si vous utilisez Git) :
```
# Fichiers de configuration de production
config/database.production.php
config/config.production.php

# Fichiers de logs
logs/*
*.log

# Fichiers de cache
cache/*
*.cache

# Fichiers de backup
backups/*

# Fichiers de test
test_*.php
debug_*.php
check_*.php
*.backup.*
```

### Étape 2 : Transférer les Fichiers

1. **Via FTP/SFTP** :
   - Connectez-vous à votre serveur
   - Transférez tous les fichiers dans le dossier public (ex: `public_html/`, `www/`, `htdocs/`)
   - **Important** : Assurez-vous que la structure des dossiers est préservée :
     ```
     StayManager/
     ├── assets/
     ├── config/
     ├── controllers/
     ├── includes/
     ├── models/
     ├── views/
     ├── index.php
     ├── login.php
     ├── reservations.php
     ├── restaurant_orders.php
     ├── cash_register.php
     ├── etc.
     ```

2. **Via Git** (recommandé) :
   ```bash
   git clone votre-repo.git
   cd StayManager
   # Installer les dépendances si nécessaire
   composer install --no-dev --optimize-autoloader
   ```

### Étape 3 : Configurer le Fichier .htaccess

1. Copiez le fichier `.htaccess.production` vers `.htaccess` à la racine :
   ```bash
   cp .htaccess.production .htaccess
   ```

2. Vérifiez que le fichier `.htaccess` est bien présent à la racine de l'application

3. **Important** : Sur certains hébergeurs, le fichier `.htaccess` doit être dans le dossier `public_html/` ou `www/`, pas dans un sous-dossier

### Étape 4 : Configurer les Permissions

Sur le serveur, configurez les permissions des dossiers :

```bash
# Dossiers en écriture
chmod 755 assets/uploads/
chmod 755 logs/
chmod 755 cache/
chmod 755 backups/
chmod 755 reports/

# Fichiers de configuration (lecture seule pour les autres)
chmod 644 config/*.php
chmod 600 config/database.production.php
chmod 600 config/config.production.php
```

---

## Routes et Accès aux Pages

### Architecture des Routes

StayManager utilise une architecture basée sur des **fichiers PHP directs** avec des **paramètres GET** pour les actions. Chaque module a son propre fichier d'entrée. Cette approche est simple, portable et fonctionne sur tous les hébergeurs sans configuration spéciale.

**Format des routes** : `https://votre-domaine.com/fichier.php?action=action&id=X&param=value`

### Liste Complète des Routes Principales

#### Pages d'Authentification
- `/login.php` - Page de connexion
- `/logout.php` - Déconnexion
- `/index.php` - Page d'accueil (redirige vers login ou dashboard)

#### Dashboard
- `/dashboard_dynamic.php` - Dashboard principal (recommandé)
- `/dashboard_simple.php` - Dashboard simplifié
- `/dashboard.php` - Ancien dashboard (compatibilité)

#### Gestion des Réservations
- `/reservations.php` - Liste des réservations
  - `/reservations.php?action=create` - Créer une réservation
  - `/reservations.php?action=edit&id=X` - Modifier une réservation
  - `/reservations.php?action=show&id=X` - Voir une réservation
  - `/reservations.php?action=delete&id=X` - Supprimer une réservation
- `/group_reservations.php` - Réservations groupées
- `/room_planning.php` - Planning des chambres

#### Gestion des Clients
- `/clients.php` - Liste des clients
  - `/clients.php?action=create` - Créer un client
  - `/clients.php?action=edit&id=X` - Modifier un client
  - `/clients.php?action=show&id=X` - Voir un client

#### Gestion des Chambres
- `/rooms.php` - Liste des chambres
  - `/rooms.php?action=create` - Créer une chambre
  - `/rooms.php?action=edit&id=X` - Modifier une chambre
  - `/rooms.php?action=show&id=X` - Voir une chambre

#### Gestion des Événements
- `/events.php` - Liste des événements
- `/event_bookings.php` - Réservations d'événements
  - `/event_bookings.php?action=create` - Créer un événement
  - `/event_bookings.php?action=edit&id=X` - Modifier un événement

#### Module Restaurant
- `/restaurant.php` - Factures restaurant
- `/restaurant_menus.php` - Menus restaurant
  - `/restaurant_menus.php?action=create` - Créer un menu
  - `/restaurant_menus.php?action=edit&id=X` - Modifier un menu
- `/restaurant_orders.php` - Commandes restaurant
  - `/restaurant_orders.php?action=create` - Créer une commande
  - `/restaurant_orders.php?action=show&id=X` - Voir une commande
  - `/restaurant_orders.php?action=validate&id=X` - Valider une commande
  - `/restaurant_orders.php?action=print&id=X` - Imprimer une commande

#### Module Cuisine
- `/kitchen_orders.php` - Commandes cuisine
  - `/kitchen_orders.php?action=show&id=X` - Voir une commande
  - `/kitchen_orders.php?action=update_status` - Mettre à jour le statut
- `/kitchen_stock_exits.php` - Sorties de stock cuisine

#### Module Caisse
- `/cash_register.php` - Gestion de la caisse
  - `/cash_register.php?action=open_session` - Ouvrir une session
  - `/cash_register.php?action=close_session&id=X` - Fermer une session
  - `/cash_register.php?action=show_session&id=X` - Voir une session
  - `/cash_register.php?action=create_transaction&session_id=X` - Créer une transaction
  - `/cash_register.php?action=session_recap&id=X` - Récapitulatif de session
  - `/cash_register.php?action=transaction_details` - Détails des transactions
  - `/cash_register.php?action=client_transaction_details` - Relevés de compte

#### Module Inventaire
- `/inventory.php` - Gestion de l'inventaire
  - `/inventory.php?action=create` - Créer un article
  - `/inventory.php?action=edit&id=X` - Modifier un article
  - `/inventory.php?action=show&id=X` - Voir un article
  - `/inventory.php?action=export_excel` - Exporter en Excel

#### Rapports
- `/reports.php?report=revenue` - Rapport chiffre d'affaires
- `/reports.php?report=occupation` - Rapport d'occupation
- `/reports.php?report=restaurant` - Rapport restauration
- `/reports.php?report=events` - Rapport événements
- `/reports.php?report=cancelled_transactions` - Transactions annulées

#### Administration
- `/users.php` - Gestion des utilisateurs
  - `/users.php?action=create` - Créer un utilisateur
  - `/users.php?action=edit&id=X` - Modifier un utilisateur
  - `/users.php?action=bulk_toggle` - Gestion en masse
- `/roles.php` - Gestion des rôles
  - `/roles.php?action=create` - Créer un rôle
  - `/roles.php?action=edit&id=X` - Modifier un rôle
- `/notifications.php` - Centre de notifications

### Configuration des Chemins

Tous les chemins utilisent des chemins relatifs basés sur `__DIR__` et `dirname(__DIR__)`, ce qui garantit la portabilité :

```php
// Exemple dans les contrôleurs
require_once __DIR__ . '/../config/config.php';
require_once __DIR__ . '/../models/User.php';
include __DIR__ . '/../views/users/index.php';
```

### Configuration des URLs

La fonction `getBaseUrl()` est utilisée partout pour générer les URLs. Elle lit la valeur de `APP_URL` définie dans `config.php` :

```php
// Dans config.php
define('APP_URL', 'https://votre-domaine.com');

// Utilisation dans le code
redirect(getBaseUrl() . '/login.php');
header('Location: ' . getBaseUrl() . '/dashboard_dynamic.php');
```

**Important pour la production** : Modifiez `APP_URL` dans `config/config.production.php` avec votre URL de production.

### Vérification des Accès

Chaque page vérifie :
1. **Authentification** : `isLoggedIn()`
2. **Permissions** : `hasPermission('permission.name')`
3. **Redirection** : Vers `/login.php` si non authentifié, vers `/error.php?code=403` si pas de permission

### Exemple de Structure de Route

```php
// Fichier : reservations.php
<?php
// 1. Configuration
require_once __DIR__ . '/config/session_config.php';
require_once __DIR__ . '/config/config.php';

// 2. Vérification authentification
if (!isLoggedIn()) {
    redirect(getBaseUrl() . '/login.php');
}

// 3. Vérification permissions
if (!hasPermission('bookings.view')) {
    redirect(getBaseUrl() . '/error.php?code=403');
}

// 4. Router les actions
$action = $_GET['action'] ?? 'index';
switch ($action) {
    case 'create':
        $controller->create();
        break;
    // ...
}
?>
```

---

## Configuration du Serveur

### Apache (.htaccess)

Créez ou modifiez le fichier `.htaccess` à la racine :

```apache
# Activer le moteur de réécriture
RewriteEngine On

# Rediriger vers HTTPS (recommandé)
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# Page d'accueil - Redirection vers index.php
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^$ index.php [L]

# Routes principales - Accès direct aux fichiers PHP
# Les fichiers PHP sont accessibles directement (pas de réécriture nécessaire)
# Exemples :
# - /login.php
# - /dashboard_dynamic.php
# - /reservations.php
# - /restaurant_orders.php
# - /cash_register.php
# - etc.

# Protéger les fichiers de configuration
<FilesMatch "^(database|config)\.production\.php$">
    Order allow,deny
    Deny from all
</FilesMatch>

# Protéger les fichiers sensibles
<FilesMatch "\.(log|sql|backup|env)$">
    Order allow,deny
    Deny from all
</FilesMatch>

# Protéger les dossiers sensibles
RedirectMatch 403 ^/config/.*\.production\.php$
RedirectMatch 403 ^/logs/.*
RedirectMatch 403 ^/backups/.*
RedirectMatch 403 ^/cache/.*
RedirectMatch 403 ^/vendor/.*
RedirectMatch 403 ^/database/.*\.sql$

# Désactiver l'affichage des répertoires
Options -Indexes

# Protection contre les injections
<IfModule mod_php7.c>
    php_flag display_errors Off
    php_flag log_errors On
    php_value error_log logs/php_errors.log
</IfModule>

# Compression GZIP
<IfModule mod_deflate.c>
    AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css text/javascript application/javascript application/json
</IfModule>

# Cache des fichiers statiques
<IfModule mod_expires.c>
    ExpiresActive On
    ExpiresByType image/jpg "access plus 1 year"
    ExpiresByType image/jpeg "access plus 1 year"
    ExpiresByType image/png "access plus 1 year"
    ExpiresByType image/gif "access plus 1 year"
    ExpiresByType image/svg+xml "access plus 1 year"
    ExpiresByType text/css "access plus 1 month"
    ExpiresByType application/javascript "access plus 1 month"
    ExpiresByType application/pdf "access plus 1 month"
</IfModule>

# Headers de sécurité
<IfModule mod_headers.c>
    # Protection XSS
    Header set X-XSS-Protection "1; mode=block"
    # Protection contre le clickjacking
    Header set X-Frame-Options "SAMEORIGIN"
    # Protection MIME type sniffing
    Header set X-Content-Type-Options "nosniff"
    # Politique de référent
    Header set Referrer-Policy "strict-origin-when-cross-origin"
</IfModule>
```

### Nginx

Si vous utilisez Nginx, ajoutez dans votre configuration :

```nginx
server {
    listen 80;
    server_name votre-domaine.com;
    
    # Redirection HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name votre-domaine.com;
    
    root /chemin/vers/StayManager;
    index index.php;
    
    # SSL Configuration
    ssl_certificate /chemin/vers/certificat.crt;
    ssl_certificate_key /chemin/vers/cle.privee;
    
    # Protection des fichiers sensibles
    location ~ ^/(config|database)\.production\.php$ {
        deny all;
    }
    
    location ~ \.(log|sql|backup|env)$ {
        deny all;
    }
    
    # Protection des dossiers sensibles
    location ~ ^/(logs|backups|cache|vendor|database)/ {
        deny all;
    }
    
    # Routes principales - Accès direct aux fichiers PHP
    # Tous les fichiers .php sont accessibles directement
    # Exemples :
    # - /login.php
    # - /dashboard_dynamic.php
    # - /reservations.php?action=create
    # - /restaurant_orders.php?action=show&id=1
    
    # PHP-FPM
    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.0-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
        
        # Sécurité supplémentaire
        fastcgi_param PHP_VALUE "display_errors=Off";
        fastcgi_param PHP_VALUE "log_errors=On";
        fastcgi_param PHP_VALUE "error_log=/chemin/vers/StayManager/logs/php_errors.log";
    }
    
    # Page d'accueil
    location = / {
        try_files $uri $uri/ /index.php;
    }
    
    # Fichiers statiques
    location ~* \.(jpg|jpeg|png|gif|css|js|svg|woff|woff2|ttf|eot)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        access_log off;
    }
    
    # Headers de sécurité
    add_header X-XSS-Protection "1; mode=block" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
    
    # Désactiver l'affichage des répertoires
    autoindex off;
}
```

---

## Sécurité

### Checklist de Sécurité

- [ ] **HTTPS activé** : Utilisez un certificat SSL (Let's Encrypt gratuit)
- [ ] **Mode debug désactivé** : `DEBUG_MODE = false`
- [ ] **Erreurs masquées** : `DISPLAY_ERRORS = false`
- [ ] **Clé JWT changée** : Utilisez une clé unique et forte
- [ ] **Mots de passe forts** : Base de données et utilisateurs
- [ ] **Fichiers de config protégés** : `.htaccess` ou règles Nginx
- [ ] **Permissions correctes** : Dossiers 755, fichiers 644
- [ ] **Backups réguliers** : Automatisez les sauvegardes
- [ ] **Mises à jour** : PHP, MySQL, et extensions

---

## Vérification Post-Déploiement

### Tests à Effectuer

1. **Test de connexion** :
   - Accédez à `https://votre-domaine.com/login.php`
   - Connectez-vous avec un compte admin
   - Vérifiez la redirection vers le dashboard

2. **Test des routes principales** :
   - ✅ `/index.php` → Redirige vers login ou dashboard
   - ✅ `/login.php` → Page de connexion accessible
   - ✅ `/dashboard_dynamic.php` → Dashboard accessible après connexion
   - ✅ `/reservations.php` → Liste des réservations
   - ✅ `/reservations.php?action=create` → Formulaire de création
   - ✅ `/clients.php` → Liste des clients
   - ✅ `/rooms.php` → Liste des chambres
   - ✅ `/restaurant_orders.php` → Liste des commandes
   - ✅ `/cash_register.php` → Gestion de la caisse
   - ✅ `/inventory.php` → Gestion de l'inventaire
   - ✅ `/users.php` → Gestion des utilisateurs
   - ✅ `/reports.php?report=revenue` → Rapports

3. **Test des permissions** :
   - Testez avec différents rôles utilisateurs
   - Vérifiez que les accès sont correctement restreints
   - Vérifiez que les erreurs 403 s'affichent correctement

4. **Test des chemins et URLs** :
   - Vérifiez que tous les liens dans le menu fonctionnent
   - Vérifiez que les redirections utilisent bien HTTPS
   - Vérifiez que les assets (CSS, JS, images) se chargent correctement
   - Vérifiez que les chemins relatifs fonctionnent

5. **Vérification des erreurs** :
   - Consultez les logs : `logs/error_YYYY-MM-DD.log`
   - Consultez les logs PHP : `logs/php_errors.log`
   - Vérifiez qu'aucune erreur n'apparaît dans la console du navigateur
   - Vérifiez que les erreurs ne s'affichent pas à l'utilisateur (mode production)

6. **Test de performance** :
   - Vérifiez les temps de chargement
   - Testez avec plusieurs utilisateurs simultanés
   - Vérifiez que le cache fonctionne
   - Vérifiez la compression GZIP

7. **Test de sécurité** :
   - Vérifiez que les fichiers de config ne sont pas accessibles
   - Vérifiez que les logs ne sont pas accessibles
   - Vérifiez que HTTPS est bien activé
   - Vérifiez les headers de sécurité

---

## Maintenance

### Sauvegardes

Configurez des sauvegardes automatiques :

1. **Base de données** : Quotidienne
2. **Fichiers** : Hebdomadaire
3. **Logs** : Archivage mensuel

### Mises à jour

1. **PHP** : Maintenez PHP à jour (version 8.0+)
2. **MySQL** : Mettez à jour régulièrement
3. **Application** : Suivez les mises à jour de sécurité

### Monitoring

- Surveillez les logs d'erreur
- Surveillez l'espace disque
- Surveillez les performances

---

## Variables d'Environnement (Optionnel)

Pour une meilleure sécurité, vous pouvez utiliser des variables d'environnement :

1. Créez un fichier `.env` à la racine (non versionné) :
```
APP_ENV=production
DB_HOST=votre_serveur_mysql
DB_NAME=staymanager_prod
DB_USER=staymanager_user
DB_PASS=votre_mot_de_passe
APP_URL=https://votre-domaine.com
JWT_SECRET=votre_cle_secrete
```

2. Modifiez `config/database.php` pour lire ces variables :
```php
private $host = getenv('DB_HOST') ?: 'localhost';
private $db_name = getenv('DB_NAME') ?: 'staymanager_db';
private $username = getenv('DB_USER') ?: 'root';
private $password = getenv('DB_PASS') ?: '';
```

---

## Support

Pour toute question ou problème lors du déploiement :
- Consultez les logs : `logs/error_*.log`
- Vérifiez la configuration de la base de données
- Vérifiez les permissions des fichiers et dossiers
- Contactez votre hébergeur si nécessaire

---

**Document généré automatiquement**  
**StayManager v1.0**  
**Novembre 2025**

