README

Un framework PHP moderne et léger suivant le pattern MVC avec injection de dépendances, gestion des sessions, validation des données et bien plus.

Fonctionnalités

• Architecture MVC : Organisation claire du code avec séparation des responsabilités
• Injection de dépendances : Container IoC avec configuration YAML
• Routing système : Routage simple et efficace avec support des middlewares
• Base de données : Couche d'abstraction PDO avec pattern Singleton
• Validation : Système de validation robuste avec règles personnalisables
• Gestion d'images : Upload et gestion d'images avec génération d'URLs
• Sessions : Wrapper simplifié pour la gestion des sessions PHP
• Middlewares : Support des middlewares pour l'authentification et autres traitements
• Pattern Repository : Abstraction de la couche de données

Installation

Via Composer

composer install votre-vendor/votre-framework

Installation manuelle

1. Clonez le repository

git clone https://github.com/votre-username/votre-framework.git

1. Installez les dépendances

composer install

1. Configurez votre environnement (voir Configuration)

⚙️ Configuration

1. Configuration de la base de données

Créez vos constantes de base de données dans votre fichier de configuration :

// config/database.php
define('DSN', 'mysql:host=localhost;dbname=votre_db');
define('DB_USER', 'votre_username');
define('DB_PASSWORD', 'votre_password');

2. Configuration des services (services.yml)

Créez un fichier config/services.yml pour définir vos dépendances :

# config/services.yml
core:
  database: App\Core\Database
  session: App\Core\Session
  validator: App\Core\Validator
  imageService: App\Core\ImageService

repositories:
  userRepository: App\Repository\UserRepository
  productRepository: App\Repository\ProductRepository

controllers:
  userController: App\Controller\UserController
  productController: App\Controller\ProductController

3. Configuration des constantes

// config/constants.php
define('APP_URL', 'http://localhost:8000');
define('IMG_DIR', '/public/images/uploads/');

🏗️ Structure du projet

project/
├── app/
│   ├── config/
│   │   ├── services.yml
│   │   ├── middlewares.php
│   │   └── routes.php
│   ├── src/
│   │   ├── Core/
│   │   │   ├── App.php
│   │   │   ├── Database.php
│   │   │   ├── Router.php
│   │   │   ├── Session.php
│   │   │   ├── Validator.php
│   │   │   └── ImageService.php
│   │   ├── Abstract/
│   │   │   ├── AbstractController.php
│   │   │   ├── AbstractEntity.php
│   │   │   └── AbstractRepository.php
│   │   ├── Controller/
│   │   ├── Entity/
│   │   ├── Repository/
│   │   └── Middlewares/
│   └── templates/
├── public/
│   ├── index.php
│   └── images/uploads/
└── composer.json

Utilisation

1. Initialisation de l'application

// public/index.php
<?php
require_once '../vendor/autoload.php';
use App\Core\App;
use App\Core\Router;

// Initialiser l'application
App::init();

// Définir les routes
$routes = [
    '/' => [
        'controller' => 'App\Controller\HomeController',
        'method' => 'index',
        'middlewares' => []
    ],
    '/login' => [
        'controller' => 'App\Controller\AuthController',
        'method' => 'login',
        'middlewares' => []
    ],
    '/dashboard' => [
        'controller' => 'App\Controller\DashboardController',
        'method' => 'index',
        'middlewares' => ['auth']
    ]
];

// Résoudre la route
Router::resolve($routes);

2. Création d'un contrôleur

<?php
namespace App\Controller;

use App\Core\Abstract\AbstractController;
use App\Core\App;

class UserController extends AbstractController
{
    private $userRepository;

    public function __construct()
    {
        parent::__construct();
        $this->userRepository = App::getDependency('userRepository');
    }

    public function index()
    {
        $users = $this->userRepository->selectAll();
        $this->render('users/index.php', ['users' => $users]);
    }

    public function create()
    {
        $this->render('users/create.php');
    }

    public function store()
    {
        $validator = App::getDependency('validator');
        
        $rules = [
            'name' => [['required', 'Le nom est requis']],
            'email' => [['required', 'L\'email est requis'], ['isMail', 'Email invalide']],
            'password' => [['required', 'Le mot de passe est requis'], ['isPassword', 'Mot de passe trop faible']]
        ];

        if ($validator->validate($_POST, $rules)) {
            $this->userRepository->insert($_POST);
            header('Location: /users');
        } else {
            $errors = $validator->getErrors();
            $this->render('users/create.php', ['errors' => $errors]);
        }
    }

    public function show() { /* Implementation */ }
    public function edit() { /* Implementation */ }
}

3. Création d'une entité

<?php
namespace App\Entity;

use App\Core\Abstract\AbstractEntity;

class User extends AbstractEntity
{
    private int $id;
    private string $name;
    private string $email;
    private string $password;

    public function __construct(int $id = 0, string $name = '', string $email = '', string $password = '')
    {
        $this->id = $id;
        $this->name = $name;
        $this->email = $email;
        $this->password = $password;
    }

    public static function toObject(array $data): static
    {
        return new self(
            $data['id'] ?? 0,
            $data['name'] ?? '',
            $data['email'] ?? '',
            $data['password'] ?? ''
        );
    }

    public function toArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'password' => $this->password
        ];
    }

    // Getters et setters...
    public function getId(): int { return $this->id; }
    public function getName(): string { return $this->name; }
    public function getEmail(): string { return $this->email; }
    // ...
}

4. Création d'un repository

<?php
namespace App\Repository;

use App\Core\Abstract\AbstractRepository;
use App\Entity\User;

class UserRepository extends AbstractRepository
{
    public function selectAll(): array
    {
        $stmt = $this->pdo->query("SELECT * FROM users");
        $users = [];
        
        while ($userData = $stmt->fetch()) {
            $users[] = User::toObject($userData);
        }
        
        return $users;
    }

    public function insert(array $data): bool
    {
        $sql = "INSERT INTO users (name, email, password) VALUES (:name, :email, :password)";
        $stmt = $this->pdo->prepare($sql);
        
        return $stmt->execute([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => $data['password']
        ]);
    }

    public function selectById($id): ?User
    {
        $sql = "SELECT * FROM users WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['id' => $id]);
        
        $userData = $stmt->fetch();
        return $userData ? User::toObject($userData) : null;
    }

    public function selectBy(array $filter): array
    {
        // Implementation selon vos besoins
        return [];
    }

    public function update() { /* Implementation */ }
    public function delete() { /* Implementation */ }
}

5. Validation des données

use App\Core\App;

$validator = App::getDependency('validator');

$rules = [
    'name' => [['required', 'Le nom est obligatoire'], ['minLength', 3, 'Minimum 3 caractères']],
    'email' => [['required', 'Email requis'], ['isMail', 'Format email invalide']],
    'password' => [['required', 'Mot de passe requis'], ['isPassword', 'Mot de passe trop faible']],
    'phone' => [['isSenegalPhone', 'Numéro de téléphone sénégalais invalide']],
    'cni' => [['isCNI', 'Numéro CNI invalide']]
];

if ($validator->validate($_POST, $rules)) {
    // Données valides
    echo "Validation réussie !";
} else {
    // Récupérer les erreurs
    $errors = $validator->getErrors();
    foreach ($errors as $field => $error) {
        echo "$field: $error\n";
    }
}

6. Gestion des sessions

use App\Core\Session;

// Démarrer une session (automatique avec le router)
Session::set('user', ['id' => 1, 'name' => 'John Doe']);

// Récupérer une valeur de session
$userId = Session::get('user', 'id');

// Vérifier si une clé existe
if (Session::isset('user')) {
    echo "Utilisateur connecté";
}

// Supprimer une clé
Session::unset('user');

// Détruire la session
Session::destroy();

7. Upload d'images

use App\Core\ImageService;

// Upload d'une seule image
try {
    $result = ImageService::uploadImage(
        $_FILES['image'], 
        '/public/images/uploads/',
        ['jpg', 'jpeg', 'png', 'gif']
    );
    
    echo "Image uploadée : " . $result['url'];
    
} catch (Exception $e) {
    echo "Erreur : " . $e->getMessage();
}

// Upload multiple (dans un contrôleur)
$photoData = $this->uploadPhotos($_FILES);
if ($photoData) {
    $photos = json_decode($photoData, true);
    echo "Recto : " . $photos['recto'];
    echo "Verso : " . $photos['verso'];
}

8. Middlewares

// config/middlewares.php
function runMiddleWare(array $middlewares) {
    $middlewareMap = [
        'auth' => App\Core\Middlewares\Auth::class,
        'cryptPassword' => App\Core\Middlewares\CryptPassword::class
    ];

    foreach ($middlewares as $middleware) {
        if (isset($middlewareMap[$middleware])) {
            $middlewareInstance = new $middlewareMap[$middleware]();
            $middlewareInstance();
        }
    }
}

Créer un middleware personnalisé :

<?php
namespace App\Core\Middlewares;

class CustomMiddleware
{
    public function __invoke()
    {
        // Votre logique de middleware
        if (!condition()) {
            header('Location: /error');
            exit();
        }
    }
}

Règles de validation disponibles

• required : Champ obligatoire
• minLength : Longueur minimale
• isMail : Format email valide
• isPassword : Mot de passe fort (8+ caractères, majuscule, minuscule, chiffre, caractère spécial)
• isSenegalPhone : Numéro de téléphone sénégalais (70, 75, 76, 77, 78)
• isCNI : Numéro de CNI sénégalais

Sécurité

• Utilisation de requêtes préparées (PDO)
• Hashage automatique des mots de passe
• Protection CSRF (à implémenter selon vos besoins)
• Validation stricte des données d'entrée
• Gestion sécurisée des uploads de fichiers

Contribution

1. Fork le projet
2. Créez votre branche feature (git checkout -b feature/AmazingFeature)
3. Committez vos changements (git commit -m 'Add some AmazingFeature')
4. Push vers la branche (git push origin feature/AmazingFeature)
5. Ouvrez une Pull Request

Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

📞 Support

• Documentation : [Lien vers votre documentation]
• Issues : [Lien vers les issues GitHub]
• Email : votre-email@example.com

🔄 Changelog

v1.0.0

• Release initiale
• Architecture MVC complète
• Système d'injection de dépendances
• Validation des données
• Gestion des sessions et images
• Support des middlewares

Développé avec pour la communauté PHPf_