# Architecture du Projet Taskio

## Vue d'ensemble

Taskio est une application web de gestion de projets construite avec une architecture MVC (Model-View-Controller) en PHP pur, sans framework externe. L'application suit les principes SOLID et utilise des patterns de conception modernes.

## Structure des dossiers

```
Taskio/
├── app/
│   ├── Controllers/          # Contrôleurs de l'application
│   │   ├── Api/             # Contrôleurs API REST
│   │   ├── AuthController.php
│   │   ├── DashboardController.php
│   │   ├── ProjectController.php
│   │   ├── TaskController.php
│   │   ├── SubtaskController.php
│   │   ├── CommentController.php
│   │   ├── CalendarController.php
│   │   ├── NotificationController.php
│   │   └── ProfileController.php
│   │
│   ├── Core/                # Classes du framework MVC
│   │   ├── Autoloader.php   # Autoloader PSR-4
│   │   ├── Router.php       # Système de routage
│   │   ├── Controller.php   # Contrôleur de base
│   │   ├── Model.php        # Modèle Active Record
│   │   └── Database.php     # Connexion PDO (Singleton)
│   │
│   ├── Models/              # Modèles de données
│   │   ├── User.php
│   │   ├── Project.php
│   │   ├── Task.php
│   │   ├── Subtask.php
│   │   ├── Comment.php
│   │   ├── Notification.php
│   │   └── ActivityLog.php
│   │
│   └── Views/               # Vues (templates PHP)
│       ├── layouts/
│       │   └── main.php
│       ├── auth/
│       ├── dashboard/
│       ├── projects/
│       ├── tasks/
│       ├── calendar/
│       ├── notifications/
│       ├── profile/
│       └── errors/
│
├── config/
│   └── config.php           # Configuration globale
│
├── cron/
│   └── check_due_tasks.php  # Tâches planifiées
│
├── database/
│   └── schema.sql           # Schéma et données initiales
│
├── public/                  # Dossier public (DocumentRoot)
│   ├── index.php           # Point d'entrée
│   ├── .htaccess           # Configuration Apache
│   ├── manifest.json       # Manifest PWA
│   ├── sw.js              # Service Worker
│   └── assets/            # Assets statiques
│       ├── icons/
│       ├── images/
│       └── uploads/
│
├── ARCHITECTURE.md         # Ce fichier
├── INSTALLATION.md         # Guide d'installation
├── readme.md              # Cahier des charges
└── cahier_de_charge.md   # Spécifications détaillées
```

## Architecture MVC

### 1. **Model (Modèle)**

Les modèles héritent de la classe `Core\Model` qui implémente le pattern Active Record.

**Fonctionnalités:**
- CRUD complet (Create, Read, Update, Delete)
- Relations entre modèles
- Validation des données
- Méthodes métier spécifiques

**Exemple:**
```php
class Task extends Model {
    protected $table = 'tasks';
    protected $fillable = ['title', 'description', 'project_id', ...];
    
    public function project() {
        return $this->belongsTo(Project::class, 'project_id');
    }
}
```

### 2. **View (Vue)**

Les vues sont des templates PHP simples avec échappement HTML.

**Fonctionnalités:**
- Layout principal réutilisable
- Composants modulaires
- Support de Tailwind CSS
- Intégration Alpine.js pour l'interactivité
- Icons Lucide

**Exemple:**
```php
<!-- app/Views/tasks/index.php -->
<h1><?= htmlspecialchars($pageTitle) ?></h1>
<?php foreach ($tasks as $task): ?>
    <div><?= htmlspecialchars($task->title) ?></div>
<?php endforeach; ?>
```

### 3. **Controller (Contrôleur)**

Les contrôleurs héritent de `Core\Controller` et orchestrent la logique.

**Fonctionnalités:**
- Gestion des requêtes HTTP
- Validation des données
- Authentification/Autorisation
- Rendu des vues
- Réponses JSON pour API

**Exemple:**
```php
class TaskController extends Controller {
    public function index() {
        $this->requireAuth();
        $tasks = Task::where('assigned_to', $_SESSION['user_id'])->get();
        return $this->view('tasks/index', compact('tasks'));
    }
}
```

## Patterns de Conception

### 1. **Singleton (Database)**

La connexion PDO utilise le pattern Singleton pour éviter les connexions multiples.

```php
$db = Database::getInstance();
```

### 2. **Active Record (Models)**

Les modèles encapsulent la logique de base de données.

```php
$task = Task::find(1);
$task->title = 'Nouveau titre';
$task->save();
```

### 3. **Front Controller (Router)**

Un point d'entrée unique (`public/index.php`) route toutes les requêtes.

```php
$router->get('/tasks', 'TaskController@index');
$router->post('/tasks/store', 'TaskController@store');
```

### 4. **Factory (Flash Messages)**

Les messages flash sont créés via des méthodes factory.

```php
$this->flash('success', 'Tâche créée avec succès!');
```

## Flux de données

### Requête HTTP typique:

```
1. Client → public/index.php
2. index.php → Router
3. Router → Controller approprié
4. Controller → Model (récupération données)
5. Model → Database (requête SQL)
6. Database → Model (résultats)
7. Model → Controller (objets)
8. Controller → View (rendu)
9. View → Client (HTML)
```

### Requête API:

```
1. Client (AJAX) → /api/tasks/status
2. Router → Api\TaskController
3. Controller → Model (mise à jour)
4. Controller → JSON response
5. Client (AJAX) → Mise à jour interface
```

## Base de données

### Schéma relationnel:

```
users (1) ←→ (N) projects
projects (1) ←→ (N) tasks
tasks (1) ←→ (N) subtasks
tasks (1) ←→ (N) comments
users (1) ←→ (N) notifications
```

### Tables principales:

- **users**: Utilisateurs (admin/partner)
- **projects**: Projets avec statut et dates
- **tasks**: Tâches avec priorité, statut, assignation
- **subtasks**: Sous-tâches liées aux tâches
- **comments**: Commentaires sur les tâches
- **notifications**: Notifications push/email
- **activity_logs**: Journal des activités

## Sécurité

### Mesures implémentées:

1. **Authentification:**
   - Hachage des mots de passe (password_hash)
   - Sessions sécurisées
   - Tokens de réinitialisation

2. **Protection CSRF:**
   - Tokens dans les formulaires (à implémenter si nécessaire)

3. **Injections SQL:**
   - PDO avec requêtes préparées
   - Paramètres bindés

4. **XSS:**
   - htmlspecialchars() sur toutes les sorties
   - Validation des entrées

5. **Autorisation:**
   - Middleware d'authentification
   - Vérification des permissions

## API REST

### Endpoints disponibles:

```
GET    /api/tasks/status        - Récupérer le statut
POST   /api/tasks/status        - Modifier le statut
POST   /api/tasks/order         - Modifier l'ordre (Kanban)
GET    /api/notifications/count - Compter non lues
GET    /api/projects/progress   - Progression d'un projet
```

### Format de réponse:

```json
{
    "success": true,
    "data": {...},
    "message": "Opération réussie"
}
```

## Progressive Web App (PWA)

### Composants:

1. **Manifest (`manifest.json`):**
   - Configuration de l'application installable
   - Icônes multiples résolutions
   - Shortcuts vers fonctions clés

2. **Service Worker (`sw.js`):**
   - Cache des assets
   - Fonctionnement offline
   - Push notifications
   - Background sync

3. **Installation:**
   - Détection automatique
   - Prompt d'installation personnalisé
   - Support iOS/Android

## Performance

### Optimisations:

1. **Frontend:**
   - CDN pour Tailwind/Alpine.js/Lucide
   - Lazy loading des images
   - Cache du service worker

2. **Backend:**
   - Requêtes SQL optimisées avec index
   - Connexion PDO persistante
   - Pagination des résultats

3. **Base de données:**
   - Index sur clés étrangères
   - Index sur colonnes fréquemment recherchées

## Évolutivité

### Extensions possibles:

1. **Features:**
   - Upload de fichiers
   - Graphiques/statistiques avancés
   - Export PDF/Excel
   - Intégration calendrier externe
   - Chat en temps réel (WebSocket)

2. **Technique:**
   - Migration vers framework (Laravel, Symfony)
   - API REST complète avec versioning
   - Tests automatisés (PHPUnit)
   - CI/CD (GitHub Actions)
   - Docker pour déploiement

3. **Infrastructure:**
   - Redis pour cache et sessions
   - Queue pour jobs asynchrones
   - CDN pour assets statiques
   - Load balancer pour scaling

## Maintenance

### Logs:

- Logs cron: `/logs/cron.log`
- Logs Apache/Nginx: configuration serveur
- Logs applicatifs: à implémenter avec Monolog si nécessaire

### Monitoring:

- Surveillance des tâches cron
- Monitoring base de données
- Alertes en cas d'erreur critique

### Mises à jour:

1. Sauvegarder base de données
2. Appliquer migrations si nécessaire
3. Mettre à jour fichiers
4. Tester en staging
5. Déployer en production
6. Vider caches

## Conventions de code

### PSR-4 Autoloading:

```
App\Controllers\TaskController → app/Controllers/TaskController.php
App\Models\Task → app/Models/Task.php
```

### Nommage:

- Classes: PascalCase (`TaskController`)
- Méthodes: camelCase (`createTask`)
- Variables: camelCase (`$taskList`)
- Constantes: UPPER_SNAKE_CASE (`BASE_URL`)
- Tables DB: snake_case (`activity_logs`)

### Documentation:

- Docblocks pour classes et méthodes publiques
- Commentaires pour logique complexe
- README pour chaque module si nécessaire