auto-sync-opus46
This commit is contained in:
opus
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"generated": "2026-04-16 22:50:02",
|
||||
"generated": "2026-04-16 22:55:02",
|
||||
"version": "1.0",
|
||||
"servers": [
|
||||
{
|
||||
@@ -10,7 +10,7 @@
|
||||
"ssh": 49222,
|
||||
"disk_pct": 84,
|
||||
"disk_avail": "24G",
|
||||
"uptime": "up 2 days, 12 hours, 58 minutes",
|
||||
"uptime": "up 2 days, 13 hours, 3 minutes",
|
||||
"nginx": "active",
|
||||
"php_fpm": "active",
|
||||
"php_version": "8.5.5"
|
||||
@@ -76,7 +76,7 @@
|
||||
},
|
||||
{
|
||||
"name": "twenty",
|
||||
"status": "Up 12 hours",
|
||||
"status": "Up 13 hours",
|
||||
"ports": ""
|
||||
},
|
||||
{
|
||||
@@ -301,7 +301,7 @@
|
||||
"langfuse"
|
||||
],
|
||||
"key_tables": {
|
||||
"kb_learnings": 5121,
|
||||
"kb_learnings": 5122,
|
||||
"kb_documents": 0,
|
||||
"ethica_medecins": 50004,
|
||||
"enterprise_agents": 0
|
||||
@@ -359,7 +359,7 @@
|
||||
},
|
||||
{
|
||||
"name": "wevia_memory_768",
|
||||
"vectors": 7
|
||||
"vectors": 8
|
||||
},
|
||||
{
|
||||
"name": "wevia_kb_768",
|
||||
@@ -543,7 +543,7 @@
|
||||
]
|
||||
},
|
||||
"wiki": {
|
||||
"total_entries": 5121,
|
||||
"total_entries": 5122,
|
||||
"categories": [
|
||||
{
|
||||
"category": "AUTO-FIX",
|
||||
@@ -551,7 +551,7 @@
|
||||
},
|
||||
{
|
||||
"category": "TOPOLOGY",
|
||||
"cnt": "972"
|
||||
"cnt": "973"
|
||||
},
|
||||
{
|
||||
"category": "DISCOVERY",
|
||||
@@ -1651,9 +1651,9 @@
|
||||
"fast_lines": 3620,
|
||||
"router_lines": 6152,
|
||||
"router_functions": 17,
|
||||
"today_requests": 6,
|
||||
"today_requests": 7,
|
||||
"today_cost": 0,
|
||||
"avg_latency_ms": 2729,
|
||||
"avg_latency_ms": 2809,
|
||||
"top_provider": "cerebras",
|
||||
"providers_used": 2
|
||||
},
|
||||
@@ -1878,7 +1878,7 @@
|
||||
"fixes_log": [],
|
||||
"recommendations": []
|
||||
},
|
||||
"scan_time_ms": 1262,
|
||||
"scan_time_ms": 761,
|
||||
"gaps": [],
|
||||
"score": 100,
|
||||
"automation": {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"ts": "2026-04-16T22:50:04+00:00",
|
||||
"ts": "2026-04-16T22:57:11+00:00",
|
||||
"hostname": "blade",
|
||||
"cpu": "?",
|
||||
"ram": "?",
|
||||
|
||||
@@ -13,5 +13,5 @@
|
||||
"Run simulation",
|
||||
"CEO insights"
|
||||
],
|
||||
"timestamp": "2026-04-16 22:50:03"
|
||||
"timestamp": "2026-04-16 22:55:02"
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
19634
api/screens-health.json.pre-phantom-20260417-005457
Normal file
19634
api/screens-health.json.pre-phantom-20260417-005457
Normal file
File diff suppressed because it is too large
Load Diff
19634
api/screens-health.json.pre-phantom-20260417-005504
Normal file
19634
api/screens-health.json.pre-phantom-20260417-005504
Normal file
File diff suppressed because it is too large
Load Diff
19634
api/screens-health.json.pre-phantom-20260417-005555
Normal file
19634
api/screens-health.json.pre-phantom-20260417-005555
Normal file
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"ts": "2026-04-16 22:49:51",
|
||||
"ts": "2026-04-16 22:55:07",
|
||||
"r": {
|
||||
"reconcile": "OK",
|
||||
"nonreg": "NONREG: 153\/153 (100%)",
|
||||
@@ -7,7 +7,8 @@
|
||||
"docker": 19,
|
||||
"disk": 84,
|
||||
"hubs": 29,
|
||||
"dirty": 0,
|
||||
"dirty": 24,
|
||||
"pushed": true,
|
||||
"alerts": [
|
||||
"CLEAR"
|
||||
]
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
{
|
||||
"timestamp": "2026-04-17 00:45:09",
|
||||
"healthy": false,
|
||||
"issues": [
|
||||
"Chatbot check error: Expecting value: line 1 column 1 (char 0)"
|
||||
],
|
||||
"timestamp": "2026-04-17 00:55:04",
|
||||
"healthy": true,
|
||||
"issues": [],
|
||||
"fixes": [],
|
||||
"issues_count": 1,
|
||||
"issues_count": 0,
|
||||
"fixes_count": 0
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"timestamp": "2026-04-16 22:45:08",
|
||||
"timestamp": "2026-04-16 22:55:08",
|
||||
"healthy": false,
|
||||
"checks": {
|
||||
"outpost": "DOWN",
|
||||
@@ -19,7 +19,7 @@
|
||||
"docker:authentik-worker": "NOT_FOUND",
|
||||
"docker:authentik-db": "NOT_FOUND",
|
||||
"docker:authentik-redis": "NOT_FOUND",
|
||||
"open_ports": 65,
|
||||
"open_ports": 66,
|
||||
"nginx": "OK"
|
||||
},
|
||||
"flow_ok": 2,
|
||||
@@ -30,62 +30,62 @@
|
||||
{
|
||||
"level": "critical",
|
||||
"msg": "Outpost DOWN 9090",
|
||||
"ts": "2026-04-16T22:45:01+00:00"
|
||||
"ts": "2026-04-16T22:55:01+00:00"
|
||||
},
|
||||
{
|
||||
"level": "critical",
|
||||
"msg": "Outpost STILL DOWN",
|
||||
"ts": "2026-04-16T22:45:06+00:00"
|
||||
"ts": "2026-04-16T22:55:06+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow wevads.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:06+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow ethica.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:06+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow n8n.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow crm.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow mm.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow analytics.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Auth flow deerflow.weval-consulting.com: 200",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Callback location missing in nginx",
|
||||
"ts": "2026-04-16T22:45:07+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
}
|
||||
],
|
||||
"fixes": [
|
||||
{
|
||||
"title": "Restart authentik",
|
||||
"ts": "2026-04-16T22:45:01+00:00"
|
||||
"ts": "2026-04-16T22:55:01+00:00"
|
||||
},
|
||||
{
|
||||
"title": "Callback location auto-added",
|
||||
"ts": "2026-04-16T22:45:08+00:00"
|
||||
"ts": "2026-04-16T22:55:07+00:00"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -111,6 +111,20 @@ if ($__fp_input && isset($__fp_input["message"])) {
|
||||
if ($include) $__orch_tools[] = ["name"=>$name, "cmd"=>$spec["cmd"], "timeout"=>$spec["timeout"] ?? 25];
|
||||
}
|
||||
|
||||
|
||||
// === DYNAMIC AGENT FALLBACK (reconcile fix: dynamic_multiagent) ===
|
||||
// If user asks for action verbs but no agent matched beyond defaults
|
||||
$__action_verbs = preg_match('/(cr[eé]e|modifi|branch|fix|install|d[eé]ploi|patch|inject|ajoute|supprime|configure|wire|connect|link|symlink)/i', $__orch_msg);
|
||||
if ($__action_verbs) {
|
||||
// Add a dynamic "exec_request" agent that describes what was asked
|
||||
$__safe_msg = substr(preg_replace('/[^a-zA-Z0-9 _-]/', '', $__orch_msg), 0, 200);
|
||||
$__orch_tools[] = [
|
||||
"name" => "dynamic_exec",
|
||||
"cmd" => "echo 'DYNAMIC_AGENT: User requested action: " . addslashes($__safe_msg) . "'; echo 'STATUS: This requires manual wiring or a staged script. Use /tmp/ to stage scripts then run.'",
|
||||
"timeout" => 10
|
||||
];
|
||||
}
|
||||
// === END DYNAMIC AGENT FALLBACK ===
|
||||
echo "data: " . json_encode(["type"=>"answer","text"=>"### plan\n".count($__orch_tools)." agents: ".implode(", ", array_column($__orch_tools, "name")),"engine"=>"Orchestrator/plan","intent"=>"multi_agent"]) . "\n\n";
|
||||
flush();
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"timestamp": "2026-04-16 22:50:01",
|
||||
"timestamp": "2026-04-16 22:55:01",
|
||||
"version": "1.0",
|
||||
"disk": 84,
|
||||
"ram": 28,
|
||||
@@ -14,26 +14,26 @@
|
||||
{
|
||||
"level": "critical",
|
||||
"msg": "S204:authentik DOWN (:9090)",
|
||||
"time": "22:50:01"
|
||||
"time": "22:55:01"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Token : expired",
|
||||
"time": "22:50:03"
|
||||
"time": "22:55:02"
|
||||
},
|
||||
{
|
||||
"level": "warning",
|
||||
"msg": "Token : expired",
|
||||
"time": "22:50:03"
|
||||
"time": "22:55:02"
|
||||
}
|
||||
],
|
||||
"log": [
|
||||
"22:50:01 Disk: 84%",
|
||||
"22:50:01 SSL: 353d remaining",
|
||||
"22:50:01 Docker: 19 containers",
|
||||
"22:50:01 Ollama: 5 models, 5.2GB",
|
||||
"22:50:01 RAM: 28%",
|
||||
"22:50:03 Arch score: 100\/100"
|
||||
"22:55:01 Disk: 84%",
|
||||
"22:55:01 SSL: 353d remaining",
|
||||
"22:55:01 Docker: 19 containers",
|
||||
"22:55:01 Ollama: 5 models, 5.2GB",
|
||||
"22:55:01 RAM: 28%",
|
||||
"22:55:02 Arch score: 100\/100"
|
||||
],
|
||||
"s204_services": 8,
|
||||
"s95_mta": 5
|
||||
|
||||
@@ -1 +1 @@
|
||||
{"ts":"00:50","status":"offline"}
|
||||
{"ts":"00:56","status":"offline"}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"timestamp": "2026-04-16 22:45:07",
|
||||
"timestamp": "2026-04-16 22:55:07",
|
||||
"frameworks": [
|
||||
{
|
||||
"name": "Lean Six Sigma",
|
||||
@@ -46,7 +46,7 @@
|
||||
{
|
||||
"name": "Change Mgmt",
|
||||
"ok": true,
|
||||
"detail": "2490 commits\/7d"
|
||||
"detail": "2495 commits\/7d"
|
||||
},
|
||||
{
|
||||
"name": "SLA Monitor",
|
||||
@@ -153,7 +153,7 @@
|
||||
{
|
||||
"name": "CI\/CD",
|
||||
"ok": true,
|
||||
"detail": "2490 commits"
|
||||
"detail": "2495 commits"
|
||||
},
|
||||
{
|
||||
"name": "Auto testing",
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"timestamp": "2026-04-16 22:45:23",
|
||||
"timestamp": "2026-04-16 22:55:22",
|
||||
"healthy": false,
|
||||
"global_pass": 292,
|
||||
"global_fail": 2,
|
||||
|
||||
@@ -1 +1 @@
|
||||
{"ts": "00:50", "status": "ok"}
|
||||
{"ts": "00:55", "status": "ok"}
|
||||
@@ -1,167 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP pour une API REST complète en utilisant les technologies PHP 8.5, PostgreSQL, HTML5, CSS3 et JavaScript.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
$db_host = 'localhost';
|
||||
$db_name = 'projet';
|
||||
$db_user = 'user';
|
||||
$db_password = 'password';
|
||||
|
||||
// Configuration du JWT
|
||||
$secret_key = 'secret_key';
|
||||
|
||||
// Configuration du rate limiting
|
||||
$rate_limit = 10;
|
||||
$rate_timeout = 60;
|
||||
|
||||
// Function pour la connexion à la base de données
|
||||
function connectDb() {
|
||||
try {
|
||||
$dsn = "pgsql:host=$GLOBALS['db_host'];dbname=$GLOBALS['db_name']";
|
||||
$opt = [
|
||||
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
// PDO::ATTR_STRINGIFY_FETCHES => true,
|
||||
];
|
||||
$pdo = new PDO($dsn, $GLOBALS['db_user'], $GLOBALS['db_password'], $opt);
|
||||
return $pdo;
|
||||
} catch (PDOException $e) {
|
||||
throw new PDOException($e->getMessage(), (int)$e->getCode());
|
||||
}
|
||||
}
|
||||
|
||||
// Function pour l'authentification via JWT
|
||||
function authenticate($username, $password) {
|
||||
$pdo = connectDb();
|
||||
$stmt = $pdo->prepare('SELECT * FROM utilisateur WHERE username = :username');
|
||||
$stmt->bindParam(':username', $username);
|
||||
$stmt->execute();
|
||||
$user = $stmt->fetch();
|
||||
if ($user && password_verify($password, $user['password'])) {
|
||||
$token = jwt_encode(['username' => $username]);
|
||||
return [
|
||||
'token' => $token,
|
||||
'exp' => time() + 3600, // expire après 1 heure
|
||||
];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// Function pour la génération d'un token JSON Web Token (JWT)
|
||||
function jwt_encode($payload) {
|
||||
return \Firebase\JWT\JWT::encode($payload, $GLOBALS['secret_key']);
|
||||
}
|
||||
|
||||
// Function pour la décrytion d'un token JSON Web Token (JWT)
|
||||
function jwt_decode($token) {
|
||||
return \Firebase\JWT\JWT::decode($token, $GLOBALS['secret_key'], ['HS256']);
|
||||
}
|
||||
|
||||
// Function pour l'implémentation du schéma de pagination
|
||||
function paginate($pdo, $sql, $params) {
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
$totalRows = $stmt->rowCount();
|
||||
$stmt->execute(array_merge($params, ['limit' => 10]));
|
||||
return [
|
||||
'data' => $stmt->fetchAll(),
|
||||
'meta' => [
|
||||
'page' => 1,
|
||||
'limit' => 10,
|
||||
'total' => (int) ($totalRows / 10) + 1,
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
// Function pour l'implémentation du rate limiting
|
||||
function rateLimit() {
|
||||
// Nous utilisons un tableau associatif pour stocker les données de rate limiting
|
||||
$rateLimitData = [];
|
||||
if (isset($_SESSION['rateLimit']) && time() - $_SESSION['rateLimit'] < $GLOBALS['rate_timeout']) {
|
||||
// Si le temps écoulé depuis le dernier appel est supérieur à la durée de rate limiting
|
||||
// Nous incrémentons le compteur de demande
|
||||
$rateLimitData['count'] = isset($rateLimitData['count']) ? $rateLimitData['count'] + 1 : 1;
|
||||
// Nous mettons à jour la date et l'heure de la dernière requête
|
||||
$rateLimitData['time'] = time();
|
||||
} else {
|
||||
// Si le temps écoulé depuis le dernier appel est inférieur ou égal à la durée de rate limiting
|
||||
// Nous mettons à zéro le compteur de demande et la date et l'heure de la dernière requête
|
||||
$rateLimitData['count'] = 0;
|
||||
$rateLimitData['time'] = time();
|
||||
}
|
||||
// Nous mettons à jour la date et l'heure de la dernière requête dans la session
|
||||
$_SESSION['rateLimit'] = time();
|
||||
// Nous vérifions si le compteur de demande est supérieur à la limite autorisée
|
||||
if ($rateLimitData['count'] > $GLOBALS['rate_limit']) {
|
||||
// Si oui, nous envoyons un code d'état HTTP 429 (Too Many Requests)
|
||||
http_response_code(429);
|
||||
return 'Rate limiting exceeded';
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Fonction de validation des données
|
||||
function validate($data, $schema) {
|
||||
$errors = [];
|
||||
foreach ($schema as $field => $rules) {
|
||||
$value = $data[$field];
|
||||
if (isset($rules['required']) && empty($value)) {
|
||||
$errors[] = $field . ' est requis';
|
||||
}
|
||||
}
|
||||
return $errors;
|
||||
}
|
||||
|
||||
// Route pour la récupération de tous les projets
|
||||
$app->get('/api/projets', function () use ($pdo) {
|
||||
$sql = 'SELECT * FROM projet'; // query
|
||||
$params = []; // params for the query
|
||||
$data = paginate($pdo, $sql, $params);
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($data);
|
||||
});
|
||||
|
||||
// Route pour la création d'un projet
|
||||
$app->post('/api/projets', function () use ($pdo) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$errors = validate($data, [
|
||||
'titre' => ['required'],
|
||||
'description' => ['required'],
|
||||
]);
|
||||
if (!empty($errors)) {
|
||||
http_response_code(422);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['errors' => $errors]);
|
||||
return;
|
||||
}
|
||||
$sql = 'INSERT INTO projet (titre, description) VALUES (:titre, :description)';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':titre', $data['titre']);
|
||||
$stmt->bindParam(':description', $data['description']);
|
||||
$stmt->execute();
|
||||
http_response_code(201);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['message' => 'Projet crée avec succès']);
|
||||
});
|
||||
|
||||
// Route pour la récupération d'un projet par ID
|
||||
$app->get('/api/projets/:id', function ($id) use ($pdo) {
|
||||
$sql = 'SELECT * FROM projet WHERE id = :id';
|
||||
$params = ['id' => $id];
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $params['id']);
|
||||
$stmt->execute();
|
||||
$data = $stmt->fetch();
|
||||
if ($data === false) {
|
||||
http_response_code(404);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['errors' => ['Projet non trouvé']]);
|
||||
return;
|
||||
}
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo
|
||||
@@ -1,160 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP avec authentification JWT, validation, pagination et rate limiting. Cette API s'appelle « WEVCODE » et permet de gérer des ressources appelées « utilisateurs ».
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de l'application
|
||||
$appName = 'WEVCODE';
|
||||
|
||||
// Configuration de la base de données
|
||||
$dbConfig = [
|
||||
'host' => 'localhost',
|
||||
'port' => 5432,
|
||||
'database' => 'wevcodesql',
|
||||
'username' => 'wevcodeuser',
|
||||
'password' => 'wevcodedbuser',
|
||||
];
|
||||
|
||||
// Configuration du système de fichier
|
||||
$filePath = __DIR__ . '/uploads/';
|
||||
|
||||
// Configuration de la mise en mémoire
|
||||
$memcachedHosts = ['127.0.0.1:11211'];
|
||||
|
||||
// Configuration du rate limiting
|
||||
$rateLimitConfig = [
|
||||
'limit' => 5,
|
||||
'seconds' => 60,
|
||||
];
|
||||
|
||||
// Configuration de la pagination
|
||||
$paginationConfig = [
|
||||
'limit' => 10,
|
||||
];
|
||||
|
||||
// Autoloader
|
||||
require_once __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
// Connection à PostgreSQL
|
||||
$db = \Doctrine\DBAL\DriverManager::getConnection([
|
||||
'driver' => 'pdo_pgsql',
|
||||
'host' => $dbConfig['host'],
|
||||
'port' => $dbConfig['port'],
|
||||
'user' => $dbConfig['username'],
|
||||
'password' => $dbConfig['password'],
|
||||
'database' => $dbConfig['database'],
|
||||
]);
|
||||
|
||||
// Configuration de Jwt
|
||||
$jwt = new \Firebase\JWT\JWT([
|
||||
'key' => 'SECRET_KEY_WEEV',
|
||||
]);
|
||||
|
||||
// Configuration validateur
|
||||
$validator = new \Phalcon\Validation();
|
||||
$validator->addValidator('email', new \Phalcon\Validation\Validator\Email([]));
|
||||
|
||||
// Mise en mémoire
|
||||
$memcache = new \Memcached();
|
||||
$memcache->addServer($memcachedHosts[0]);
|
||||
|
||||
// RateLimiter
|
||||
$rateLimiter = new \App\Tools\RateLimiter($rateLimitConfig);
|
||||
|
||||
// Routes
|
||||
$app = new \Phalcon\Mvc\Micro();
|
||||
|
||||
// Auth
|
||||
$app->get('/auth/token', function () use ($jwt) {
|
||||
$token = $jwt->encode([
|
||||
'user_id' => 1,
|
||||
'email' => 'test@test.com',
|
||||
]);
|
||||
return json_encode([
|
||||
'token' => $token,
|
||||
]);
|
||||
})->before($authMiddleware);
|
||||
|
||||
// Routes CRUD
|
||||
$app->get('/users', function () use ($db, $paginationConfig) {
|
||||
$users = $db->query('SELECT * FROM users', $paginationConfig)->fetchAll();
|
||||
return json_encode($users);
|
||||
})->before($paginationMiddleware)->setName('GET_users');
|
||||
|
||||
$app->post('/users', function () use ($db, $validator) {
|
||||
$data = $_POST;
|
||||
if (!$validator->validate($data, ['email'])) {
|
||||
return json_encode(['error' => 'Email error']);
|
||||
}
|
||||
$db->insert('users', $data);
|
||||
return json_encode($db->lastInsertId());
|
||||
});
|
||||
|
||||
$app->get('/users/{id}', function ($id) use ($db) {
|
||||
$user = $db->fetchOne('SELECT * FROM users WHERE id = :id:', ['id' => $id]);
|
||||
return json_encode($user);
|
||||
});
|
||||
|
||||
$app->put('/users/{id}', function ($id) use ($db, $validator) {
|
||||
$data = $_PUT;
|
||||
if (!$validator->validate($data, ['email'])) {
|
||||
return json_encode(['error' => 'Email error']);
|
||||
}
|
||||
$db->update('users', $data, ['id' => $id]);
|
||||
return json_encode(['message' => 'User updated']);
|
||||
});
|
||||
|
||||
$app->delete('/users/{id}', function ($id) use ($db) {
|
||||
$db->delete('users', ['id' = $id]);
|
||||
return json_encode(['message' => 'User deleted']);
|
||||
});
|
||||
|
||||
// Pagination Middleware
|
||||
function paginationMiddleware($route) {
|
||||
$paginationConfig = $paginationConfig;
|
||||
return function () use ($route, $paginationConfig) {
|
||||
$pageNumber = $route->getParams()->get('pageNumber', 1);
|
||||
$limit = $route->getParams()->get('limit', $paginationConfig['limit']);
|
||||
$route->setParams(['pageNumber' => $pageNumber]);
|
||||
$route->setParams(['limit' => $limit]);
|
||||
};
|
||||
}
|
||||
|
||||
// Auth Middleware
|
||||
function authMiddleware($route) {
|
||||
$token = $_COOKIE['token'];
|
||||
if (!isset($token) || !$jwt->decode($token, 'SECRET_KEY_WEEV')) {
|
||||
return json_encode(['error' => 'Unauthorized']);
|
||||
}
|
||||
}
|
||||
|
||||
// Rate Limiter Middleware
|
||||
function rateLimiterMiddleware($route) {
|
||||
$rateLimiter = $rateLimiter;
|
||||
return function () use ($rateLimiter, $route) {
|
||||
$routeLimiter = $rateLimiter->hit();
|
||||
if ($routeLimiter) {
|
||||
json_encode(['error' => 'Too many requests']);
|
||||
return;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Execution de l'application
|
||||
$app->handle();
|
||||
|
||||
?>
|
||||
```
|
||||
|
||||
Le code ci-dessus implémente les fonctionnalités suivantes :
|
||||
|
||||
1. **Authentification JWT** : L'application utilise la bibliothèque `firebase/php-jwt` pour générer et valider des jetons JWT. Lors de la connexion, l'application renvoie un jeton JWT contenant les informations de l'utilisateur.
|
||||
2. **Routes CRUD** : Les routes CRUD (`GET`, `POST`, `PUT`, `DELETE`) sont implémentées pour gérer les ressources utilisateur.
|
||||
3. **Pagination** : L'application utilise la pagination pour permettre aux utilisateurs de récupérer les données utilisateur paginées.
|
||||
4. **Rate Limiting** : L'application utilise la bibliothèque `phalcon-hidra` pour implémenter le rate limiting et éviter les abus de la ressource.
|
||||
5. **Mise en mémoire** : L'application utilise la bibliothèque `memcached` pour mettre en mémoire des données.
|
||||
6. **Validation** : L'application utilise la bibliothèque `phalcon/validation` pour valider les données en entrée.
|
||||
7. **Databse** : L'application utilise la bibliothèque `doctrine/dbal` pour se connecter à la base de données PostgreSQL.
|
||||
|
||||
Notez que ce code est un exemple et peut ne pas être adapté à vos besoins spécifiques. Il est recommandé de personnaliser et de sécuriser les routes, la base de données et les autorisations pour votre application.
|
||||
@@ -1,200 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour gérer les opérations CRUD (Create, Read, Update, Delete) avec authentification JWT, validation, pagination, et rate limiting. Nous utiliserons la bibliothèque de validation Laravel pour les règles de validation et RateLimiter pour le rate limiter.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Import des bibliothèques nécessaires
|
||||
require 'vendor/autoload.php';
|
||||
|
||||
use Illuminate\Support\Collection;
|
||||
use Illuminate\Support\Str;
|
||||
use Illuminate\Support\Facades\RateLimiter;
|
||||
use Illuminate\Http\Request;
|
||||
use Illuminate\Pipeline\ Pipeline;
|
||||
use Illuminate\Support\Facades\Cache;
|
||||
use Illuminate\Support\Facades\Event;
|
||||
use Laravel\Sanctum\Security\GuardAPI;
|
||||
use Laravel\Sanctum\Security\GuardAPIUser;
|
||||
use Laravel\Sanctum\Security\GuardAPIVerifier;
|
||||
use Laravel\Sanctum\Security\GuardUser;
|
||||
use Laravel\Sanctum\Security\VerifierAPIUser;
|
||||
use Laravel\Sanctum\Support\Facades\Sanctum;
|
||||
|
||||
// Configuration de la base de données
|
||||
$configPDO = [
|
||||
'host' => 'localhost',
|
||||
'dbname' => 'donnees_api',
|
||||
'user' => 'API_user',
|
||||
'password' => 'pass_api'
|
||||
];
|
||||
|
||||
// Connection à la base de données
|
||||
try {
|
||||
$pdo = new PDO('pgsql:host=localhost;dbname=donnees_api', 'API_user', 'pass_api');
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo 'Erreur de connexion à la base de données : ', $e->getMessage(), "\n";
|
||||
exit;
|
||||
}
|
||||
|
||||
// Règles de validation pour les données envoyées par le client
|
||||
ValidationRules::validate = function ($request) {
|
||||
return $request->validate([
|
||||
'name' => 'required|string',
|
||||
'description' => 'required|string',
|
||||
]);
|
||||
};
|
||||
|
||||
// Verifier si l'utilisateur a autorisation
|
||||
VerifiesPermissions::check = function ($action) use ($request, $user) {
|
||||
return true
|
||||
};
|
||||
|
||||
// Validation des données envoyées par le client
|
||||
validationRules = array(
|
||||
'insert' => [
|
||||
'name' => 'required|string',
|
||||
'description' => 'required|string',
|
||||
],
|
||||
'update' => [
|
||||
'name' => 'required|string',
|
||||
'description' => 'required|string',
|
||||
]
|
||||
);
|
||||
|
||||
// Rate Limiter
|
||||
$maxAttempts = 50;
|
||||
$decayMinutes = 1;
|
||||
|
||||
RateLimiter::for('auth', function (\Illuminate\Http\Request $request) use ($maxAttempts, $decayMinutes) {
|
||||
$key = $request->ip();
|
||||
if (! RateLimiter::tooManyAttempts($key, $maxAttempts)) {
|
||||
RateLimiter::clear($key);
|
||||
}
|
||||
return RateLimiter::allow($key, $maxAttempts, $decayMinutes);
|
||||
});
|
||||
|
||||
// Gestion des routes pour les opérations CRUD
|
||||
$router = new \Illuminate\Routing\RouteCollection();
|
||||
|
||||
// Route pour récupérer toutes les données
|
||||
$router->map(['POST', 'GET'], '/users', 'getData');
|
||||
|
||||
// Route pour ajouter une nouvelle donnée
|
||||
$router->map(['POST'], '/users', 'addData');
|
||||
|
||||
// Route pour mettre à jour une donnée existante
|
||||
$router->map(['PUT'], '/users/{id}', 'updateData');
|
||||
|
||||
// Route pour supprimer une donnée
|
||||
$router->map(['DELETE'], '/users/{id}', 'deleteData');
|
||||
|
||||
// Fonction pour récupérer toutes les données existantes
|
||||
function getData()
|
||||
{
|
||||
$query = "SELECT * FROM donnees";
|
||||
$stmt = $pdo->prepare($query);
|
||||
$stmt->execute();
|
||||
$result = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
// Pagination des données
|
||||
$currentPage = $_GET['page'] ?? 1;
|
||||
$perPage = $_GET['per_page'] ?? 10;
|
||||
|
||||
$totalRows = count($result);
|
||||
$totalPages = ceil($totalRows / $perPage);
|
||||
|
||||
$start = ($currentPage - 1) * $perPage;
|
||||
$end = $start + $perPage;
|
||||
if ($end > $totalRows) {
|
||||
$end = $totalRows;
|
||||
}
|
||||
|
||||
$result = array_slice($result, $start, $perPage);
|
||||
return $result;
|
||||
}
|
||||
|
||||
// Fonction pour ajouter de nouvelles données
|
||||
function addData()
|
||||
{
|
||||
// Vérification de la validité des données
|
||||
ValidationRules::validate(request()->all());
|
||||
VerifiesPermissions::check('insert');
|
||||
|
||||
$data = request()->all();
|
||||
$stmt = $pdo->prepare("INSERT INTO donnees (name, description) VALUES (:name, :description)");
|
||||
$stmt->bindParam(':name', $data['name']);
|
||||
$stmt->bindParam(':description', $data['description']);
|
||||
$stmt->execute();
|
||||
|
||||
return ['message' => 'Donnée ajoutée'];
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour une donnée existante
|
||||
function updateData()
|
||||
{
|
||||
$id = $_GET['id'];
|
||||
// Vérification de la validité des données
|
||||
ValidationRules::validate(request()->all());
|
||||
VerifiesPermissions::check('update');
|
||||
|
||||
$data = request()->all();
|
||||
$stmt = $pdo->prepare("UPDATE donnees SET name = :name, description = :description WHERE id = :id");
|
||||
$stmt->bindParam(':name', $data['name']);
|
||||
$stmt->bindParam(':description', $data['description']);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
|
||||
return ['message' => 'Donnée mise à jour'];
|
||||
}
|
||||
|
||||
// Fonction pour supprimer une donnée
|
||||
function deleteData()
|
||||
{
|
||||
$id = $_GET['id'];
|
||||
$stmt = $pdo->prepare("DELETE FROM donnees WHERE id = :id");
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
|
||||
return ['message' => 'Donnée supprimée'];
|
||||
}
|
||||
|
||||
// Fonction pour générer un jeton de connexion
|
||||
function generateToken()
|
||||
{
|
||||
$key = Str::random(64);
|
||||
// Enregistrement du jeton
|
||||
Cache::store('files')->forever($key, now());
|
||||
|
||||
return $key;
|
||||
}
|
||||
|
||||
// Fonction pour vérifier le jeton de connexion
|
||||
function verifyToken($token)
|
||||
{
|
||||
// Vérification si le jeton est valable
|
||||
$cache = Cache::store('files')->get($token);
|
||||
if (!$cache) {
|
||||
return false;
|
||||
}
|
||||
// Temps de validité du jeton
|
||||
if (now()->diffInSeconds($cache) > 10*60) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Mise en oeuvre des routes CRUD
|
||||
$router->map(['POST', 'GET'], '/users', 'getData');
|
||||
$router->map(['POST'], '/users', 'addData');
|
||||
$router->map(['PUT', 'DELETE'], '/users/{id}', 'updateData');
|
||||
|
||||
// Route pour l'authentification
|
||||
$router->map(['POST'], '/auth', 'login');
|
||||
|
||||
// Fonction de connexion
|
||||
function login()
|
||||
{
|
||||
// Vérification de la
|
||||
@@ -1,43 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP avec les fonctionnalités demandées :
|
||||
```php
|
||||
<?php
|
||||
use Psr\Http\Message\ResponseInterface as Response;
|
||||
use Psr\Http\Message\ServerRequestInterface as Request;
|
||||
use Slim\Factory\AppFactory;
|
||||
use Firebase\JWT\JWT;
|
||||
use Slim\Middleware\JwtAuthentication;
|
||||
use Slim\Factory\ServerRequest;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddleware;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\Middleware\JwtAuthentication\JwtAuthenticationMiddlewareOptions;
|
||||
use Slim\
|
||||
@@ -1,210 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API REST avec les fonctionnalités suivantes :
|
||||
|
||||
* Authentification et autorisation à l'aide de JSON Web Tokens (JWT)
|
||||
* CRUD (Créer, Lire, Mettre à jour, Supprimer) pour les ressources
|
||||
* Validation des données entrantes à l'aide de la bibliothèque de validation Symfony
|
||||
* Pagination pour les résultats de requête
|
||||
* Limite de taux pour éviter les attaques de saturation
|
||||
* Connexion à une base de données PostgreSQL
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Réglages de base
|
||||
$scheme = 'https';
|
||||
$hosts = ['localhost'];
|
||||
$port = 5432;
|
||||
$dbname = 'mon_base_de_donnees';
|
||||
$login = 'mon_utilisateur';
|
||||
$password = 'mon_mot_de_passe';
|
||||
|
||||
// Enregistrement des paramètres de connexion
|
||||
$dsn = $scheme . '://' . $hosts[0] . ':' . $port . '/' . $dbname;
|
||||
|
||||
// Import des bibliothèques nécessaires
|
||||
require_once __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
use Doctrine\ORM\Tools\Setup;
|
||||
use Doctrine\DBAL\Driver\PDOPgSql\Driver;
|
||||
use Symfony\Component\Serializer\Encoder\JsonEncoder;
|
||||
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
|
||||
use Symfony\Component\Serializer\SerializerInterface;
|
||||
use Symfony\Component\Validator\Validation;
|
||||
use Symfony\Component\Validator\Constraints as Assert;
|
||||
use Predis\Client;
|
||||
use JWTAuth\Providers\JWT;
|
||||
use GuzzleHttp\Psr7\Response;
|
||||
use FastRoute\RouteCollector;
|
||||
use FastRoute\RouteData;
|
||||
|
||||
// Configuration de Doctrine
|
||||
$isDevMode = false;
|
||||
$config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/entities"), $isDevMode);
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = \Doctrine\DBAL\DriverManager::getConnection([
|
||||
'pdo' => [
|
||||
'dsn' => $dsn,
|
||||
'user' => $login,
|
||||
'password' => $password
|
||||
],
|
||||
'wrapperClass' => \PDO::class,
|
||||
]);
|
||||
$conn->connect();
|
||||
|
||||
// Création de l'entité Étudiant
|
||||
class Étudiant
|
||||
{
|
||||
private $id;
|
||||
private $nom;
|
||||
private $prenom;
|
||||
private $dateNaissance;
|
||||
|
||||
public function setId($id): self
|
||||
{
|
||||
$this->id = $id;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function getId(): ?int
|
||||
{
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function setNom($nom): self
|
||||
{
|
||||
$this->nom = $nom;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function getNom(): ?string
|
||||
{
|
||||
return $this->nom;
|
||||
}
|
||||
|
||||
public function setPrenom($prenom): self
|
||||
{
|
||||
$this->prenom = $prenom;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function getPrenom(): ?string
|
||||
{
|
||||
return $this->prenom;
|
||||
}
|
||||
|
||||
public function setDateNaissance($dateNaissance): self
|
||||
{
|
||||
$this->dateNaissance = $dateNaissance;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function getDateNaissance(): ?string
|
||||
{
|
||||
return $this->dateNaissance;
|
||||
}
|
||||
}
|
||||
|
||||
// Enregistrement de l'entité dans le mappage de Doctrine
|
||||
$conn->getSchemaManager()->createTable(new \Tanneaud\Osmose\ORM\Mapping\Table(
|
||||
"etudiants",
|
||||
[
|
||||
new \Tanneaud\Osmose\ORM\Mapping\Columns(
|
||||
"id",
|
||||
new \Doctrine\DBAL\Schema\TableColumn("integer", "id", "id")
|
||||
),
|
||||
new \Tanneaud\Osmose\ORM\Mapping\Columns(
|
||||
"nom",
|
||||
new \Doctrine\DBAL\Schema\TableColumn("text", "nom", "nom")
|
||||
),
|
||||
new \Tanneaud\Osmose\ORM\Mapping\Columns(
|
||||
"prenom",
|
||||
new \Doctrine\DBAL\Schema\TableColumn("text", "prenom", "prenom")
|
||||
),
|
||||
new \Tanneaud\Osmose\ORM\Mapping\Columns(
|
||||
"date_naissance",
|
||||
new \Doctrine\DBAL\Schema\TableColumn("timestamp", "date_naissance", "date_naissance")
|
||||
),
|
||||
]
|
||||
)
|
||||
);
|
||||
|
||||
// Import de FastRouter
|
||||
require_once __DIR__ . '/vendor/autoload.php';
|
||||
use FastRouter\FastRouter;
|
||||
|
||||
// Configuration de FastRouter
|
||||
$router = new FastRouter();
|
||||
$router->setRouteCollector(new RouteCollector(new RouteData()));
|
||||
|
||||
// Configuration de l'autorisation
|
||||
class Authorize
|
||||
{
|
||||
public static function autoriser(\Request $request)
|
||||
{
|
||||
if (!$request->getHeader('Authorization')) {
|
||||
return false;
|
||||
}
|
||||
$jwt = JWT::decode($request->getHeader('Authorization'));
|
||||
if (!$jwt->getClaims()->hasClaim('id')) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Création de l'API
|
||||
class API
|
||||
{
|
||||
private $router;
|
||||
private $conn;
|
||||
private $serializer;
|
||||
|
||||
public function __construct(FastRouter $router, \Doctrine\DBAL\Connection $conn, SerializerInterface $serializer)
|
||||
{
|
||||
$this->router = $router;
|
||||
$this->conn = $conn;
|
||||
$this->serializer = $serializer;
|
||||
}
|
||||
|
||||
public function get(\Request $request)
|
||||
{
|
||||
if (!$authorize = \Authorize::autoriser($request)) {
|
||||
return new Response(401, ['Content-Type' => 'application/json'], 'Authorization faite');
|
||||
}
|
||||
|
||||
$querybuilder = $this->conn->createQueryBuilder();
|
||||
$querybuilder
|
||||
->select('e.id', 'e.nom', 'e.prenom', 'e.date_naissance')
|
||||
->from('etudiants', 'e');
|
||||
$items = $querybuilder->execute()->fetchAll();
|
||||
return new Response(200, ['Content-Type' => 'application/json'], $this->serializer->serialize($items, 'json'));
|
||||
}
|
||||
|
||||
public function post(\Request $request)
|
||||
{
|
||||
if (!$authorize = \Authorize::autoriser($request)) {
|
||||
return new Response(401, ['Content-Type' => 'application/json'], 'Authorization faite');
|
||||
}
|
||||
|
||||
$data = $this->serializer->deserialize($request->getBody()->getContents(), 'Étudiant', 'json');
|
||||
$this->conn->insert('etudiants', $data);
|
||||
return new Response(201, ['Content-Type' => 'application/json'], "$data");
|
||||
}
|
||||
|
||||
public function patch(\Request $request)
|
||||
{
|
||||
if (!$authorize = \Authorize::autoriser($request)) {
|
||||
return new Response(401, ['Content-Type' => 'application/json'], 'Authorization faite');
|
||||
}
|
||||
|
||||
$data = $this->serializer->deserialize($request->getBody()->getContents(), 'Étudiant', 'json');
|
||||
$this->conn->update('etudiants', $data);
|
||||
return new Response(200, ['Content-Type' => 'application/json'], "$data");
|
||||
}
|
||||
|
||||
public function delete(\Request $request)
|
||||
{
|
||||
if (!$authorize = \Authorize::autoriser($request)) {
|
||||
return
|
||||
@@ -1,155 +0,0 @@
|
||||
<?php
|
||||
Voici une implémentation d'une API REST complète en PHP pour un CRM avec les fonctionnalités demandées :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
$host = 'localhost';
|
||||
$dbname = 'crm';
|
||||
$user = 'VotreUtilisateur';
|
||||
$password = 'VotreMotDePasse';
|
||||
|
||||
// Connexion à la base de données
|
||||
$dsn = "pgsql:host=$host;dbname=$dbname";
|
||||
try {
|
||||
$pdo = new PDO($dsn, $user, $password);
|
||||
} catch (PDOException $e) {
|
||||
throw new PDOException($e->getMessage(), (int)$e->getCode());
|
||||
}
|
||||
|
||||
// Fonction authentification
|
||||
function authenticate($username, $password) {
|
||||
$sql = "SELECT * FROM utilisateurs WHERE username = :username AND password = :password";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['username' => $username, 'password' => $password]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
// Fonction de création d'un client
|
||||
function createClient($nom, $prenom, $email, $telephone) {
|
||||
$sql = "INSERT INTO clients (nom, prenom, email, telephone) VALUES (:nom, :prenom, :email, :telephone)";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['nom' => $nom, 'prenom' => $prenom, 'email' => $email, 'telephone' => $telephone]);
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction de création d'un deal
|
||||
function createDeal($titre, $client_id, $montant) {
|
||||
$sql = "INSERT INTO deals (titre, client_id, montant) VALUES (:titre, :client_id, :montant)";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['titre' => $titre, 'client_id' => $client_id, 'montant' => $montant]);
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction de création d'activité
|
||||
function createActivity($titre, $date, $client_id) {
|
||||
$sql = "INSERT INTO activites (titre, date, client_id) VALUES (:titre, :date, :client_id)";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['titre' => $titre, 'date' => $date, 'client_id' => $client_id]);
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction de création d'un utilisateur
|
||||
function createUser($username, $password, $email) {
|
||||
$sql = "INSERT INTO utilisateurs (username, password, email) VALUES (:username, :password, :email)";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['username' => $username, 'password' => $password, 'email' => $email]);
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction de lecture de clients
|
||||
function readClients() {
|
||||
$sql = "SELECT * FROM clients";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
// Fonction de lecture d'un client par ID
|
||||
function readClient($id) {
|
||||
$sql = "SELECT * FROM clients WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
// Fonction de lecture de deals
|
||||
function readDeals($client_id = null) {
|
||||
$sql = "SELECT * FROM deals";
|
||||
if ($client_id) {
|
||||
$sql .= " WHERE client_id = :client_id";
|
||||
}
|
||||
$stmt = $pdo->prepare($sql);
|
||||
if ($client_id) {
|
||||
$stmt->execute(['client_id' => $client_id]);
|
||||
} else {
|
||||
$stmt->execute();
|
||||
}
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
// Fonction de lecture d'un deal par ID
|
||||
function readDeal($id) {
|
||||
$sql = "SELECT * FROM deals WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
// Fonction de lecture d'activités
|
||||
function readActivities($client_id = null) {
|
||||
$sql = "SELECT * FROM activites";
|
||||
if ($client_id) {
|
||||
$sql .= " WHERE client_id = :client_id";
|
||||
}
|
||||
$stmt = $pdo->prepare($sql);
|
||||
if ($client_id) {
|
||||
$stmt->execute(['client_id' => $client_id]);
|
||||
} else {
|
||||
$stmt->execute();
|
||||
}
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
// Fonction de lecture d'un activité par ID
|
||||
function readActivity($id) {
|
||||
$sql = "SELECT * FROM activites WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un client
|
||||
function updateClient($id, $nom, $prenom, $email, $telephone) {
|
||||
$sql = "UPDATE clients SET nom = :nom, prenom = :prenom, email = :email, telephone = :telephone WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['nom' => $nom, 'prenom' => $prenom, 'email' => $email, 'telephone' => $telephone, 'id' => $id]);
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un deal
|
||||
function updateDeal($id, $titre, $client_id, $montant) {
|
||||
$sql = "UPDATE deals SET titre = :titre, client_id = :client_id, montant = :montant WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['titre' => $titre, 'client_id' => $client_id, 'montant' => $montant, 'id' => $id]);
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'une activité
|
||||
function updateActivity($id, $titre, $date, $client_id) {
|
||||
$sql = "UPDATE activites SET titre = :titre, date = :date, client_id = :client_id WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['titre' => $titre, 'date' => $date, 'client_id' => $client_id, 'id' => $id]);
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un client
|
||||
function deleteClient($id) {
|
||||
$sql = "DELETE FROM clients WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un deal
|
||||
function deleteDeal($id) {
|
||||
$sql = "DELETE FROM deals WHERE id = :id";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute(['
|
||||
@@ -1,150 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP pour une API REST complète pour un CRM avec contacts, deals, pipeline, activités et rapports. Ce code utilise PHP 8.5, PostgreSQL comme base de données et SQL pour effectuer les interactions avec la base de données.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
$host = 'localhost';
|
||||
$dbname = 'crm';
|
||||
$user = 'username';
|
||||
$password = 'password';
|
||||
|
||||
// Connexion à la base de données
|
||||
try {
|
||||
$pdo = new PDO("pgsql:host=$host;dbname=$dbname", $user, $password);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo 'Erreur de connexion à la base de données : ' . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Fonction de gestion des requêtes HTTP
|
||||
function traitementRequete($requete, $donnees) {
|
||||
$entetes = array();
|
||||
$requete = $_SERVER['REQUEST_METHOD'] . ' ' . $_SERVER['REQUEST_URI'];
|
||||
foreach ($_SERVER as $cle => $valeur) {
|
||||
if (strpos($cle, 'HTTP_') === 0) {
|
||||
$entetes[] = ucfirst(str_replace('_', ' ', substr($cle, 5))) . ': ' . $valeur;
|
||||
}
|
||||
}
|
||||
// Renvoye des informations sur les requêtes
|
||||
echo implode("\n", $requete . "\n", $entetes) . "\n";
|
||||
echo json_encode($donnees) . "\n";
|
||||
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'GET') {
|
||||
afficherContacts();
|
||||
afficherDeals();
|
||||
afficherActivites();
|
||||
}
|
||||
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
|
||||
ajouterContact($donnees);
|
||||
ajouterDeal($donnees);
|
||||
ajouterActivite($donnees);
|
||||
}
|
||||
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'PUT') {
|
||||
miseAJourContact($donnees);
|
||||
miseAJourDeal($donnees);
|
||||
miseAJourActivite($donnees);
|
||||
}
|
||||
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'DELETE') {
|
||||
supprimerContact($donnees['idContact']);
|
||||
supprimerDeal($donnees['idDeal']);
|
||||
supprimerActivite($donnees['idActivite']);
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour afficher les contacts
|
||||
function afficherContacts() {
|
||||
$requete = 'SELECT * FROM contacts';
|
||||
$resultat = $pdo->query($requete);
|
||||
$donnees = $resultat->fetchAll(PDO::FETCH_ASSOC);
|
||||
echo json_encode($donnees);
|
||||
}
|
||||
|
||||
// Fonction pour afficher les deals
|
||||
function afficherDeals() {
|
||||
$requete = 'SELECT * FROM deals';
|
||||
$resultat = $pdo->query($requete);
|
||||
$donnees = $resultat->fetchAll(PDO::FETCH_ASSOC);
|
||||
echo json_encode($donnees);
|
||||
}
|
||||
|
||||
// Fonction pour afficher les activités
|
||||
function afficherActivites() {
|
||||
$requete = 'SELECT * FROM activites';
|
||||
$resultat = $pdo->query($requete);
|
||||
$donnees = $resultat->fetchAll(PDO::FETCH_ASSOC);
|
||||
echo json_encode($donnees);
|
||||
}
|
||||
|
||||
// Fonction pour ajouter un contact
|
||||
function ajouterContact($donnees) {
|
||||
$requete = 'INSERT INTO contacts (nom, email, telephone, entreprise) VALUES (:nom, :email, :telephone, :entreprise)';
|
||||
$sth = $pdo->prepare($requete);
|
||||
$sth->bindParam(':nom', $donnees['nom']);
|
||||
$sth->bindParam(':email', $donnees['email']);
|
||||
$sth->bindParam(':telephone', $donnees['telephone']);
|
||||
$sth->bindParam(':entreprise', $donnees['entreprise']);
|
||||
$sth->execute();
|
||||
$idContact = $pdo->lastInsertId();
|
||||
echo json_encode(array('message' => 'Contact ajouté avec succès', 'idContact' => $idContact));
|
||||
}
|
||||
|
||||
// Fonction pour ajouter un deal
|
||||
function ajouterDeal($donnees) {
|
||||
$requete = 'INSERT INTO deals (nom, montant, dateEchéance, idContact) VALUES (:nom, :montant, :dateEchéance, :idContact)';
|
||||
$sth = $pdo->prepare($requete);
|
||||
$sth->bindParam(':nom', $donnees['nom']);
|
||||
$sth->bindParam(':montant', $donnees['montant']);
|
||||
$sth->bindParam(':dateEchéance', $donnees['dateEchéance']);
|
||||
$sth->bindParam(':idContact', $donnees['idContact']);
|
||||
$sth->execute();
|
||||
$idDeal = $pdo->lastInsertId();
|
||||
echo json_encode(array('message' => 'Deal ajouté avec succès', 'idDeal' => $idDeal));
|
||||
}
|
||||
|
||||
// Fonction pour ajouter une activité
|
||||
function ajouterActivite($donnees) {
|
||||
$requete = 'INSERT INTO activites (nom, dateRealisation, idDeal) VALUES (:nom, :dateRealisation, :idDeal)';
|
||||
$sth = $pdo->prepare($requete);
|
||||
$sth->bindParam(':nom', $donnees['nom']);
|
||||
$sth->bindParam(':dateRealisation', $donnees['dateRealisation']);
|
||||
$sth->bindParam(':idDeal', $donnees['idDeal']);
|
||||
$sth->execute();
|
||||
$idActivite = $pdo->lastInsertId();
|
||||
echo json_encode(array('message' => 'Activité ajoutée avec succès', 'idActivite' => $idActivite));
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un contact
|
||||
function miseAJourContact($donnees) {
|
||||
$requete = 'UPDATE contacts SET nom = :nom, email = :email, telephone = :telephone, entreprise = :entreprise WHERE idContact = :idContact';
|
||||
$sth = $pdo->prepare($requete);
|
||||
$sth->bindParam(':nom', $donnees['nom']);
|
||||
$sth->bindParam(':email', $donnees['email']);
|
||||
$sth->bindParam(':telephone', $donnees['telephone']);
|
||||
$sth->bindParam(':entreprise', $donnees['entreprise']);
|
||||
$sth->bindParam(':idContact', $donnees['idContact']);
|
||||
$sth->execute();
|
||||
echo json_encode(array('message' => 'Contact mis à jour avec succès'));
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un deal
|
||||
function miseAJourDeal($donnees) {
|
||||
$requete = 'UPDATE deals SET nom = :nom, montant = :montant, dateEchéance = :dateEchéance, idContact = :idContact WHERE idDeal = :idDeal';
|
||||
$sth = $pdo->prepare($requete);
|
||||
$sth->bindParam(':nom', $donnees['nom']);
|
||||
$sth->bindParam(':montant', $donnees['montant']);
|
||||
$sth->bindParam(':dateEchéance', $donnees['dateEchéance']);
|
||||
$sth->bindParam(':idContact', $donnees['idContact']);
|
||||
$sth->bindParam(':idDeal', $donnees['idDeal']);
|
||||
$sth->execute();
|
||||
echo json_encode(array('message' => 'Deal mis à jour avec succès'));
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour une activité
|
||||
function miseAJourActivite($donnees) {
|
||||
|
||||
@@ -1,184 +0,0 @@
|
||||
<?php
|
||||
Voici une mise en page complète d'une API CRM en PHP qui répond à vos exigences :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de base des données
|
||||
$dsn = 'pgsql:host=localhost;dbname=crm';
|
||||
$dbuser = 'admin';
|
||||
$dbpass = 'password';
|
||||
|
||||
// Réponse JSON
|
||||
function sendResponse($status, $message, $data = null, $code = 200) {
|
||||
$response = array(
|
||||
'status' => $status,
|
||||
'message' => $message,
|
||||
'data' => $data
|
||||
);
|
||||
http_response_code($code);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($response);
|
||||
exit();
|
||||
}
|
||||
|
||||
// Connexion à la base de données
|
||||
try {
|
||||
$pdo = new PDO($dsn, $dbuser, $dbpass);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
sendResponse(false, "Erreur de connexion à la base de données", null, 500);
|
||||
exit();
|
||||
}
|
||||
|
||||
// Fonction pour créer un client
|
||||
function createClient($pseudo, $nom, $prenom, $email, $telephone) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('INSERT INTO clients (pseudo, nom, prenom, email, telephone) VALUES (:pseudo, :nom, :prenom, :email, :telephone)');
|
||||
$stmt->bindParam(':pseudo', $pseudo);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':prenom', $prenom);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->bindParam(':telephone', $telephone);
|
||||
$stmt->execute();
|
||||
$lastInsertId = $pdo->lastInsertId();
|
||||
return $lastInsertId;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour récupérer un client
|
||||
function getClient($idClient) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('SELECT * FROM clients WHERE id = :id');
|
||||
$stmt->bindParam(':id', $idClient);
|
||||
$stmt->execute();
|
||||
$data = $stmt->fetch();
|
||||
return $data;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un client
|
||||
function updateClient($idClient, $pseudoNew, $nomNew, $prenomNew, $emailNew, $telephoneNew) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('UPDATE clients SET pseudo = :pseudoNew, nom = :nomNew, prenom = :prenomNew, email = :emailNew, telephone = :telephoneNew WHERE id = :idClient');
|
||||
$stmt->bindParam(':pseudoNew', $pseudoNew);
|
||||
$stmt->bindParam(':nomNew', $nomNew);
|
||||
$stmt->bindParam(':prenomNew', $prenomNew);
|
||||
$stmt->bindParam(':emailNew', $emailNew);
|
||||
$stmt->bindParam(':telephoneNew', $telephoneNew);
|
||||
$stmt->bindParam(':idClient', $idClient);
|
||||
$stmt->execute();
|
||||
return true;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un client
|
||||
function deleteClient($idClient) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('DELETE FROM clients WHERE id = :id');
|
||||
$stmt->bindParam(':id', $idClient);
|
||||
$stmt->execute();
|
||||
return true;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour créer un accord
|
||||
function createDeals($idClient, $nom, $email, $telephone, $montant, $statut) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('INSERT INTO deals (id_client, nom, email, telephone, montant, statut) VALUES (:idClient, :nom, :email, :telephone, :montant, :statut)');
|
||||
$stmt->bindParam(':idClient', $idClient);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->bindParam(':telephone', $telephone);
|
||||
$stmt->bindParam(':montant', $montant);
|
||||
$stmt->bindParam(':statut', $statut);
|
||||
$stmt->execute();
|
||||
$lastInsertId = $pdo->lastInsertId();
|
||||
return $lastInsertId;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour récupérer un accord
|
||||
function getDeals($idClient) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('SELECT * FROM deals WHERE id_client = :idClient');
|
||||
$stmt->bindParam(':idClient', $idClient);
|
||||
$stmt->execute();
|
||||
$data = $stmt->fetchAll();
|
||||
return $data;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un accord
|
||||
function updateDeals($idDeal, $statut) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('UPDATE deals SET statut = :statut WHERE id = :idDeal');
|
||||
$stmt->bindParam(':statut', $statut);
|
||||
$stmt->bindParam(':idDeal', $idDeal);
|
||||
$stmt->execute();
|
||||
return true;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un accord
|
||||
function deleteDeals($idDeal) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('DELETE FROM deals WHERE id = :idDeal');
|
||||
$stmt->bindParam(':idDeal', $idDeal);
|
||||
$stmt->execute();
|
||||
return true;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour créer une activité
|
||||
function createActivities($idClient, $nomActivite, $description) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('INSERT INTO activities (id_client, nom_activite, description) VALUES (:idClient, :nomActivite, :description)');
|
||||
$stmt->bindParam(':idClient', $idClient);
|
||||
$stmt->bindParam(':nomActivite', $nomActivite);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->execute();
|
||||
$lastInsertId = $pdo->lastInsertId();
|
||||
return $lastInsertId;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour récupérer une activité
|
||||
function getActivities($idClient) {
|
||||
global $pdo;
|
||||
try {
|
||||
$stmt = $pdo->prepare('SELECT * FROM activities WHERE id_client = :idClient');
|
||||
$stmt->bindParam(':idClient', $idClient);
|
||||
$stmt->execute();
|
||||
$data = $stmt->fetchAll();
|
||||
return $data;
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
<?php
|
||||
Bien sûr, WEVCODE va générer pour vous une API REST complète et souveraine pour votre CRM. Ce code sera unique, fonctionnel, et prêt pour la production, respectant les standards PHP 8.5 et PostgreSQL.
|
||||
|
||||
Cette API gérera les entités
|
||||
@@ -1,225 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST pour un CRM avec routes CRUD pour les éléments suivants : contacts, deals, pipeline, activités et rapports.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configurer les paramètres de la base de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'crm_database');
|
||||
define('DB_USER', 'username');
|
||||
define('DB_PASSWORD', 'password');
|
||||
|
||||
// Connecter à la base de données
|
||||
$dsn = "pgsql:host=" . DB_HOST . "; dbname=" . DB_NAME;
|
||||
$pdo = new PDO($dsn, DB_USER, DB_PASSWORD);
|
||||
|
||||
// Fichier de configuration pour les paramètres du JSON
|
||||
header('Content-Type: application/json');
|
||||
|
||||
class Contact {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $prenom;
|
||||
public $email;
|
||||
public $telephone;
|
||||
|
||||
function __construct($id, $nom, $prenom, $email, $telephone) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->prenom = $prenom;
|
||||
$this->email = $email;
|
||||
$this->telephone = $telephone;
|
||||
}
|
||||
|
||||
function __toString() {
|
||||
return json_encode($this);
|
||||
}
|
||||
}
|
||||
|
||||
class Deal {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $description;
|
||||
public $montant;
|
||||
public $date_creation;
|
||||
public $contact_id;
|
||||
|
||||
function __construct($id, $nom, $description, $montant, $date_creation, $contact_id) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->description = $description;
|
||||
$this->montant = $montant;
|
||||
$this->date_creation = $date_creation;
|
||||
$this->contact_id = $contact_id;
|
||||
}
|
||||
|
||||
function __toString() {
|
||||
return json_encode($this);
|
||||
}
|
||||
}
|
||||
|
||||
class Pipeline {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $description;
|
||||
public $état;
|
||||
public $contact_id;
|
||||
|
||||
function __construct($id, $nom, $description, $état, $contact_id) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->description = $description;
|
||||
$this->état = $état;
|
||||
$this->contact_id = $contact_id;
|
||||
}
|
||||
|
||||
function __toString() {
|
||||
return json_encode($this);
|
||||
}
|
||||
}
|
||||
|
||||
class Activite {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $description;
|
||||
public $date_realisation;
|
||||
public $contact_id;
|
||||
|
||||
function __construct($id, $nom, $description, $date_realisation, $contact_id) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->description = $description;
|
||||
$this->date_realisation = $date_realisation;
|
||||
$this->contact_id = $contact_id;
|
||||
}
|
||||
|
||||
function __toString() {
|
||||
return json_encode($this);
|
||||
}
|
||||
}
|
||||
|
||||
class Rapport {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $description;
|
||||
public $date_creation;
|
||||
public $contact_id;
|
||||
|
||||
function __construct($id, $nom, $description, $date_creation, $contact_id) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->description = $description;
|
||||
$this->date_creation = $date_creation;
|
||||
$this->contact_id = $contact_id;
|
||||
}
|
||||
|
||||
function __toString() {
|
||||
return json_encode($this);
|
||||
}
|
||||
}
|
||||
|
||||
class Route {
|
||||
private $name;
|
||||
private $method;
|
||||
private $controller;
|
||||
private $params;
|
||||
|
||||
function __construct($name, $method, $controller, $params = array()) {
|
||||
$this->name = $name;
|
||||
$this->method = $method;
|
||||
$this->controller = $controller;
|
||||
$this->params = $params;
|
||||
}
|
||||
|
||||
function execute() {
|
||||
call_user_func_array($this->controller, $this->params);
|
||||
}
|
||||
}
|
||||
|
||||
class Router {
|
||||
private $routes;
|
||||
|
||||
function __construct() {
|
||||
$this->routes = array();
|
||||
}
|
||||
|
||||
function getRoute($name) {
|
||||
return array_filter($this->routes, function($route) use ($name) {
|
||||
return $route->name == $name;
|
||||
});
|
||||
}
|
||||
|
||||
function addRoute($name, $method, $controller, $params = array()) {
|
||||
$this->routes[] = new Route($name, $method, $controller, $params);
|
||||
}
|
||||
|
||||
function executeRoute() {
|
||||
$name = $_SERVER['REQUEST_URI'];
|
||||
$this->getRoute($name);
|
||||
$route = reset($this->getRoute($name));
|
||||
$route->execute();
|
||||
}
|
||||
}
|
||||
|
||||
function CRUDController($model, $action) {
|
||||
try {
|
||||
$method = $_SERVER['REQUEST_METHOD'];
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
getController($model, $action);
|
||||
break;
|
||||
case 'POST':
|
||||
postController($model, $action);
|
||||
break;
|
||||
case 'PUT':
|
||||
putController($model, $action);
|
||||
break;
|
||||
case 'DELETE':
|
||||
deleteController($model, $action);
|
||||
break;
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
http_response_code(400);
|
||||
echo json_encode(array('error' => 'Invalid request'));
|
||||
}
|
||||
}
|
||||
|
||||
function getController($model, $action) {
|
||||
$id = $_GET['id'];
|
||||
if ($id) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM ' . $model . ' WHERE id = :id');
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
echo json_encode($stmt->fetch());
|
||||
} else {
|
||||
$stmt = $pdo->prepare('SELECT * FROM ' . $model);
|
||||
$stmt->execute();
|
||||
echo json_encode($stmt->fetchAll());
|
||||
}
|
||||
}
|
||||
|
||||
function postController($model, $action) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
if ($data) {
|
||||
$sql = 'INSERT INTO ' . $model . '
|
||||
SET nom = :nom, prenom = :prenom, email = :email, telephone = :telephone';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':nom', $data['nom']);
|
||||
$stmt->bindParam(':prenom', $data['prenom']);
|
||||
$stmt->bindParam(':email', $data['email']);
|
||||
$stmt->bindParam(':telephone', $data['telephone']);
|
||||
$stmt->execute();
|
||||
echo json_encode($stmt->fetchAll());
|
||||
} else {
|
||||
http_response_code(400);
|
||||
echo json_encode(array('error' => 'Invalid data'));
|
||||
}
|
||||
}
|
||||
|
||||
function putController($model, $action) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$id = $_GET['id'];
|
||||
if ($id && $data) {
|
||||
$sql = 'UPDATE ' . $model . ' SET
|
||||
nom = :nom
|
||||
@@ -1,178 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API RESTfull pour un CRM avec contacts, deals, pipeline, activités et rapports :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données PostgreSQL
|
||||
$dsn = 'postgresql://admin:admin@localhost.crm';
|
||||
$bdd = new PDO($dsn);
|
||||
// Utilisation d'un set de charset spécifique
|
||||
$bdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
// Classe pour les opérations CRUD
|
||||
class CRM
|
||||
{
|
||||
// Fonction pour créer un nouveau contact
|
||||
public function createContact($nom, $prenom, $email)
|
||||
{
|
||||
$sql = 'INSERT INTO contacts (nom, prenom, email) VALUES (:nom, :prenom, :email)';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':prenom', $prenom);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->execute();
|
||||
return $bdd->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction pour créer un nouveau deal
|
||||
public function createDeal($title, $description, $contact_id)
|
||||
{
|
||||
$sql = 'INSERT INTO deals (title, description, contact_id) VALUES (:title, :description, :contact_id)';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':title', $title);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->bindParam(':contact_id', $contact_id);
|
||||
$stmt->execute();
|
||||
return $bdd->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction pour créer une nouvelle activité
|
||||
public function createActivity($title, $description, $deal_id)
|
||||
{
|
||||
$sql = 'INSERT INTO activities (title, description, deal_id) VALUES (:title, :description, :deal_id)';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':title', $title);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->bindParam(':deal_id', $deal_id);
|
||||
$stmt->execute();
|
||||
return $bdd->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction pour créer une nouvelle phase de pipeline
|
||||
public function createPipeline($title, $description, $deal_id)
|
||||
{
|
||||
$sql = 'INSERT INTO pipelines (title, description, deal_id) VALUES (:title, :description, :deal_id)';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':title', $title);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->bindParam(':deal_id', $deal_id);
|
||||
$stmt->execute();
|
||||
return $bdd->lastInsertId();
|
||||
}
|
||||
|
||||
// Fonction pour lancer un rapport
|
||||
public function rapport($debut, $fin)
|
||||
{
|
||||
$sql = 'SELECT * FROM deals where date_creation >= :debut and date_creation <= :fin';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':debut', $debut);
|
||||
$stmt->bindParam(':fin', $fin);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les contacts
|
||||
public function getContacts()
|
||||
{
|
||||
$sql = 'SELECT * FROM contacts';
|
||||
$stmt = $bdd->query($sql);
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les deals
|
||||
public function getDeals()
|
||||
{
|
||||
$sql = 'SELECT d.*, c.nom, c.prenom, c.email FROM deals d JOIN contacts c ON d.contact_id = c.id';
|
||||
$stmt = $bdd->query($sql);
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les activités
|
||||
public function getActivites()
|
||||
{
|
||||
$sql = 'SELECT * FROM activities';
|
||||
$stmt = $bdd->query($sql);
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les phases de pipeline
|
||||
public function getPipelines()
|
||||
{
|
||||
$sql = 'SELECT * FROM pipelines';
|
||||
$stmt = $bdd->query($sql);
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un contact
|
||||
public function updateContact($id, $nom, $prenom, $email)
|
||||
{
|
||||
$sql = 'UPDATE contacts SET nom = :nom, prenom = :prenom, email = :email WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':prenom', $prenom);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un deal
|
||||
public function updateDeal($id, $title, $description)
|
||||
{
|
||||
$sql = 'UPDATE deals SET title = :title, description = :description WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':title', $title);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour une activité
|
||||
public function updateActivity($id, $title, $description)
|
||||
{
|
||||
$sql = 'UPDATE activities SET title = :title, description = :description WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':title', $title);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un contact
|
||||
public function deleteContact($id)
|
||||
{
|
||||
$sql = 'DELETE FROM contacts WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un deal
|
||||
public function deleteDeal($id)
|
||||
{
|
||||
$sql = 'DELETE FROM deals WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour supprimer une activité
|
||||
public function deleteActivity($id)
|
||||
{
|
||||
$sql = 'DELETE FROM activities WHERE id = :id';
|
||||
$stmt = $bdd->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
}
|
||||
|
||||
// Gestion des requêtes
|
||||
$crm = new CRM();
|
||||
|
||||
// Routage des requêtes
|
||||
$app = new \Slim\App();
|
||||
|
||||
// Route pour la création d'un contact
|
||||
$app->post('/contacts', function ($request, $response) use ($crm) {
|
||||
$data = $request->getJsonBody();
|
||||
$nom = $data['nom
|
||||
@@ -1,173 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple d'API REST complète en PHP pour un CRM avec les fonctionnalités de gestion de contacts, de deals, de pipeline, d'activités et de rapports. Cette API utilise PostgreSQL comme base de données et prend en charge les routes CRUD (lecture, création, mise à jour, suppression) pour les différents entités.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données PostgreSQL
|
||||
$dbHost = 'localhost';
|
||||
$dbName = 'crm';
|
||||
$dbUser = 'utilisateur';
|
||||
$dbPass = 'motdepasse';
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=$dbHost dbname=$dbName user=$dbUser password=$dbPass");
|
||||
|
||||
// Fonction de création d'un client
|
||||
function createClient($connexion, $name, $telephone, $email) {
|
||||
$query = "INSERT INTO clients (name, telephone, email) VALUES ('$name', '$telephone', '$email') RETURNING *";
|
||||
$result = pg_query($connexion, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de lecture des clients
|
||||
function getClients($connexion) {
|
||||
$query = "SELECT * FROM clients";
|
||||
$result = pg_query($connexion, $query);
|
||||
$clients = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$clients[] = $row;
|
||||
}
|
||||
return $clients;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un client
|
||||
function updateClient($connexion, $id, $name, $telephone, $email) {
|
||||
$query = "UPDATE clients SET name = '$name', telephone = '$telephone', email = '$email' WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un client
|
||||
function deleteClient($connexion, $id) {
|
||||
$query = "DELETE FROM clients WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de création d'un deal
|
||||
function createDeal($connexion, $nom, $description, $montant) {
|
||||
$query = "INSERT INTO deals (nom, description, montant) VALUES ('$nom', '$description', $montant) RETURNING *";
|
||||
$result = pg_query($connexion, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de lecture des deals
|
||||
function getDeals($connexion) {
|
||||
$query = "SELECT * FROM deals";
|
||||
$result = pg_query($connexion, $query);
|
||||
$deals = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$deals[] = $row;
|
||||
}
|
||||
return $deals;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un deal
|
||||
function updateDeal($connexion, $id, $nom, $description, $montant) {
|
||||
$query = "UPDATE deals SET nom = '$nom', description = '$description', montant = $montant WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un deal
|
||||
function deleteDeal($connexion, $id) {
|
||||
$query = "DELETE FROM deals WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de création d'une activité
|
||||
function createActivity($connexion, $nom, $description, $date) {
|
||||
$query = "INSERT INTO activities (nom, description, date) VALUES ('$nom', '$description', '$date') RETURNING *";
|
||||
$result = pg_query($connexion, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de lecture des activités
|
||||
function getActivities($connexion) {
|
||||
$query = "SELECT * FROM activities";
|
||||
$result = pg_query($connexion, $query);
|
||||
$activities = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$activities[] = $row;
|
||||
}
|
||||
return $activities;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'une activité
|
||||
function updateActivity($connexion, $id, $nom, $description, $date) {
|
||||
$query = "UPDATE activities SET nom = '$nom', description = '$description', date = '$date' WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de suppression d'une activité
|
||||
function deleteActivity($connexion, $id) {
|
||||
$query = "DELETE FROM activities WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de création d'un pipeline
|
||||
function createPipeline($connexion, $nom, $description) {
|
||||
$query = "INSERT INTO pipelines (nom, description) VALUES ('$nom', '$description') RETURNING *";
|
||||
$result = pg_query($connexion, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de lecture des pipelines
|
||||
function getPipelines($connexion) {
|
||||
$query = "SELECT * FROM pipelines";
|
||||
$result = pg_query($connexion, $query);
|
||||
$pipelines = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$pipelines[] = $row;
|
||||
}
|
||||
return $pipelines;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un pipeline
|
||||
function updatePipeline($connexion, $id, $nom, $description) {
|
||||
$query = "UPDATE pipelines SET nom = '$nom', description = '$description' WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un pipeline
|
||||
function deletePipeline($connexion, $id) {
|
||||
$query = "DELETE FROM pipelines WHERE id = $id";
|
||||
pg_query($connexion, $query);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de création d'un rapport
|
||||
function createReport($connexion, $dateDebut, $dateFin) {
|
||||
$query = "INSERT INTO reports (date_debut, date_fin) VALUES ('$dateDebut', '$dateFin') RETURNING *";
|
||||
$result = pg_query($connexion, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de lecture des rapports
|
||||
function getReports($connexion) {
|
||||
$query = "SELECT * FROM reports";
|
||||
$result = pg_query($connexion, $query);
|
||||
$reports = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$reports[] = $row;
|
||||
}
|
||||
return $reports;
|
||||
}
|
||||
|
||||
// Fonction d'exécution d'une requête POST (création, mise à jour, suppression)
|
||||
function executePostRequest($connexion, $entite, $method, $data) {
|
||||
if ($method == 'create') {
|
||||
return $entite($connexion, $data['name'], $data['telephone'], $data['email']);
|
||||
} elseif ($method == 'update') {
|
||||
return $entite($connexion, $data['id'], $data['name'], $data['telephone'], $data['email']);
|
||||
} elseif ($method == 'delete') {
|
||||
return $entite($connexion, $data['id']);
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de réponse à une
|
||||
@@ -1,167 +0,0 @@
|
||||
<?php
|
||||
Voici une implémentation complète d'une API REST pour un CRM en PHP.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données PostgreSQL
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'crm');
|
||||
define('DB_USER', 'utilisateur');
|
||||
define('DB_PASSWORD', 'mot_de_passe');
|
||||
|
||||
// Connexion à la base de données
|
||||
$dsn = "pgsql:host=" . DB_HOST . ";dbname=" . DB_NAME;
|
||||
try {
|
||||
$pdo = new PDO($dsn, DB_USER, DB_PASSWORD);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo 'Erreur de connection : ' . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Fonctions d'inscription et de connexion
|
||||
function inscription($nom, $prenom, $email, $password)
|
||||
{
|
||||
global $pdo;
|
||||
|
||||
// Vérification d'existence de l'utilisateur
|
||||
$requete = $pdo->prepare('SELECT * FROM utilisateurs WHERE email = :email');
|
||||
$requete->bindParam(':email', $email);
|
||||
$requete->execute();
|
||||
$utilisateur = $requete->fetch();
|
||||
|
||||
if ($utilisateur) {
|
||||
return 'L\'email est déjà utilisé.';
|
||||
}
|
||||
|
||||
// Insertion de l'utilisateur
|
||||
$requete = $pdo->prepare('INSERT INTO utilisateurs (nom, prenom, email, mot_de_passe) VALUES (:nom, :prenom, :email, :mot_de_passe)');
|
||||
$requete->bindParam(':nom', $nom);
|
||||
$requete->bindParam(':prenom', $prenom);
|
||||
$requete->bindParam(':email', $email);
|
||||
$requete->bindParam(':mot_de_passe', $password);
|
||||
$requete->execute();
|
||||
|
||||
return 'L\'inscription a été effectuée avec succès.';
|
||||
}
|
||||
|
||||
function connexion($email, $password)
|
||||
{
|
||||
global $pdo;
|
||||
|
||||
// Vérification de l'existence de l'utilisateur et de son mot de passe
|
||||
$requete = $pdo->prepare('SELECT * FROM utilisateurs WHERE email = :email AND mot_de_passe = :mot_de_passe');
|
||||
$requete->bindParam(':email', $email);
|
||||
$requete->bindParam(':mot_de_passe', $password);
|
||||
$requete->execute();
|
||||
|
||||
$utilisateur = $requete->fetch();
|
||||
|
||||
if (!$utilisateur) {
|
||||
return 'Identifiants incorrects.';
|
||||
}
|
||||
|
||||
return $utilisateur;
|
||||
}
|
||||
|
||||
// Fonctions CRUD pour contacts
|
||||
function obtenir_contacts()
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->query('SELECT * FROM contacts ORDER BY id DESC');
|
||||
return $requete->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
function ajouter_contact($nom, $prenom, $email, $numero_telephone)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('INSERT INTO contacts (nom, prenom, email, numero_telephone) VALUES (:nom, :prenom, :email, :numero_telephone)');
|
||||
$requete->bindParam(':nom', $nom);
|
||||
$requete->bindParam(':prenom', $prenom);
|
||||
$requete->bindParam(':email', $email);
|
||||
$requete->bindParam(':numero_telephone', $numero_telephone);
|
||||
$requete->execute();
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
function modifier_contact($id, $nom, $prenom, $email, $numero_telephone)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('UPDATE contacts SET nom = :nom, prenom = :prenom, email = :email, numero_telephone = :numero_telephone WHERE id = :id');
|
||||
$requete->bindParam(':id', $id);
|
||||
$requete->bindParam(':nom', $nom);
|
||||
$requete->bindParam(':prenom', $prenom);
|
||||
$requete->bindParam(':email', $email);
|
||||
$requete->bindParam(':numero_telephone', $numero_telephone);
|
||||
$requete->execute();
|
||||
}
|
||||
|
||||
function supprimer_contact($id)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('DELETE FROM contacts WHERE id = :id');
|
||||
$requete->bindParam(':id', $id);
|
||||
$requete->execute();
|
||||
}
|
||||
|
||||
// Fonctions CRUD pour deals
|
||||
function obtenir_deals()
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->query('SELECT * FROM deals ORDER BY id DESC');
|
||||
return $requete->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
function ajouter_deal($nom_deal, $date_cloture, $valeur_deal, $contact_id)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('INSERT INTO deals (nom_deal, date_cloture, valeur_deal, contact_id) VALUES (:nom_deal, :date_cloture, :valeur_deal, :contact_id)');
|
||||
$requete->bindParam(':nom_deal', $nom_deal);
|
||||
$requete->bindParam(':date_cloture', $date_cloture);
|
||||
$requete->bindParam(':valeur_deal', $valeur_deal);
|
||||
$requete->bindParam(':contact_id', $contact_id);
|
||||
$requete->execute();
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
function modifier_deal($id, $nom_deal, $date_cloture, $valeur_deal, $contact_id)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('UPDATE deals SET nom_deal = :nom_deal, date_cloture = :date_cloture, valeur_deal = :valeur_deal, contact_id = :contact_id WHERE id = :id');
|
||||
$requete->bindParam(':id', $id);
|
||||
$requete->bindParam(':nom_deal', $nom_deal);
|
||||
$requete->bindParam(':date_cloture', $date_cloture);
|
||||
$requete->bindParam(':valeur_deal', $valeur_deal);
|
||||
$requete->bindParam(':contact_id', $contact_id);
|
||||
$requete->execute();
|
||||
}
|
||||
|
||||
function supprimer_deal($id)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('DELETE FROM deals WHERE id = :id');
|
||||
$requete->bindParam(':id', $id);
|
||||
$requete->execute();
|
||||
}
|
||||
|
||||
// Fonctions CRUD pour activités
|
||||
function obtenir_activites()
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->query('SELECT * FROM activites ORDER BY id DESC');
|
||||
return $requete->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
function ajouter_activite($type_activite, $date_activite, $contact_id)
|
||||
{
|
||||
global $pdo;
|
||||
$requete = $pdo->prepare('INSERT INTO activites (type_activite, date_activite, contact_id) VALUES (:type_activite, :date_activite, :contact_id)');
|
||||
$requete->bindParam(':type_activite', $type_activite);
|
||||
$requete->bindParam(':date_activite', $date_activite);
|
||||
$requete->bindParam(':contact_id', $contact_id);
|
||||
$requete->execute();
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
function modifier_activite($id, $type_activite, $date_activite,
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Salut ! En tant que WEVCODE, ton générateur de code souverain WEVAL, je te fournis ici une API REST complète, fonctionnelle et prête pour la production, entièrement contenue dans un seul fichier PHP pour ton CRM. Elle gère les Contacts, les Deals, les Étapes
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Salut, âme audacieuse de WEVAL ! Je suis WEVCODE, et je vais générer pour toi une API REST PHP 8.5 d'une robustesse et d'une clarté inégalées pour ton CRM. Cette solution monolithique est complète,
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE, générateur de code souverain WEVAL, est honoré de vous présenter une API REST complète, fonctionnelle et prête pour la production pour votre CRM. Ce fichier PHP unique inclut la gestion des routes CRUD pour les contacts, les deals, les pipelines, les étapes (stages
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE vous présente ce code souverain WEVAL, une API REST complète pour CRM, fonctionnelle, sans placeholders et prête pour la production. Ce fichier PHP unique gère les entités Contacts, Deals, Pipeline Stages, Activités et propose des rapports, avec des opérations CRUD via
|
||||
@@ -1,4 +0,0 @@
|
||||
<?php
|
||||
WEVCODE CRM API - PHP 8.5, PostgreSQL, REST
|
||||
|
||||
Voici le code PHP complet pour une API REST de CRM, respectant toutes vos exigences : fichier unique, production-ready, PHP 8.5, PostgreSQL, JSON, et gestion des entités Contacts, Deals
|
||||
@@ -1,187 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API REST pour votre dashboard analytique avec les caractéristiques souhaitées.
|
||||
|
||||
**dashboard.php**
|
||||
```php
|
||||
<?php
|
||||
// Configurazione database
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_USERNAME', ' votre_nom_utilisateur');
|
||||
define('DB_PASSWORD', 'votre_mot_de_passe');
|
||||
define('DB_NAME', 'votre_nom_base_de_données');
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = new PDO("pgsql:host=".DB_HOST.";dbname=".DB_NAME, DB_USERNAME, DB_PASSWORD);
|
||||
|
||||
// Fonction pour récupérer les données du dashboard
|
||||
function getDashboardData($filters = array()) {
|
||||
$sql = "SELECT * FROM your_table_name WHERE 1=1";
|
||||
$params = array();
|
||||
|
||||
// Ajout de filtres
|
||||
if (isset($filters['date_debut']) && isset($filters['date_fin'])) {
|
||||
$sql .= " AND date BETWEEN :date_debut AND :date_fin";
|
||||
$params[':date_debut'] = $filters['date_debut'];
|
||||
$params[':date_fin'] = $filters['date_fin'];
|
||||
}
|
||||
|
||||
if (isset($filters['categorie'])) {
|
||||
$sql .= " AND categorie = :categorie";
|
||||
$params[':categorie'] = $filters['categorie'];
|
||||
}
|
||||
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les KPIs
|
||||
function getKPIs($filters = array()) {
|
||||
$sql = "SELECT * FROM your_table_name WHERE 1=1";
|
||||
$params = array();
|
||||
|
||||
// Ajout de filtres
|
||||
if (isset($filters['date_debut']) && isset($filters['date_fin'])) {
|
||||
$sql .= " AND date BETWEEN :date_debut AND :date_fin";
|
||||
$params[':date_debut'] = $filters['date_debut'];
|
||||
$params[':date_fin'] = $filters['date_fin'];
|
||||
}
|
||||
|
||||
if (isset($filters['categorie'])) {
|
||||
$sql .= " AND categorie = :categorie";
|
||||
$params[':categorie'] = $filters['categorie'];
|
||||
}
|
||||
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour créer un nouveau point de données
|
||||
function createData($data) {
|
||||
$sql = "INSERT INTO your_table_name (categorie, value, date) VALUES (:categorie, :value, :date)";
|
||||
$params = array(':categorie' => $data['categorie'], ':value' => $data['value'], ':date' => $data['date']);
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un point de données
|
||||
function updateData($id, $data) {
|
||||
$sql = "UPDATE your_table_name SET categorie = :categorie, value = :value, date = :date WHERE id = :id";
|
||||
$params = array(':id' => $id, ':categorie' => $data['categorie'], ':value' => $data['value'], ':date' => $data['date']);
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un point de données
|
||||
function deleteData($id) {
|
||||
$sql = "DELETE FROM your_table_name WHERE id = :id";
|
||||
$params = array(':id' => $id);
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute($params);
|
||||
}
|
||||
|
||||
// Route pour récupérer les données du dashboard
|
||||
$app->get('/dashboard', function($request, $response, $args) {
|
||||
$filters = $request->getQueryParams();
|
||||
$data = getDashboardData($filters);
|
||||
return $response->withJson($data, 200);
|
||||
});
|
||||
|
||||
// Route pour récupérer les KPIs
|
||||
$app->get('/kpi', function($request, $response, $args) {
|
||||
$filters = $request->getQueryParams();
|
||||
$kpi = getKPIs($filters);
|
||||
return $response->withJson($kpi, 200);
|
||||
});
|
||||
|
||||
// Route pour créer un nouveau point de données
|
||||
$app->post('/data', function($request, $response, $args) {
|
||||
$data = json_decode($request->getBody()->getContents(), true);
|
||||
createData($data);
|
||||
return $response->withJson(array('message' => 'Point de données créé avec succès'), 201);
|
||||
});
|
||||
|
||||
// Route pour mettre à jour un point de données
|
||||
$app->put('/data/{id}', function($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$data = json_decode($request->getBody()->getContents(), true);
|
||||
updateData($id, $data);
|
||||
return $response->withJson(array('message' => 'Point de données mis à jour avec succès'), 200);
|
||||
});
|
||||
|
||||
// Route pour supprimer un point de données
|
||||
$app->delete('/data/{id}', function($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
deleteData($id);
|
||||
return $response->withJson(array('message' => 'Point de données supprimé avec succès'), 200);
|
||||
});
|
||||
```
|
||||
|
||||
**dashboard.js**
|
||||
```jsx
|
||||
import React, { useState, useEffect } from 'react';
|
||||
import axios from 'axios';
|
||||
|
||||
function Dashboard() {
|
||||
const [data, setData] = useState([]);
|
||||
const [kpi, setKpi] = useState([]);
|
||||
const [filters, setFilters] = useState({
|
||||
dateDebut: '',
|
||||
dateFin: '',
|
||||
categorie: ''
|
||||
});
|
||||
const [loading, setLoading] = useState(true);
|
||||
|
||||
useEffect(() => {
|
||||
const fetchData = async () => {
|
||||
setLoading(true);
|
||||
try {
|
||||
const response = await axios.get('/dashboard', {
|
||||
params: filters
|
||||
});
|
||||
setData(response.data);
|
||||
} catch (error) {
|
||||
console.error(error);
|
||||
} finally {
|
||||
setLoading(false);
|
||||
}
|
||||
};
|
||||
fetchData();
|
||||
}, [filters]);
|
||||
|
||||
useEffect(() => {
|
||||
const fetchKPI = async () => {
|
||||
setLoading(true);
|
||||
try {
|
||||
const response = await axios.get('/kpi', {
|
||||
params: filters
|
||||
});
|
||||
setKpi(response.data);
|
||||
} catch (error) {
|
||||
console.error(error);
|
||||
} finally {
|
||||
setLoading(false);
|
||||
}
|
||||
};
|
||||
fetchKPI();
|
||||
}, [filters]);
|
||||
|
||||
const handleFilterChange = (event) => {
|
||||
setFilters((prevFilters) => ({
|
||||
...prevFilters,
|
||||
[event.target.name]: event.target.value
|
||||
}));
|
||||
};
|
||||
|
||||
const handleExport = () => {
|
||||
axios.get('/dashboard', {
|
||||
params: filters,
|
||||
responseType: 'blob'
|
||||
})
|
||||
.then((response) => {
|
||||
const url = window.URL.createObjectURL(new Blob([response.data], { type: 'application/json' }));
|
||||
const a = document.createElement('a');
|
||||
a.href = url;
|
||||
@@ -1,8 +0,0 @@
|
||||
<?php
|
||||
```php
|
||||
<?php
|
||||
// WEVCODE - Générateur de code souverain WEVAL
|
||||
// API REST complète pour Dashboard analytique et Monitoring temps réel
|
||||
// PHP 8.5+, PostgreSQL, JSON, Production-ready, Fichier unique
|
||||
|
||||
// --- 0. Configuration de l
|
||||
@@ -1,219 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST en PHP pour un dashboard analytique :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la db
|
||||
$db_host = 'localhost';
|
||||
$db_name = 'analytique';
|
||||
$db_user = 'utilisateur';
|
||||
$db_password = 'mot_de_passe';
|
||||
|
||||
// Connexion à la db
|
||||
$connection = pg_connect("host=$db_host dbname=$db_name user=$db_user password=$db_password");
|
||||
if (!$connection) {
|
||||
echo 'Erreur de connexion à la base de données ' . pg_last_error() . '<br>';
|
||||
exit;
|
||||
}
|
||||
|
||||
// Definir les routes CRUD
|
||||
defined('BASE_URL') or define('BASE_URL', '');
|
||||
|
||||
// Router
|
||||
class Router {
|
||||
private $routes;
|
||||
|
||||
public function __construct() {
|
||||
$this->routes = [];
|
||||
}
|
||||
|
||||
public function get($path, $callback) {
|
||||
$this->routes[] = ['method' => 'GET', 'path' => $path, 'callback' => $callback];
|
||||
}
|
||||
|
||||
public function post($path, $callback) {
|
||||
$this->routes[] = ['method' => 'POST', 'path' => $path, 'callback' => $callback];
|
||||
}
|
||||
|
||||
public function run() {
|
||||
$path = explode('/', $_SERVER['REQUEST_URI'])[1];
|
||||
$method = $_SERVER['REQUEST_METHOD'];
|
||||
|
||||
foreach ($this->routes as $route) {
|
||||
if ($route['method'] == $method && $route['path'] == $path) {
|
||||
call_user_func($route['callback']);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
http_response_code(404);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['erreur' => 'Route non trouvée']);
|
||||
}
|
||||
}
|
||||
|
||||
// Récupérer les données de la db
|
||||
function get_data($request) {
|
||||
$query = "SELECT * FROM graphiques ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$data = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$data[] = [
|
||||
'label' => $ligne['label'],
|
||||
'value' => $ligne['value']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($data);
|
||||
}
|
||||
|
||||
// Créer une nouvelle entrée
|
||||
function create_entry($request) {
|
||||
$data = json_decode($request->get_body(), true);
|
||||
|
||||
$query = "INSERT INTO graphiques (label, value) VALUES ('$data[label]', '$data[value]')";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
http_response_code(201);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['message' => 'Entrée créée avec succès']);
|
||||
}
|
||||
|
||||
// Mise à jour d'une entrée existante
|
||||
function update_entry($request) {
|
||||
$data = json_decode($request->get_body(), true);
|
||||
|
||||
$query = "UPDATE graphiques SET label = '$data[label]', value = '$data[value]' WHERE id = " . $data['id'];
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['message' => 'Entrée mis à jour avec succès']);
|
||||
}
|
||||
|
||||
// Suppression d'une entrée
|
||||
function delete_entry($request) {
|
||||
$data = json_decode($request->get_body(), true);
|
||||
|
||||
$query = "DELETE FROM graphiques WHERE id = " . $data['id'];
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode(['message' => 'Entrée supprimée avec succès']);
|
||||
}
|
||||
|
||||
// Charger les éléments du menu
|
||||
function load_menu() {
|
||||
$query = "SELECT * FROM menu ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$menu = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$menu[] = $ligne['label'];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($menu);
|
||||
}
|
||||
|
||||
// Charger les données des graphiques
|
||||
function load_graphiques() {
|
||||
$query = "SELECT * FROM graphiques ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$graphiques = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$graphiques[] = [
|
||||
'label' => $ligne['label'],
|
||||
'value' => $ligne['value'],
|
||||
'id' => $ligne['id']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($graphiques);
|
||||
}
|
||||
|
||||
// Charger les données des KPIs
|
||||
function load_kpis() {
|
||||
$query = "SELECT * FROM kpis ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$kpis = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$kpis[] = [
|
||||
'label' => $ligne['label'],
|
||||
'value' => $ligne['value'],
|
||||
'id' => $ligne['id']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($kpis);
|
||||
}
|
||||
|
||||
// Charger les données de l'historique
|
||||
function load_historique() {
|
||||
$query = "SELECT * FROM historique ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$historique = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$historique[] = [
|
||||
'date' => $ligne['date'],
|
||||
'value' => $ligne['value'],
|
||||
'id' => $ligne['id']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($historique);
|
||||
}
|
||||
|
||||
// Charger les données de la page
|
||||
function load_page() {
|
||||
$query = "SELECT * FROM page ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$page = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$page[] = [
|
||||
'label' => $ligne['label'],
|
||||
'content' => $ligne['content'],
|
||||
'id' => $ligne['id']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($page);
|
||||
}
|
||||
|
||||
// Charger les données des paramètres
|
||||
function load_params() {
|
||||
$query = "SELECT * FROM parametre ORDER BY id";
|
||||
$result = pg_query($connection, $query);
|
||||
|
||||
$params = [];
|
||||
while ($ligne = pg_fetch_array($result)) {
|
||||
$params[] = [
|
||||
'label' => $ligne['label'],
|
||||
'value' => $ligne['value'],
|
||||
'id' => $ligne['id']
|
||||
];
|
||||
}
|
||||
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($params);
|
||||
}
|
||||
|
||||
// Charger les données de la page d'authentification
|
||||
@@ -1,140 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique et un kanban projet agile :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à PostgreSQL
|
||||
$dsn = "host=localhost dbname=monbdd user=monutilisateur password=monmotdepasse";
|
||||
$conn = new PDO($dsn);
|
||||
|
||||
// Fonction pour traiter les requêtes GET
|
||||
function get($method, $params) {
|
||||
switch ($method) {
|
||||
case "dashboards":
|
||||
// Récupérer les dashboards
|
||||
$sql = "SELECT * FROM dashboards";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$dashboards = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($dashboards);
|
||||
case "kanban":
|
||||
// Récupérer les tâches du kanban
|
||||
$sql = "SELECT * FROM taches";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$taches = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($taches);
|
||||
case "charts":
|
||||
// Récupérer les données pour les charts
|
||||
$sql = "SELECT * FROMdonnees_charts";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$donnees_charts = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($donnees_charts);
|
||||
case "kpi":
|
||||
// Récupérer les KPIs
|
||||
$sql = "SELECT * FROM kpis";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$kpis = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($kpis);
|
||||
case "filtres":
|
||||
// Récupérer les filtres
|
||||
$sql = "SELECT * FROM filtres";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$filtres = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($filtres);
|
||||
case "export":
|
||||
// Exporter les données
|
||||
$sql = "SELECT * FROM donnéesexport";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$donnees_export = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return json_encode($donnees_export);
|
||||
default:
|
||||
return json_encode(array("erreur" => "Méthode GET non supportée"));
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour traiter les requêtes POST
|
||||
function post($method, $data) {
|
||||
switch ($method) {
|
||||
case "dashboard":
|
||||
// Créer un nouveau dashboard
|
||||
$sql = "INSERT INTO dashboards (nom, description) VALUES (:nom, :description)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":nom", $data["nom"]);
|
||||
$stmt->bindParam(":description", $data["description"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Dashboard créé avec succès"));
|
||||
case "tache":
|
||||
// Créer une nouvelle tâche
|
||||
$sql = "INSERT INTO taches (titre, description, état) VALUES (:titre, :description, :état)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":titre", $data["titre"]);
|
||||
$stmt->bindParam(":description", $data["description"]);
|
||||
$stmt->bindParam(":état", $data["etat"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Tâche créée avec succès"));
|
||||
case "donnees_charts":
|
||||
// Créer de nouvelles données pour les charts
|
||||
$sql = "INSERT INTO données_charts (label, valeur) VALUES (:label, :valeur)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":label", $data["label"]);
|
||||
$stmt->bindParam(":valeur", $data["valeur"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Données de chart créées avec succès"));
|
||||
case "kpis":
|
||||
// Créer un nouveau KPI
|
||||
$sql = "INSERT INTO kpis (label, valeur) VALUES (:label, :valeur)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":label", $data["label"]);
|
||||
$stmt->bindParam(":valeur", $data["valeur"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "KPI créé avec succès"));
|
||||
case "filtres":
|
||||
// Créer un nouveau filtre
|
||||
$sql = "INSERT INTO filtres (label, valeur) VALUES (:label, :valeur)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":label", $data["label"]);
|
||||
$stmt->bindParam(":valeur", $data["valeur"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Filtre créé avec succès"));
|
||||
default:
|
||||
return json_encode(array("erreur" => "Méthode POST non supportée"));
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour traiter les requêtes PUT
|
||||
function put($method, $data) {
|
||||
switch ($method) {
|
||||
case "dashboard":
|
||||
// Mettre à jour un dashboard
|
||||
$sql = "UPDATE dashboards SET nom = :nom, description = :description WHERE id = :id";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":nom", $data["nom"]);
|
||||
$stmt->bindParam(":description", $data["description"]);
|
||||
$stmt->bindParam(":id", $data["id"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Dashboard mis à jour avec succès"));
|
||||
case "tache":
|
||||
// Mettre à jour une tâche
|
||||
$sql = "UPDATE taches SET titre = :titre, description = :description, état = :état WHERE id = :id";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":titre", $data["titre"]);
|
||||
$stmt->bindParam(":description", $data["description"]);
|
||||
$stmt->bindParam(":état", $data["etat"]);
|
||||
$stmt->bindParam(":id", $data["id"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Tâche mise à jour avec succès"));
|
||||
case "donnees_charts":
|
||||
// Mettre à jour les données de chart
|
||||
$sql = "UPDATE données_charts SET label = :label, valeur = :valeur WHERE id = :id";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(":label", $data["label"]);
|
||||
$stmt->bindParam(":valeur", $data["valeur"]);
|
||||
$stmt->bindParam(":id", $data["id"]);
|
||||
$stmt->execute();
|
||||
return json_encode(array("message" => "Données de chart mises à jour avec succès"));
|
||||
case "kp
|
||||
@@ -1,204 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API REST qui répond à vos besoins. Ce code utilise PHP 8.5, PostgreSQL et les technologies standards (HTML5, CSS3, JavaScript) pour le front-end. Il est divisé en plusieurs sections :
|
||||
|
||||
**Section 1 : Configurations**
|
||||
|
||||
Nous définissons d'abord les configurations pour notre API. Cela inclut la connection à notre base de données PostgreSQL et les paramètres pour notre API.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configurations
|
||||
$db_host = 'localhost';
|
||||
$db_name = 'dashboard_analytics';
|
||||
$db_username = 'utilisateur';
|
||||
$db_password = 'mot_de_passe';
|
||||
|
||||
// Connection à la base de données
|
||||
$conn = pg_connect("host=$db_host dbname=$db_name user=$db_username password=$db_password")
|
||||
or die('Une erreur s\'est produite : ' . pg_last_error());
|
||||
```
|
||||
|
||||
**Section 2 : Modèles de données**
|
||||
|
||||
Nous définissons ensuite les modèles de données pour nos entités.
|
||||
|
||||
```php
|
||||
// Modèle pour les visiteurs
|
||||
class Visiteur {
|
||||
public $id;
|
||||
public $page;
|
||||
public $conversion;
|
||||
|
||||
function __construct($id, $page, $conversion) {
|
||||
$this->id = $id;
|
||||
$this->page = $page;
|
||||
$this->conversion = $conversion;
|
||||
}
|
||||
|
||||
function getJson() {
|
||||
return json_encode([
|
||||
'id' => $this->id,
|
||||
'page' => $this->page,
|
||||
'conversion' => $this->conversion
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// Modèle pour les KPIs
|
||||
class KPI {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $valeur;
|
||||
|
||||
function __construct($id, $nom, $valeur) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->valeur = $valeur;
|
||||
}
|
||||
|
||||
function getJson() {
|
||||
return json_encode([
|
||||
'id' => $this->id,
|
||||
'nom' => $this->nom,
|
||||
'valeur' => $this->valeur
|
||||
]);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Section 3 : Fonctions CRUD**
|
||||
|
||||
Nous définissons ensuite les fonctions CRUD pour nos entités.
|
||||
|
||||
```php
|
||||
// Fonction pour lister les visiteurs
|
||||
function getVisitants() {
|
||||
$req = pg_query("SELECT * FROM visiteurs");
|
||||
$resultat = pg_fetch_all($req);
|
||||
$listeVisiteurs = [];
|
||||
|
||||
foreach ($resultat as $visiteur) {
|
||||
$listeVisiteurs[] = new Visiteur($visiteur['id'], $visiteur['page'], $visiteur['conversion']);
|
||||
}
|
||||
|
||||
return json_encode($listeVisiteurs);
|
||||
}
|
||||
|
||||
// Fonction pour créer un nouveau visiteur
|
||||
function createVisiteur($page, $conversion) {
|
||||
$req = pg_query("INSERT INTO visiteurs (page, conversion) VALUES ('$page', '$conversion')");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un visiteur existant
|
||||
function updateVisiteur($id, $page, $conversion) {
|
||||
$req = pg_query("UPDATE visiteurs SET page = '$page', conversion = '$conversion' WHERE id = $id");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un visiteur
|
||||
function deleteVisiteur($id) {
|
||||
$req = pg_query("DELETE FROM visiteurs WHERE id = $id");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
|
||||
// Fonction pour lister les KPIs
|
||||
function getKPIs() {
|
||||
$req = pg_query("SELECT * FROM kpis");
|
||||
$resultat = pg_fetch_all($req);
|
||||
$listeKPIs = [];
|
||||
|
||||
foreach ($resultat as $kpi) {
|
||||
$listeKPIs[] = new KPI($kpi['id'], $kpi['nom'], $kpi['valeur']);
|
||||
}
|
||||
|
||||
return json_encode($listeKPIs);
|
||||
}
|
||||
|
||||
// Fonction pour créer un nouveau KPI
|
||||
function createKPI($nom, $valeur) {
|
||||
$req = pg_query("INSERT INTO kpis (nom, valeur) VALUES ('$nom', '$valeur')");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un KPI existant
|
||||
function updateKPI($id, $nom, $valeur) {
|
||||
$req = pg_query("UPDATE kpis SET nom = '$nom', valeur = '$valeur' WHERE id = $id");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un KPI
|
||||
function deleteKPI($id) {
|
||||
$req = pg_query("DELETE FROM kpis WHERE id = $id");
|
||||
return json_encode(['status' => true]);
|
||||
}
|
||||
```
|
||||
|
||||
**Section 4 : API REST**
|
||||
|
||||
Nous définissons ensuite les routes de notre API.
|
||||
|
||||
```php
|
||||
// Route pour récupérer les visiteurs
|
||||
function route_get_visitants() {
|
||||
return getVisitants();
|
||||
}
|
||||
|
||||
// Route pour créer un nouveau visiteur
|
||||
function route_post_visiteur() {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
return createVisiteur($data['page'], $data['conversion']);
|
||||
}
|
||||
|
||||
// Route pour mettre à jour un visiteur
|
||||
function route_put_visiteur($id) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
return updateVisiteur($id, $data['page'], $data['conversion']);
|
||||
}
|
||||
|
||||
// Route pour supprimer un visiteur
|
||||
function route_delete_visiteur($id) {
|
||||
return deleteVisiteur($id);
|
||||
}
|
||||
|
||||
// Route pour récupérer les KPIs
|
||||
function route_get_kpis() {
|
||||
return getKPIs();
|
||||
}
|
||||
|
||||
// Route pour créer un nouveau KPI
|
||||
function route_post_kpi() {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
return createKPI($data['nom'], $data['valeur']);
|
||||
}
|
||||
|
||||
// Route pour mettre à jour un KPI
|
||||
function route_put_kpi($id) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
return updateKPI($id, $data['nom'], $data['valeur']);
|
||||
}
|
||||
|
||||
// Route pour supprimer un KPI
|
||||
function route_delete_kpi($id) {
|
||||
return deleteKPI($id);
|
||||
}
|
||||
```
|
||||
|
||||
**Section 5 : Front-end**
|
||||
|
||||
Nous définissons ensuite la structure de notre front-end.
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Page de dashboard</title>
|
||||
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/css/bootstrap.min.css">
|
||||
</head>
|
||||
<body>
|
||||
<nav class="navbar navbar-expand-lg navbar-light bg-light">
|
||||
<a class="navbar-brand" href="#">Dashboard</a>
|
||||
<button class
|
||||
@@ -1,193 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour un dashboard analytique avec chartes, KPI, filtres, et export. Il utilise les technologies PHP 8.5, PostgreSQL, HTML5/CSS3/JS, et REST API.
|
||||
|
||||
**db.php**
|
||||
```php
|
||||
// Configuration de la connexion à la base de données
|
||||
$conn = pg_connect('host=localhost dbname=dashboard user=username password=password');
|
||||
|
||||
if (!$conn) {
|
||||
echo "Erreur de connexion à la base de données : " . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
```
|
||||
|
||||
**dashboard.php**
|
||||
```php
|
||||
<?php
|
||||
require_once 'db.php';
|
||||
|
||||
// Faire une requête pour récupérer les KPI
|
||||
$kpiQuery = 'SELECT * FROM kpi';
|
||||
$kpiResult = pg_query($conn, $kpiQuery);
|
||||
$kpiData = pg_fetch_all($kpiResult);
|
||||
|
||||
// Faire une requête pour récupérer les données de chartes
|
||||
$chartQuery = 'SELECT * FROM chart_data';
|
||||
$chartResult = pg_query($conn, $chartQuery);
|
||||
$chartData = pg_fetch_all($chartResult);
|
||||
|
||||
?>
|
||||
|
||||
<!DOCTYPE html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Dashboard Analytique</title>
|
||||
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css">
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
|
||||
<script src="https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<h1>Dashboard Analytique</h1>
|
||||
<form id="filtrage">
|
||||
<select id="filtre">
|
||||
<option value="">Filtrer</option>
|
||||
<?php foreach ($kpiData as $key => $value) { ?>
|
||||
<option value="<?php echo $key; ?>"><?php echo $value['kpi_name']; ?></option>
|
||||
<?php } ?>
|
||||
</select>
|
||||
<button type="submit" class="btn btn-primary">Filtrer</button>
|
||||
</form>
|
||||
<div id="charts">
|
||||
<?php foreach ($chartData as $key => $value) { ?>
|
||||
<canvas id="myChart<?php echo $key; ?>"></canvas>
|
||||
<?php } ?>
|
||||
</div>
|
||||
<div id="kpi">
|
||||
<h2>KPI</h2>
|
||||
<table class="table table-striped">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>KPI</th>
|
||||
<th>Valeur</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<?php foreach ($kpiData as $key => $value) { ?>
|
||||
<tr>
|
||||
<td><?php echo $value['kpi_name']; ?></td>
|
||||
<td><?php echo $value['kpi_value']; ?></td>
|
||||
</tr>
|
||||
<?php } ?>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<div id="export">
|
||||
<button id="btn-export" class="btn btn-primary">Exporter les données</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
$(document).ready(function () {
|
||||
// Mettre à jour les chartes lors du filtrage
|
||||
$('#filtrage').submit(function (e) {
|
||||
e.preventDefault();
|
||||
var filtre = $('#filtre').val();
|
||||
if (filtre === '') {
|
||||
location.reload();
|
||||
} else {
|
||||
// Mettre à jour les données de chartes
|
||||
$.get('/chart_data?filtre=' + filtre, function (data) {
|
||||
if (data.length > 0) {
|
||||
// Mettre à jour les chartes
|
||||
$.each(data, function (index, value) {
|
||||
var chartCanvas = $('#myChart' + index);
|
||||
if (chartCanvas.length > 0) {
|
||||
var ctx = chartCanvas[0].getContext('2d');
|
||||
var chart = new Chart(ctx, {
|
||||
type: 'line',
|
||||
data: {
|
||||
labels: value.labels,
|
||||
datasets: [{
|
||||
label: value.dataset_label,
|
||||
data: value.datasets,
|
||||
backgroundColor: value.backgroundColor,
|
||||
borderColor: value.borderColor,
|
||||
borderWidth: 1
|
||||
}]
|
||||
},
|
||||
options: {
|
||||
responsive: true,
|
||||
scales: {
|
||||
yAxes: [{
|
||||
ticks: {
|
||||
beginAtZero: true
|
||||
}
|
||||
}]
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
} else {
|
||||
alert('Aucune donnée trouvée');
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Exporter les données
|
||||
$('#btn-export').click(function () {
|
||||
var filtre = $('#filtre').val();
|
||||
if (filtre === '') {
|
||||
alert('SVP sélectionnez un KPI');
|
||||
} else {
|
||||
$.ajax({
|
||||
type: 'GET',
|
||||
url: '/data_export?filtre=' + filtre,
|
||||
contentType: 'application/json',
|
||||
success: function (data) {
|
||||
var blob = new Blob([data], { type: 'application/csv' });
|
||||
var a = document.createElement('a');
|
||||
a.href = URL.createObjectURL(blob);
|
||||
a.download = 'data-' + new Date().toISOString() + '.csv';
|
||||
a.click();
|
||||
},
|
||||
error: function (xhr, status, error) {
|
||||
alert('Erreur lors de l\'exportation');
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
</script>
|
||||
|
||||
<?php
|
||||
foreach ($chartData as $key => $value) {
|
||||
echo '<script>';
|
||||
echo 'var ctx = document.getElementById("myChart' . $key . '").getContext(' . "'2d' . '");';
|
||||
echo 'var chart = new Chart(ctx, {';
|
||||
echo 'type: "line",';
|
||||
echo 'data: {' . 'labels: ' . json_encode($value['labels']) . ',';
|
||||
echo 'datasets: [' . '{';
|
||||
echo 'label: "' . $value['dataset_label'] . '",';
|
||||
echo 'data: ' . json_encode($value['datasets']) . ',';
|
||||
echo 'backgroundColor: "' . $value['backgroundColor'] . '",';
|
||||
echo 'borderColor: "' . $value['borderColor'] . '",';
|
||||
echo 'borderWidth: 1';
|
||||
echo '}';
|
||||
echo ']';
|
||||
echo '},';
|
||||
echo 'options: {' . 'responsive: true,' . '}';
|
||||
echo '});';
|
||||
echo '</script>';
|
||||
}
|
||||
?>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
**routes.php**
|
||||
```php
|
||||
<?php
|
||||
require_once 'db.php';
|
||||
|
||||
// Récupérer les données de chartes
|
||||
function getChartData($filtre = '') {
|
||||
$query = 'SELECT * FROM chart_data WHERE kpi_id = :filtre';
|
||||
$params = array(':filtre' => $filtre);
|
||||
$result = pg_query_params($conn, $query, $params);
|
||||
return pg_fetch_all
|
||||
@@ -1,109 +0,0 @@
|
||||
<?php
|
||||
**Fichier index.php complet**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
$dbHost = 'localhost';
|
||||
$dbName = 'database_name';
|
||||
$dbUser = 'database_user';
|
||||
$dbPass = 'database_password';
|
||||
|
||||
// Formulaire de connexion
|
||||
$dsn = "pgsql:host=$dbHost;dbname=$dbName";
|
||||
$options = [
|
||||
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_EMULATE_PREPARES => false,
|
||||
];
|
||||
$pdo = new PDO($dsn, $dbUser, $dbPass, $options);
|
||||
|
||||
// Configuration de l'API REST
|
||||
$routes = [];
|
||||
|
||||
// Route pour la récupération des données
|
||||
$routes['GET /data'] = function() use ($pdo) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM donnees');
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetchAll();
|
||||
return json_encode($donnees);
|
||||
};
|
||||
|
||||
// Route pour la création de données
|
||||
$routes['POST /data'] = function() use ($pdo) {
|
||||
$donnees = json_decode(file_get_contents('php://input'), true);
|
||||
$stmt = $pdo->prepare('INSERT INTO donnees SET colonne1 = :colonne1, colonne2 = :colonne2');
|
||||
$stmt->execute($donnees);
|
||||
return json_encode(['message' => 'Donnée créée avec succès']);
|
||||
};
|
||||
|
||||
// Route pour la mise à jour de données
|
||||
$routes['PUT /data/:id'] = function($id) use ($pdo) {
|
||||
$donnees = json_decode(file_get_contents('php://input'), true);
|
||||
$stmt = $pdo->prepare('UPDATE donnees SET colonne1 = :colonne1, colonne2 = :colonne2 WHERE id = :id');
|
||||
$stmt->execute([...$donnees, 'id' => (int)$id]);
|
||||
return json_encode(['message' => 'Donnée mise à jour avec succès']);
|
||||
};
|
||||
|
||||
// Route pour la suppression de données
|
||||
$routes['DELETE /data/:id'] = function($id) use ($pdo) {
|
||||
$stmt = $pdo->prepare('DELETE FROM donnees WHERE id = :id');
|
||||
$stmt->execute(['id' => (int)$id]);
|
||||
return json_encode(['message' => 'Donnée supprimée avec succès']);
|
||||
};
|
||||
|
||||
// Fonction pour gérer les requêtes HTTP
|
||||
function handleRequest($method, $uri, $getData = false) {
|
||||
global $routes;
|
||||
foreach ($routes as $route => $callback) {
|
||||
if ($route === $uri && $method === 'GET') {
|
||||
return $callback();
|
||||
} elseif (strpos($route, $method) === 0 && str_replace($method, '', $route) === ltrim($uri, '/' )) {
|
||||
return $callback(str_replace('/' . $method, '', $route, 1));
|
||||
}
|
||||
}
|
||||
if ($getData) {
|
||||
return '404 Not Found';
|
||||
} else {
|
||||
return json_encode(['error' => '404 Not Found']);
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour configurer le serveur Web
|
||||
function configureServer() {
|
||||
Header('Content-Type: application/json; charset=UTF-8');
|
||||
$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
|
||||
$method = $_SERVER['REQUEST_METHOD'];
|
||||
if ($method === 'OPTIONS') {
|
||||
Header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');
|
||||
}
|
||||
echo handleRequest($method, $uri, true);
|
||||
}
|
||||
|
||||
configureServer();
|
||||
|
||||
?>
|
||||
```
|
||||
**Tableau de base de données**
|
||||
```sql
|
||||
CREATE TABLE donnees (
|
||||
id SERIAL PRIMARY KEY,
|
||||
colonne1 VARCHAR(255),
|
||||
colonne2 VARCHAR(255)
|
||||
);
|
||||
```
|
||||
**Example usage**
|
||||
|
||||
Pour accéder au dashboard analytique, vous pouvez utiliser l'URL `http://localhost/index.php/data`. Pour récupérer les données, vous pouvez envoyer une requête GET sur cette URL.
|
||||
|
||||
Pour créer des données, vous pouvez envoyer une requête POST sur l'URL `http://localhost/index.php/data` avec le corps de la requête contenant les données à créer.
|
||||
|
||||
Pour mettre à jour des données, vous pouvez envoyer une requête PUT sur l'URL `http://localhost/index.php/data/:id` avec le corps de la requête contenant les modifications à apporter.
|
||||
|
||||
Pour supprimer des données, vous pouvez envoyer une requête DELETE sur l'URL `http://localhost/index.php/data/:id`.
|
||||
|
||||
Les données sont répondues sous forme de JSON.
|
||||
|
||||
**Note**
|
||||
|
||||
Il est important de noter que ce code est juste un exemple et doit être adapté à vos besoins spécifiques. Vous devrez modifier la configuration de la base de données, les routes et les fonctions pour qu'elles correspondent à vos besoins. De plus, il est recommandé d'ajouter des vérifications et des sécurités supplémentaires pour éviter les attaques et les vulnérabilités.
|
||||
@@ -1,187 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique :
|
||||
|
||||
```php
|
||||
<?php
|
||||
// Configuration de la base de données
|
||||
|
||||
const DB_HOST = 'localhost';
|
||||
const DB_USER = 'utilisateur';
|
||||
const DB_PASSWORD = 'motdepassse';
|
||||
const DB_NAME = 'exemple';
|
||||
|
||||
// Configuration de l'application
|
||||
|
||||
const APP_NAME = 'Dashboard Exemple';
|
||||
const APP_VERSION = '1.0';
|
||||
|
||||
// Configuration des routes
|
||||
|
||||
route::get('/api/v1/dashboard', 'DashboardController@index');
|
||||
route::get('/api/v1/dashboard/{id}', 'DashboardController@show');
|
||||
route::post('/api/v1/dashboard', 'DashboardController@store');
|
||||
route::put('/api/v1/dashboard/{id}', 'DashboardController@update');
|
||||
route::delete('/api/v1/dashboard/{id}', 'DashboardController@destroy');
|
||||
|
||||
// Récupération des données de la base de données
|
||||
|
||||
function getConnexion() {
|
||||
try {
|
||||
$connection = pg_connect("host=" . DB_HOST . " dbname=" . DB_NAME . " user=" . DB_USER . " password=" . DB_PASSWORD);
|
||||
if(!$connection) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
return $connection;
|
||||
} catch (Exception $e) {
|
||||
echo 'Erreur de connexiom : ' . $e->getMessage();
|
||||
}
|
||||
}
|
||||
|
||||
// Génération du dashboard
|
||||
|
||||
function genererDashboard($donnees) {
|
||||
return [
|
||||
'title' => APP_NAME,
|
||||
'version' => APP_VERSION,
|
||||
'donnees' => $donnees,
|
||||
'charts' => [
|
||||
[
|
||||
'label' => 'Chiffre d\'affaires',
|
||||
'series' => [
|
||||
['label' => 'Janvier', 'value' => $donnees['chiffre_d_affaires']['janvier']],
|
||||
['label' => 'Février', 'value' => $donnees['chiffre_d_affaires']['février']],
|
||||
['label' => 'Mars', 'value' => $donnees['chiffre_d_affaires']['mars']],
|
||||
],
|
||||
],
|
||||
[
|
||||
'label' => 'Nombre de clients',
|
||||
'series' => [
|
||||
['label' => 'Janvier', 'value' => $donnees['nombre_clients']['janvier']],
|
||||
['label' => 'Février', 'value' => $donnees['nombre_clients']['février']],
|
||||
['label' => 'Mars', 'value' => $donnees['nombre_clients']['mars']],
|
||||
],
|
||||
],
|
||||
],
|
||||
'KPIs' => [
|
||||
[
|
||||
'label' => 'Taux de croissance',
|
||||
'value' => $donnees['taux_de_croissance'],
|
||||
],
|
||||
[
|
||||
'label' => 'Nombre de vents',
|
||||
'value' => $donnees['nombre_vels'],
|
||||
],
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
// Gestion des requests
|
||||
|
||||
class DashboardController
|
||||
{
|
||||
public function index() {
|
||||
$connection = getConnexion();
|
||||
$requete = "SELECT * FROM DONNEES";
|
||||
$resultats = pg_query($connection, $requete);
|
||||
if(!$resultats) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
$donnees = array();
|
||||
while($ligne = pg_fetch_assoc($resultats)) {
|
||||
$donnees['chiffre_d_affaires'][$ligne['mois']] = $ligne['chiffre_d_affaires'];
|
||||
$donnees['nombre_clients'][$ligne['mois']] = $ligne['nombre_clients'];
|
||||
}
|
||||
$donnees['taux_de_croissance'] = $donnees['chiffre_d_affaires']['mars'] / $donnees['chiffre_d_affaires']['janvier'];
|
||||
$donnees['nombre_vels'] = 10;
|
||||
echo json_encode(genererDashboard($donnees));
|
||||
}
|
||||
|
||||
public function show($id) {
|
||||
$connection = getConnexion();
|
||||
$requete = "SELECT * FROM DONNEES WHERE id = " . $id;
|
||||
$resultats = pg_query($connection, $requete);
|
||||
if(!$resultats) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
$ligne = pg_fetch_assoc($resultats);
|
||||
echo json_encode(genererDashboard($ligne));
|
||||
}
|
||||
|
||||
public function store() {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$connection = getConnexion();
|
||||
$requete = "INSERT INTO DONNEES (chiffre_d_affaires, nombre_clients, mois) VALUES (:chiffre_d_affaires, :nombre_clients, :mois)";
|
||||
$resultats = pg_execute($connection, $requete, [
|
||||
'param_name' => ':param_name',
|
||||
'chiffre_d_affaires' => $data['chiffre_d_affaires'],
|
||||
'nombre_clients' => $data['nombre_clients'],
|
||||
'mois' => $data['mois'],
|
||||
]);
|
||||
if(!$resultats) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
echo 'Donnée ajoutée avec succès';
|
||||
}
|
||||
|
||||
public function update($id) {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$connection = getConnexion();
|
||||
$requete = "UPDATE DONNEES SET chiffre_d_affaires = :chiffre_d_affaires, nombre_clients = :nombre_clients, mois = :mois WHERE id = " . $id;
|
||||
$resultats = pg_execute($connection, $requete, [
|
||||
'param_name' => ':param_name',
|
||||
'chiffre_d_affaires' => $data['chiffre_d_affaires'],
|
||||
'nombre_clients' => $data['nombre_clients'],
|
||||
'mois' => $data['mois'],
|
||||
]);
|
||||
if(!$resultats) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
echo 'Donnée mise à jour avec succès';
|
||||
}
|
||||
|
||||
public function destroy($id) {
|
||||
$connection = getConnexion();
|
||||
$requete = "DELETE FROM DONNEES WHERE id = " . $id;
|
||||
$resultats = pg_query($connection, $requete);
|
||||
if(!$resultats) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
echo 'Donnée supprimée avec succès';
|
||||
}
|
||||
}
|
||||
?>
|
||||
```
|
||||
|
||||
```php
|
||||
<?php
|
||||
// Classe de génération des routes
|
||||
|
||||
class Route
|
||||
{
|
||||
private $methodes;
|
||||
private $url;
|
||||
private $controller;
|
||||
|
||||
public function __construct($methodes, $url, $controller) {
|
||||
$this->methodes = $methodes;
|
||||
$this->url = $url;
|
||||
$this->controller = $controller;
|
||||
}
|
||||
|
||||
public function get($url) {
|
||||
$this->methodes['GET'] = $url;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function post($url) {
|
||||
$this->methodes['POST'] = $url;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function put($url) {
|
||||
$this->methodes['PUT'] = $url;
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function delete($url) {
|
||||
$
|
||||
@@ -1,152 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP pour une API REST pour un dashboard analytique avec charts, KPIs, filtres, export :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données PostgreSQL
|
||||
$host = 'localhost';
|
||||
$dbname = 'database_name';
|
||||
$user = 'username';
|
||||
$password = 'password';
|
||||
|
||||
// Connexion à la base de données
|
||||
$dsn = "pgsql:host=$host;dbname=$dbname";
|
||||
$options = [
|
||||
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_EMUL_PROCTER => false,
|
||||
];
|
||||
attempts = 0;
|
||||
while (!$pdo = new PDO($dsn, $user, $password, $options)) {
|
||||
if (attempts 10) {
|
||||
sleep(1);
|
||||
attempts++;
|
||||
} else {
|
||||
throw new \PDOException('Could not connect to database');
|
||||
}
|
||||
}
|
||||
|
||||
// Route GET pour récupérer les données du dashboard
|
||||
$app->get('/', function (Request $request, Response $response) use ($pdo) {
|
||||
$sql = 'SELECT * FROM données';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetchAll();
|
||||
$response->getBody()->write(json_encode($donnees));
|
||||
return $response->withHeader('Content-type', 'application/json');
|
||||
});
|
||||
|
||||
// Route GET pour récupérer un KPI spécifique
|
||||
$app->get('/kpi/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$sql = 'SELECT * FROM kpi WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetch();
|
||||
if ($donnees) {
|
||||
$response->getBody()->write(json_encode($donnees));
|
||||
return $response->withHeader('Content-type', 'application/json');
|
||||
} else {
|
||||
return $response->withStatus(404);
|
||||
}
|
||||
});
|
||||
|
||||
// Route POST pour créer un nouveau KPI
|
||||
$app->post('/kpi', function (Request $request, Response $response) use ($pdo) {
|
||||
$donnees = $request->getParsedBody();
|
||||
$sql = 'INSERT INTO kpi (nom, valeur) VALUES (:nom, :valeur)';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':nom', $donnees['nom']);
|
||||
$stmt->bindParam(':valeur', $donnees['valeur']);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(201);
|
||||
});
|
||||
|
||||
// Route PUT pour mettre à jour un KPI existant
|
||||
$app->put('/kpi/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
$sql = 'UPDATE kpi SET nom = :nom, valeur = :valeur WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->bindParam(':nom', $donnees['nom']);
|
||||
$stmt->bindParam(':valeur', $donnees['valeur']);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(200);
|
||||
});
|
||||
|
||||
// Route DELETE pour supprimer un KPI
|
||||
$app->delete('/kpi/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$sql = 'DELETE FROM kpi WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(204);
|
||||
});
|
||||
|
||||
// Route GET pour récupérer les données du chart
|
||||
$app->get('/chart', function (Request $request, Response $response) use ($pdo) {
|
||||
$sql = 'SELECT * FROM chart';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetchAll();
|
||||
$response->getBody()->write(json_encode($donnees));
|
||||
return $response->withHeader('Content-type', 'application/json');
|
||||
});
|
||||
|
||||
// Route GET pour récupérer un filtre spécifique
|
||||
$app->get('/filtrer/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$sql = 'SELECT * FROM filtre WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetch();
|
||||
if ($donnees) {
|
||||
$response->getBody()->write(json_encode($donnees));
|
||||
return $response->withHeader('Content-type', 'application/json');
|
||||
} else {
|
||||
return $response->withStatus(404);
|
||||
}
|
||||
});
|
||||
|
||||
// Route POST pour créer un nouveau filtre
|
||||
$app->post('/filtrer', function (Request $request, Response $response) use ($pdo) {
|
||||
$donnees = $request->getParsedBody();
|
||||
$sql = 'INSERT INTO filtre (nom, valeur) VALUES (:nom, :valeur)';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':nom', $donnees['nom']);
|
||||
$stmt->bindParam(':valeur', $donnees['valeur']);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(201);
|
||||
});
|
||||
|
||||
// Route PUT pour mettre à jour un filtre existant
|
||||
$app->put('/filtrer/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
$sql = 'UPDATE filtre SET nom = :nom, valeur = :valeur WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->bindParam(':nom', $donnees['nom']);
|
||||
$stmt->bindParam(':valeur', $donnees['valeur']);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(200);
|
||||
});
|
||||
|
||||
// Route DELETE pour supprimer un filtre
|
||||
$app->delete('/filtrer/{id}', function (Request $request, Response $response, array $args) use ($pdo) {
|
||||
$id = (int) $args['id'];
|
||||
$sql = 'DELETE FROM filtre WHERE id = :id';
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
return $response->withStatus(204);
|
||||
});
|
||||
|
||||
// Route GET pour exporter les données
|
||||
$app->get('/export', function (Request $request, Response $response) use ($pdo) {
|
||||
$sql = 'SELECT * FROM données';
|
||||
$stmt = $
|
||||
@@ -1,181 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration PostgreSQL
|
||||
const DB_HOST = 'localhost';
|
||||
const DB_NAME = 'example';
|
||||
const DB_USER = 'user';
|
||||
const DB_PASSWORD = 'password';
|
||||
|
||||
// connexion à la base de données
|
||||
function dbConnect() {
|
||||
$conn = pg_connect("host=" . DB_HOST . " dbname=" . DB_NAME . " user=" . DB_USER . " password=" . DB_PASSWORD);
|
||||
if (!$conn) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
return $conn;
|
||||
}
|
||||
|
||||
// fonction de lecture des données de la base de données
|
||||
function fetchData($request) {
|
||||
$conn = dbConnect();
|
||||
$result = pg_query_params($conn, "SELECT * FROM users where id = $1", array($request['id']));
|
||||
if (!$result) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
$data = pg_fetch_all($result);
|
||||
pg_close($conn);
|
||||
return $data;
|
||||
}
|
||||
|
||||
// fonction de création ou mise à jour de données en base de données
|
||||
function saveData($request) {
|
||||
$conn = dbConnect();
|
||||
if (isset($request['id'])) {
|
||||
// mise à jour
|
||||
$query = "UPDATE users SET name = $1, email = $2 WHERE id = $3";
|
||||
} else {
|
||||
// création
|
||||
$query = "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *";
|
||||
}
|
||||
$result = pg_query_params($conn, $query, array($request['name'], $request['email'], $request['id']));
|
||||
if (!$result) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
$data = pg_fetch_row($result);
|
||||
pg_close($conn);
|
||||
return $data;
|
||||
}
|
||||
|
||||
// fonction de suppression de données en base de données
|
||||
function deleteData($request) {
|
||||
$conn = dbConnect();
|
||||
$result = pg_query_params($conn, "DELETE FROM users WHERE id = $1", array($request['id']));
|
||||
if (!$result) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
pg_close($conn);
|
||||
return array('success' => true);
|
||||
}
|
||||
|
||||
// déclaration des routes
|
||||
$routes = array(
|
||||
'GET /users' => 'getUsers',
|
||||
'GET /users/:id' => 'getUser',
|
||||
'POST /users' => 'createUser',
|
||||
'PUT /users/:id' => 'updateUser',
|
||||
'DELETE /users/:id' => 'deleteUser',
|
||||
'GET /charts' => 'getCharts',
|
||||
'GET /kpis' => 'getKpis',
|
||||
'GET /filters' => 'getFilters',
|
||||
'GET /export' => 'exportData',
|
||||
);
|
||||
|
||||
// définition des fonctions pour chaque route
|
||||
function getUsers() {
|
||||
$conn = dbConnect();
|
||||
$result = pg_query($conn, "SELECT * FROM users");
|
||||
if (!$result) {
|
||||
die('Erreur : ' . pg_last_error());
|
||||
}
|
||||
$data = pg_fetch_all($result);
|
||||
pg_close($conn);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function getUser($request) {
|
||||
$data = fetchData($request);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function createUser($request) {
|
||||
$data = saveData($request);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function updateUser($request) {
|
||||
$data = saveData($request);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function deleteUser($request) {
|
||||
$data = deleteData($request);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function getCharts() {
|
||||
// générer des données pour les charts
|
||||
$data = array(
|
||||
"labels" => array("Jan", "Fév", "Mar", "Avr", "Mai"),
|
||||
"datasets" => array(
|
||||
array(
|
||||
"label" => "Ventes",
|
||||
"backgroundColor" => "rgba(255, 99, 132, 0.2)",
|
||||
"borderColor" => "rgba(255, 99, 132, 1)",
|
||||
"data" => array(10, 20, 30, 40, 50)
|
||||
),
|
||||
array(
|
||||
"label" => "Clients",
|
||||
"backgroundColor" => "rgba(54, 162, 235, 0.2)",
|
||||
"borderColor" => "rgba(54, 162, 235, 1)",
|
||||
"data" => array(15, 25, 35, 45, 55)
|
||||
)
|
||||
)
|
||||
);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function getKpis() {
|
||||
// générer des donées pour les KPIs
|
||||
$data = array(
|
||||
array("nom" => "Chiffre d'affaires", "valeur" => 10000),
|
||||
array("nom" => "Client actif", "valeur" => 50),
|
||||
array("nom" => "Taux de conversion", "valeur" => 20)
|
||||
);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function getFilters() {
|
||||
// générer des données pour les filtres
|
||||
$data = array(
|
||||
array("nom" => "Filtré par client", "valeur" => "client1"),
|
||||
array("nom" => "Filtré par date", "valeur" => "2022-01-01")
|
||||
);
|
||||
return json_encode($data);
|
||||
}
|
||||
|
||||
function exportData() {
|
||||
// générer un fichier CSV pour l'export
|
||||
$data = array(
|
||||
array("Nom", "E-mail", "Date"),
|
||||
array("John", "john@example.com", "2022-01-01"),
|
||||
array("Jane", "jane@example.com", "2022-01-02")
|
||||
);
|
||||
$fp = fopen('export.csv', 'w');
|
||||
foreach ($data as $row) {
|
||||
fputcsv($fp, $row);
|
||||
}
|
||||
fclose($fp);
|
||||
return json_encode(array('success' => true));
|
||||
}
|
||||
|
||||
// boucle pour gérer les requêtes
|
||||
foreach ($routes as $route => $function) {
|
||||
$method = explode(' ', $route);
|
||||
if ($method[0] == 'GET') {
|
||||
require_once 'header.php';
|
||||
echo json_encode(call_user_func($function, array('method' => $method[0], 'route' => $route, 'id' => isset($method[2]) ? $method[2] : null)));
|
||||
require_once 'footer.php';
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Important**:
|
||||
|
||||
* Ce code nécessite la configuration de votre base de données PostgreSQL.
|
||||
* Les routes CRUD (`GET /users`, `GET /users/:id`, `POST /users`, `PUT /users/:id`, `DELETE /users/:id`) permettent de gérer les données dans la base de données.
|
||||
* Les routes pour les charts, les KPIs et les filtres génèrent des données pour l'interface utilisateur.
|
||||
* L'export de données génère un fichier CSV à partir
|
||||
@@ -1,111 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique avec charts, KPIs, filtres, export.
|
||||
|
||||
**index.php**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion PostgreSQL
|
||||
$db = new PDO('pgsql:host=localhost;dbname=example', 'utilisateur', 'mot_de_passe');
|
||||
|
||||
// Fonction pour récupérer les données de la base de données
|
||||
function getData($db, $table, $filtre = null) {
|
||||
$sql = "SELECT * FROM $table";
|
||||
if ($filtre) {
|
||||
$sql .= " WHERE $filtre";
|
||||
}
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
}
|
||||
|
||||
// Fonction pour incrémenter une valeur dans une table
|
||||
function incrementData($db, $table, $filtre, $increment) {
|
||||
$sql = "UPDATE $table SET value = value + $increment WHERE $filtre";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour supprimer des données de la base de données
|
||||
function deleteData($db, $table, $filtre, $increment) {
|
||||
$sql = "DELETE FROM $table WHERE $filtre";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour ajouter des données à la base de données
|
||||
function addData($db, $table, $donnees) {
|
||||
$sql = "INSERT INTO $table ($donnees) VALUES (" . implode(',', $donnees) . ")";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour des données de la base de données
|
||||
function updateData($db, $table, $filtre, $donnees) {
|
||||
$sql = "UPDATE $table SET " . implode(',', $donnees) . " WHERE $filtre";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour exporter les données de la base de données
|
||||
function exportData($db, $table) {
|
||||
$sql = "SELECT * FROM $table";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($donnees);
|
||||
}
|
||||
|
||||
// Route GET pour récupérer les données du dashboard
|
||||
$app = new \Slim\App();
|
||||
$app->get('/dashboard', function ($request, $response) use ($db) {
|
||||
$donnees = getData($db, 'dashboard');
|
||||
return $response->withJson($donnees);
|
||||
});
|
||||
|
||||
// Route POST pour ajouter une nouvelle donnée au dashboard
|
||||
$app->post('/dashboard', function ($request, $response) use ($db) {
|
||||
$donnees = $request->getParsedBody();
|
||||
addData($db, 'dashboard', $donnees);
|
||||
return $response->withJson(['success' => true]);
|
||||
});
|
||||
|
||||
// Route GET pour récupérer les données du dashboard avec filtres
|
||||
$app->get('/dashboard/filtre', function ($request, $response) use ($db) {
|
||||
$filtre = $request->getQueryParam('filtre');
|
||||
$donnees = getData($db, 'dashboard', $filtre);
|
||||
return $response->withJson($donnees);
|
||||
});
|
||||
|
||||
// Route PUT pour mettre à jour une donnée du dashboard
|
||||
$app->put('/dashboard/{id}', function ($request, $response, $args) use ($db) {
|
||||
$donnees = $request->getParsedBody();
|
||||
updateData($db, 'dashboard', 'id = ' . $args['id'], $donnees);
|
||||
return $response->withJson(['success' => true]);
|
||||
});
|
||||
|
||||
// Route DELETE pour supprimer une donnée du dashboard
|
||||
$app->delete('/dashboard/{id}', function ($request, $response, $args) use ($db) {
|
||||
deleteData($db, 'dashboard', 'id = ' . $args['id']);
|
||||
return $response->withJson(['success' => true]);
|
||||
});
|
||||
|
||||
// Route GET pour exporter les données du dashboard
|
||||
$app->get('/dashboard/export', function ($request, $response) use ($db) {
|
||||
exportData($db, 'dashboard');
|
||||
});
|
||||
|
||||
$app->run();
|
||||
|
||||
```
|
||||
Pour faire fonctionner ce code, vous devez enregister les routes pour secrétiser, puis, insérer du contenu dans la table "dashboard" de votre base de données PostgreSQL.
|
||||
|
||||
Exemple de données :
|
||||
```sql
|
||||
INSERT INTO dashboard (id, valeur) VALUES (1, 10);
|
||||
INSERT INTO dashboard (id, valeur) VALUES (2, 20);
|
||||
```
|
||||
Vous pouvez également ajouter des routes supplémentaires pour récupérer les données du dashboard en fonction de différents critères (par exemple, par date, par type, etc.).
|
||||
|
||||
Notez que ce code est un exemplaire et que vous devrez le personnaliser en fonction de vos besoins spécifiques.
|
||||
@@ -1,180 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet qui génère une API REST pour le dashboard analytique avec charts, KPIs, filtres, et export. Cet exemple utilise les bibliothèques WordPress pour la connexion à la base de données PostgreSQL, et les bibliothèques de visualisation Chart.js pour les graphiques.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données PostgreSQL
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_USER', 'votre_utilisateur');
|
||||
define('DB_PASSWORD', 'votre_mot_de_passe');
|
||||
define('DB_NAME', 'votre_base_de_donnees');
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=" . DB_HOST . " user=" . DB_USER . " password=" . DB_PASSWORD . " dbname=" . DB_NAME);
|
||||
|
||||
// Vérification de la connexion
|
||||
if (!$conn) {
|
||||
echo "Erreur de connexion : " . pg_last_error();
|
||||
exit();
|
||||
}
|
||||
|
||||
// Fonction d'initialisation de la base de données si elle n'existe pas
|
||||
function initDatabase() {
|
||||
global $conn;
|
||||
$sql = "CREATE TABLE IF NOT EXISTS public.kpi (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(100) NOT NULL,
|
||||
valeur INT NOT NULL
|
||||
);";
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
// Fonction d'ajout d'un KPI
|
||||
function addKpi($nom, $valeur) {
|
||||
global $conn;
|
||||
$sql = "INSERT INTO public.kpi (nom, valeur) VALUES ('" . pg_escape_string($nom) . "', " . $valeur . ");";
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
// Fonction de lecture des KPIs
|
||||
function getKpis() {
|
||||
global $conn;
|
||||
$sql = "SELECT * FROM public.kpi;";
|
||||
$result = pg_query($conn, $sql);
|
||||
$kpis = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$kpis[] = $row;
|
||||
}
|
||||
return $kpis;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un KPI
|
||||
function updateKpi($id, $nom, $valeur) {
|
||||
global $conn;
|
||||
$sql = "UPDATE public.kpi SET nom = '" . pg_escape_string($nom) . "', valeur = " . $valeur . " WHERE id = " . $id . ";";
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un KPI
|
||||
function deleteKpi($id) {
|
||||
global $conn;
|
||||
$sql = "DELETE FROM public.kpi WHERE id = " . $id . ";";
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
// Route pour la récupération des KPIs
|
||||
if ($_SERVER["REQUEST_METHOD"] == "GET") {
|
||||
$kpis = getKpis();
|
||||
$output = array();
|
||||
foreach ($kpis as $kpi) {
|
||||
$output[] = array(
|
||||
'id' => $kpi['id'],
|
||||
'nom' => $kpi['nom'],
|
||||
'valeur' => $kpi['valeur']
|
||||
);
|
||||
}
|
||||
http_response_code(200);
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($output);
|
||||
}
|
||||
|
||||
// Route pour l'ajout d'un KPI
|
||||
if ($_SERVER["REQUEST_METHOD"] == "POST") {
|
||||
$nom = $_POST['nom'];
|
||||
$valeur = $_POST['valeur'];
|
||||
addKpi($nom, $valeur);
|
||||
http_response_code(201);
|
||||
}
|
||||
|
||||
// Route pour la mise à jour d'un KPI
|
||||
if ($_SERVER["REQUEST_METHOD"] == "PUT") {
|
||||
$id = $_GET['id'];
|
||||
$nom = $_GET['nom'];
|
||||
$valeur = $_GET['valeur'];
|
||||
updateKpi($id, $nom, $valeur);
|
||||
http_response_code(200);
|
||||
}
|
||||
|
||||
// Route pour la suppression d'un KPI
|
||||
if ($_SERVER["REQUEST_METHOD"] == "DELETE") {
|
||||
$id = $_GET['id'];
|
||||
deleteKpi($id);
|
||||
http_response_code(200);
|
||||
}
|
||||
|
||||
// Affichage du graphique (chart.js)
|
||||
?>
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Dashboard Analytique</title>
|
||||
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
|
||||
<style>
|
||||
canvas {
|
||||
-moz-user-select: none;
|
||||
-webkit-user-select: none;
|
||||
-ms-user-select: none;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Dashboard Analytique</h1>
|
||||
<canvas id="myChart"></canvas>
|
||||
<script>
|
||||
const labels = <?php echo json_encode(array_column(getKpis(), 'nom')); ?>;
|
||||
const datasets = [
|
||||
{
|
||||
label: 'Valeurs',
|
||||
data: <?php echo json_encode(array_column(getKpis(), 'valeur')); ?>,
|
||||
backgroundColor: [
|
||||
'rgba(255, 99, 132, 0.2)',
|
||||
'rgba(54, 162, 235, 0.2)',
|
||||
'rgba(255, 206, 86, 0.2)',
|
||||
'rgba(75, 192, 192, 0.2)',
|
||||
'rgba(153, 102, 255, 0.2)',
|
||||
'rgba(255, 159, 64, 0.2)'
|
||||
],
|
||||
borderColor: [
|
||||
'rgba(255, 99, 132, 1)',
|
||||
'rgba(54, 162, 235, 1)',
|
||||
'rgba(255, 206, 86, 1)',
|
||||
'rgba(75, 192, 192, 1)',
|
||||
'rgba(153, 102, 255, 1)',
|
||||
'rgba(255, 159, 64, 1)'
|
||||
],
|
||||
borderWidth: 1
|
||||
}
|
||||
];
|
||||
const config = {
|
||||
type: 'bar',
|
||||
data: {
|
||||
labels,
|
||||
datasets
|
||||
},
|
||||
options: {
|
||||
scales: {
|
||||
y: {
|
||||
beginAtZero: true
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
const myChart = new Chart(document.getElementById('myChart'), config);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
Ce code définit les routes suivantes :
|
||||
|
||||
* `GET /`: Récupère les KPIs existants
|
||||
* `POST /`: Ajoute un nouveau KPI
|
||||
* `PUT /`: Met à jour un KPI existant
|
||||
* `DELETE /:id`: Supprime un KPI spécifique
|
||||
|
||||
Le graphe utilisé pour afficher les données est un graphique de barre généré par Chart.js. Les données sont récupérées depuis la base de données PostgreSQL.
|
||||
|
||||
Le code utilise la méthode POST pour envoyer les données d'un KPI à l'API, qui les traite et les insère dans la base de données.
|
||||
|
||||
Dans cette exemple, nous utilisons Chart.js pour afficher les données, mais vous pouvez éventuellement utiliser d'autres options
|
||||
@@ -1,205 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API REST pour un dashboard analytique avec charts, KPIs, filtres, et export. Ce code utilise PHP 8.5, PostgreSQL et les frameworks HTML5/CSS3/JS.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configurations
|
||||
$dbHost = 'localhost';
|
||||
$dbName = 'analytics';
|
||||
$dbUser = 'username';
|
||||
$dbPassword = 'password';
|
||||
|
||||
// Connexion à PostgreSQL
|
||||
$dsn = "pgsql:host=$dbHost;dbname=$dbName";
|
||||
$client = new PDO($dsn, $dbUser, $dbPassword);
|
||||
$client->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
// Class Dashboard
|
||||
class Dashboard {
|
||||
private $id;
|
||||
private $name;
|
||||
private $description;
|
||||
|
||||
public function __construct($data = []) {
|
||||
if (!empty($data)) {
|
||||
$this->id = $data['id'];
|
||||
$this->name = $data['name'];
|
||||
$this->description = $data['description'];
|
||||
}
|
||||
}
|
||||
|
||||
public function toHtml() {
|
||||
return '<h2>' . $this->name . '</h2><p>' . $this->description . '</p>';
|
||||
}
|
||||
|
||||
public function toJson() {
|
||||
return json_encode([
|
||||
'id' => $this->id,
|
||||
'name' => $this->name,
|
||||
'description' => $this->description
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// Class Chart
|
||||
class Chart {
|
||||
private $id;
|
||||
private $name;
|
||||
private $data;
|
||||
|
||||
public function __construct($data = []) {
|
||||
if (!empty($data)) {
|
||||
$this->id = $data['id'];
|
||||
$this->name = $data['name'];
|
||||
$this->data = $data['data'];
|
||||
}
|
||||
}
|
||||
|
||||
public function toHtml() {
|
||||
return '<h2>' . $this->name . '</h2><canvas id="line-chart"></canvas>';
|
||||
}
|
||||
|
||||
public function toJson() {
|
||||
return json_encode([
|
||||
'id' => $this->id,
|
||||
'name' => $this->name,
|
||||
'data' => $this->data
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// Utilitaire pour les requêtes
|
||||
function getQuery($query) {
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
function createQuery($query, $params) {
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
$stmt->execute($params);
|
||||
return $stmt->rowCount();
|
||||
}
|
||||
|
||||
function updateQuery($query, $params) {
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
$stmt->execute($params);
|
||||
return $stmt->rowCount();
|
||||
}
|
||||
|
||||
function deleteQuery($query, $params) {
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
$stmt->execute($params);
|
||||
return $stmt->rowCount();
|
||||
}
|
||||
|
||||
// Routage
|
||||
function getDashboard($id = null) {
|
||||
$query = 'SELECT * FROM dashboards';
|
||||
if ($id !== null) {
|
||||
$query .= ' WHERE id = :id';
|
||||
}
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
if ($id !== null) {
|
||||
$stmt->bindParam(':id', $id);
|
||||
}
|
||||
$stmt->execute();
|
||||
return empty($id) ? $stmt->fetchAll() : $stmt->fetch();
|
||||
}
|
||||
|
||||
function getCharts($dashboardId = null) {
|
||||
$query = 'SELECT * FROM charts';
|
||||
if ($dashboardId !== null) {
|
||||
$query .= ' WHERE dashboard_id = :dashboard_id';
|
||||
}
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
if ($dashboardId !== null) {
|
||||
$stmt->bindParam(':dashboard_id', $dashboardId);
|
||||
}
|
||||
$stmt->execute();
|
||||
return empty($dashboardId) ? $stmt->fetchAll() : $stmt->fetchAll();
|
||||
}
|
||||
|
||||
function getKpis($dashboardId = null) {
|
||||
$query = 'SELECT * FROM kpis';
|
||||
if ($dashboardId !== null) {
|
||||
$query .= ' WHERE dashboard_id = :dashboard_id';
|
||||
}
|
||||
$stmt = $GLOBALS['client']->prepare($query);
|
||||
if ($dashboardId !== null) {
|
||||
$stmt->bindParam(':dashboard_id', $dashboardId);
|
||||
}
|
||||
$stmt->execute();
|
||||
return empty($dashboardId) ? $stmt->fetchAll() : $stmt->fetchAll();
|
||||
}
|
||||
|
||||
function postDashboard($data) {
|
||||
$query = 'INSERT INTO dashboards (name, description) VALUES (:name, :description)';
|
||||
createQuery($query, $data);
|
||||
}
|
||||
|
||||
function postChart($data) {
|
||||
$query = 'INSERT INTO charts (name, data, dashboard_id) VALUES (:name, :data, :dashboard_id)';
|
||||
createQuery($query, $data);
|
||||
}
|
||||
|
||||
function postKpi($data) {
|
||||
$query = 'INSERT INTO kpis (name, value, dashboard_id) VALUES (:name, :value, :dashboard_id)';
|
||||
createQuery($query, $data);
|
||||
}
|
||||
|
||||
function putDashboard($id, $data) {
|
||||
$query = 'UPDATE dashboards SET name = :name, description = :description WHERE id = :id';
|
||||
updateQuery($query, $data);
|
||||
}
|
||||
|
||||
function putChart($id, $data) {
|
||||
$query = 'UPDATE charts SET name = :name, data = :data WHERE id = :id';
|
||||
updateQuery($query, $data);
|
||||
}
|
||||
|
||||
function putKpi($id, $data) {
|
||||
$query = 'UPDATE kpis SET name = :name, value = :value WHERE id = :id';
|
||||
updateQuery($query, $data);
|
||||
}
|
||||
|
||||
function deleteDashboard($id) {
|
||||
$query = 'DELETE FROM dashboards WHERE id = :id';
|
||||
deleteQuery($query, ['id' => $id]);
|
||||
}
|
||||
|
||||
function deleteChart($id) {
|
||||
$query = 'DELETE FROM charts WHERE id = :id';
|
||||
deleteQuery($query, ['id' => $id]);
|
||||
}
|
||||
|
||||
function deleteKpi($id) {
|
||||
$query = 'DELETE FROM kpis WHERE id = :id';
|
||||
deleteQuery($query, ['id' => $id]);
|
||||
}
|
||||
|
||||
// API REST
|
||||
$app = new \Slim\App;
|
||||
|
||||
$app->get('/dashboard', function (Request $request, Response $response) {
|
||||
$dashboards = getQuery('SELECT * FROM dashboards');
|
||||
return $response->withJson($dashboards);
|
||||
});
|
||||
|
||||
$app->get('/dashboard/{id}', function (Request $request, Response $response, $args) {
|
||||
$id = $args['id'];
|
||||
return $response->withJson(getDashboard($id));
|
||||
});
|
||||
|
||||
$app->post('/dashboard', function (Request $request, Response $response) {
|
||||
$data = $request->getParsedBody();
|
||||
postDashboard($data);
|
||||
return $response->withStatus(201);
|
||||
});
|
||||
|
||||
$app->put('/dashboard/{id}', function (Request $request, Response $response, $args) {
|
||||
$id = $args['id'];
|
||||
$data = $request->getParsedBody();
|
||||
putDashboard($id, $data);
|
||||
return $response->withStatus(
|
||||
@@ -1,207 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP pour créer une API REST complète pour un dashboard analytique avec charts, KPIs, filtres, export, routes CRUD (GET/POST/PUT/DELETE) et connexion à une base de données PostgreSQL. Ce code est fonctionnel et complet, il est optimisé pour la production.
|
||||
|
||||
```php
|
||||
<?php
|
||||
// Définir les constantes pour la connexion à la base de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'database');
|
||||
define('DB_USER', 'username');
|
||||
define('DB_PASSWORD', 'password');
|
||||
|
||||
// Fonction de connexion à la base de données
|
||||
function connectDB() {
|
||||
try {
|
||||
$conn = pg_connect("host=$DB_HOST dbname=$DB_NAME user=$DB_USER password=$DB_PASSWORD");
|
||||
if (!$conn) {
|
||||
echo "L'erreur de connexion est : " . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
// echo "Connexion établie à la base de données\n";
|
||||
return $conn;
|
||||
} catch (Exception $e) {
|
||||
echo "Erreur de connexion à la base de données : " . $e->getMessage();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de création de la table si elle n'existe pas
|
||||
function createTable() {
|
||||
// Supprimer l'ancienne table si elle existe
|
||||
$sql = "DROP TABLE IF EXISTS charts;";
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return;
|
||||
}
|
||||
pg_query($conn, $sql);
|
||||
// Créer la nouvelle table
|
||||
$sql = "
|
||||
CREATE TABLE charts (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name VARCHAR(255),
|
||||
data JSONB
|
||||
);
|
||||
";
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
// Fonction d'insertion des données dans la table
|
||||
function insertData($name, $data) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return;
|
||||
}
|
||||
$sql = "INSERT INTO charts (name, data) VALUES ('$name', $data) RETURNING id;";
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
pg_last_error($conn);
|
||||
exit;
|
||||
}
|
||||
$row = pg_fetch_row($result);
|
||||
return $row[0];
|
||||
}
|
||||
|
||||
// Fonction de recherche des données dans la table
|
||||
function searchData($id) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return array();
|
||||
}
|
||||
$sql = "SELECT name, data FROM charts WHERE id=$id;";
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
pg_last_error($conn);
|
||||
exit;
|
||||
}
|
||||
$data = array();
|
||||
while ($row = pg_fetch_row($result)) {
|
||||
$data[] = array(
|
||||
"name" => $row[0],
|
||||
"data" => json_decode($row[1], true),
|
||||
);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Fonction de mise à jour des données dans la table
|
||||
function updateData($id, $name, $data) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return;
|
||||
}
|
||||
$sql = "UPDATE charts SET name='$name', data=$data WHERE id=$id;";
|
||||
pg_query($conn, $sql);
|
||||
return;
|
||||
}
|
||||
|
||||
// Fonction de suppression des données dans la table
|
||||
function deleteData($id) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return;
|
||||
}
|
||||
$sql = "DELETE FROM charts WHERE id=$id;";
|
||||
pg_query($conn, $sql);
|
||||
return;
|
||||
}
|
||||
|
||||
// Fonction de récupération des données pour le dashboard
|
||||
function getDashboardData($filtre) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return array();
|
||||
}
|
||||
if ($filtre) {
|
||||
$sql = "SELECT name, data FROM charts WHERE name LIKE '%$filtre%';";
|
||||
} else {
|
||||
$sql = "SELECT name, data FROM charts;";
|
||||
}
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
pg_last_error($conn);
|
||||
exit;
|
||||
}
|
||||
$data = array();
|
||||
while ($row = pg_fetch_row($result)) {
|
||||
$data[] = array(
|
||||
"name" => $row[0],
|
||||
"data" => json_decode($row[1], true),
|
||||
);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Fonction de récupération des données pour les plots
|
||||
function getPlotData() {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return array();
|
||||
}
|
||||
$sql = "SELECT id, name, data FROM charts;";
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
pg_last_error($conn);
|
||||
exit;
|
||||
}
|
||||
$data = array();
|
||||
while ($row = pg_fetch_row($result)) {
|
||||
$data[] = array(
|
||||
"id" => $row[0],
|
||||
"name" => $row[1],
|
||||
"data" => json_decode($row[2], true),
|
||||
);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Fonction de génération du fichier CSV
|
||||
function generateCSV($filtre) {
|
||||
$conn = connectDB();
|
||||
if (!$conn) {
|
||||
return;
|
||||
}
|
||||
if ($filtre) {
|
||||
$sql = "SELECT name, data FROM charts WHERE name LIKE '%$filtre%';";
|
||||
} else {
|
||||
$sql = "SELECT name, data FROM charts;";
|
||||
}
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
pg_last_error($conn);
|
||||
exit;
|
||||
}
|
||||
$file = fopen("chart_data.csv", "w");
|
||||
fputcsv($file, array("Nom", "Data"));
|
||||
while ($row = pg_fetch_row($result)) {
|
||||
fputcsv($file, array($row[0], json_encode(json_decode($row[1], true))));
|
||||
}
|
||||
fclose($file);
|
||||
}
|
||||
|
||||
// Réponse JSON pour la API REST
|
||||
header("Content-Type: application/json");
|
||||
$method = $_SERVER["REQUEST_METHOD"];
|
||||
|
||||
// Récupérer les données de la requête
|
||||
$data = json_decode(file_get_contents("php://input"), true);
|
||||
|
||||
// Tableau de réponses
|
||||
$responses = array();
|
||||
|
||||
// Traitement du request
|
||||
if ($method == "GET" && isset($data["id"])) {
|
||||
$responses = searchData($data["id"]);
|
||||
} elseif ($method == "GET" && isset($data["filtre"])) {
|
||||
$responses = getDashboardData($data["filtre"]);
|
||||
} elseif ($method == "GET") {
|
||||
$responses = getDashboardData();
|
||||
} elseif ($method == "POST") {
|
||||
createTable();
|
||||
$responses["id"] = insertData($data["name"], $data["data"]);
|
||||
} elseif ($method == "PUT") {
|
||||
updateData($data["id"], $data["name"], $data["data"]);
|
||||
} elseif ($method == "DELETE" && isset($data["id"])) {
|
||||
deleteData($data["id"]);
|
||||
}
|
||||
|
||||
// Génération du fichier CSV
|
||||
@@ -1,179 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytics :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Définition des constantes de configuration
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'monbase');
|
||||
define('DB_USER', 'monutilisateur');
|
||||
define('DB_PASSWORD', 'monmotdepasse');
|
||||
|
||||
// Création de la connexion à la base de données
|
||||
$conn = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
|
||||
|
||||
// Fonction de connexion pour être utilisée dans les autres fichiers (facultatif)
|
||||
function connectDB() {
|
||||
global $conn;
|
||||
return $conn;
|
||||
}
|
||||
|
||||
// Fonction de fermeture de la connexion pour être utilisée dans les autres fichiers (facultatif)
|
||||
function closeDB($conn) {
|
||||
$conn = null;
|
||||
}
|
||||
|
||||
// Fonction pour gérer les requêtes SQL
|
||||
function fetchAll($query) {
|
||||
global $conn;
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
// Fonction pour gérer les requêtes SQL
|
||||
function fetchOne($query) {
|
||||
global $conn;
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
// Fonction pour créer des données de test (facultative)
|
||||
function createTestData() {
|
||||
global $conn;
|
||||
$query = "INSERT INTO données (nom, valeur) VALUES ('donnees1', 10), ('donnees2', 20), ('donnees3', 30)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour supprimer des données de test (facultative)
|
||||
function deleteTestData() {
|
||||
global $conn;
|
||||
$query = "DELETE FROM données WHERE 1=1";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les données de test (facultative)
|
||||
function getTotalValue() {
|
||||
global $conn;
|
||||
$query = "SELECT SUM(valeur) as total FROM données";
|
||||
return fetchOne($query)['total'];
|
||||
}
|
||||
|
||||
// GET /data
|
||||
function getData() {
|
||||
$query = "SELECT * FROM données";
|
||||
$data = fetchAll($query);
|
||||
echo json_encode($data);
|
||||
}
|
||||
|
||||
// POST /data
|
||||
function postData() {
|
||||
$nom = $_POST['nom'];
|
||||
$valeur = $_POST['valeur'];
|
||||
$query = "INSERT INTO données (nom, valeur) VALUES (:nom, :valeur)";
|
||||
$stmt = connectDB()->prepare($query);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':valeur', $valeur);
|
||||
$stmt->execute();
|
||||
echo json_encode(['message' => 'Donnée ajoutée avec succès']);
|
||||
}
|
||||
|
||||
// GET /data/:id
|
||||
function getDataById($id) {
|
||||
$query = "SELECT * FROM données WHERE id = :id";
|
||||
$stmt = connectDB()->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$data = $stmt->fetch();
|
||||
echo json_encode($data);
|
||||
}
|
||||
|
||||
// PUT /data/:id
|
||||
function putData($id) {
|
||||
$nom = $_POST['nom'];
|
||||
$valeur = $_POST['valeur'];
|
||||
$query = "UPDATE données SET nom = :nom, valeur = :valeur WHERE id = :id";
|
||||
$stmt = connectDB()->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->bindParam(':nom', $nom);
|
||||
$stmt->bindParam(':valeur', $valeur);
|
||||
$stmt->execute();
|
||||
echo json_encode(['message' => 'Donnée mise à jour avec succès']);
|
||||
}
|
||||
|
||||
// DELETE /data/:id
|
||||
function deleteData($id) {
|
||||
$query = "DELETE FROM données WHERE id = :id";
|
||||
$stmt = connectDB()->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
echo json_encode(['message' => 'Donnée supprimée avec succès']);
|
||||
}
|
||||
|
||||
// Gestion des chemins HTTP
|
||||
switch ($_SERVER['REQUEST_METHOD']) {
|
||||
case 'GET':
|
||||
if ($_GET['route'] === 'data') {
|
||||
getData();
|
||||
} else {
|
||||
echo json_encode(['message' => 'Ressource non trouvée']);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'POST':
|
||||
if ($_GET['route'] === 'data') {
|
||||
postData();
|
||||
} else {
|
||||
echo json_encode(['message' => 'Ressource non trouvée']);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'GET':
|
||||
if ($_GET['route'] === 'data/:id') {
|
||||
getDataById($_GET['id']);
|
||||
} else {
|
||||
echo json_encode(['message' => 'Ressource non trouvée']);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'PUT':
|
||||
if ($_GET['route'] === 'data/:id') {
|
||||
putData($_GET['id']);
|
||||
} else {
|
||||
echo json_encode(['message' => 'Ressource non trouvée']);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'DELETE':
|
||||
if ($_GET['route'] === 'data/:id') {
|
||||
deleteData($_GET['id']);
|
||||
} else {
|
||||
echo json_encode(['message' => 'Ressource non trouvée']);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
echo json_encode(['message' => 'Méthode HTTP non prise en charge']);
|
||||
break;
|
||||
}
|
||||
|
||||
// Connexion et fermeture de la base de données automatique
|
||||
register_shutdown_function(function () {
|
||||
global $conn;
|
||||
closeDB($conn);
|
||||
});
|
||||
```
|
||||
Ce code crée une API REST pour gérer les données stockées dans une base de données PostgreSQL. Il implémente les méthodes GET, POST, PUT et DELETE pour les chemins HTTP suivants :
|
||||
|
||||
- `GET /data`: récupère toutes les données
|
||||
- `POST /data`: ajoute une nouvelle donnée
|
||||
- `GET /data/:id`: récupère une donnée en fonction de l'ID
|
||||
- `PUT /data/:id`: met à jour une donnée en fonction de l'ID
|
||||
- `DELETE /data/:id`: supprime une donnée en fonction de l'ID
|
||||
|
||||
Il utilise des fonctions pour gérer les requêtes SQL, créer des données de test et supprimer des données de test. Les erreurs sont gérées en générant des JSON avec des messages de réponse.
|
||||
|
||||
Pour connecter la base de données, assurez-vous que vous éds les constantes `DB_HOST`, `DB_NAME`, `DB_USER` et `DB_PASSWORD` avec les informations de votre serveur de base de données.
|
||||
@@ -1,180 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique avec chart, KPIs, filtres et export. Ce code utilise les technologies PHP 8.5, PostgreSQL, HTML5/CSS3/JS et utilise des routes CRUD (get, post, put, delete) pour interagir avec la base de données.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
require_once 'vendor/autoload.php';
|
||||
|
||||
use App\Services\DashboardService;
|
||||
use App\Controllers\DashboardController;
|
||||
use App\Models\KpiModel;
|
||||
use App\Models\FiltreModel;
|
||||
use App\Models\ExporterModel;
|
||||
|
||||
use Illuminate\Database\Capsule\Manager as Capsule;
|
||||
|
||||
// Initialisation de la connexion à PostgreSQL
|
||||
$capsule = new Capsule();
|
||||
|
||||
$capsule->addConnection([
|
||||
'driver' => 'pgsql',
|
||||
'host' => 'localhost',
|
||||
'port' => '5432',
|
||||
'database' => 'dashboard',
|
||||
'username' => 'dashboard',
|
||||
'password' => 'dashboard',
|
||||
]);
|
||||
|
||||
$capsule->setAsGlobal();
|
||||
$capsule->bootEloquent();
|
||||
|
||||
// Définition de la classe DashboardController
|
||||
class DashboardController
|
||||
{
|
||||
private $dashboardService;
|
||||
|
||||
public function __construct(DashboardService $dashboardService)
|
||||
{
|
||||
$this->dashboardService = $dashboardService;
|
||||
}
|
||||
|
||||
// Route GET pour obtenir les données du dashboard
|
||||
public function getDashboard()
|
||||
{
|
||||
try {
|
||||
$data = $this->dashboardService->getDashboardData();
|
||||
return json_encode(['success' => true, 'data' => $data]);
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route POST pour créer un nouveau KP
|
||||
public function createKpi()
|
||||
{
|
||||
try {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$kpiModel = new KpiModel();
|
||||
$kpiModel->nom = $data['nom'];
|
||||
$kpiModel->valeur = $data['valeur'];
|
||||
$kpiModel->save();
|
||||
return json_encode(['success' => true, 'message' => ' KP créé avec succès']);
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route GET pour obtenir un KP spécifique
|
||||
public function getKpi()
|
||||
{
|
||||
try {
|
||||
$id = $_GET['id'];
|
||||
$kpiModel = KpiModel::find($id);
|
||||
if ($kpiModel) {
|
||||
return json_encode(['success' => true, 'data' => $kpiModel]);
|
||||
} else {
|
||||
return json_encode(['success' => false, 'error' => 'KP non trouvé']);
|
||||
}
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route PUT pour mettre à jour un KP
|
||||
public function updateKpi()
|
||||
{
|
||||
try {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$id = $data['id'];
|
||||
$kpiModel = KpiModel::find($id);
|
||||
if ($kpiModel) {
|
||||
$kpiModel->nom = $data['nom'];
|
||||
$kpiModel->valeur = $data['valeur'];
|
||||
$kpiModel->save();
|
||||
return json_encode(['success' => true, 'message' => ' KP mis à jour avec succès']);
|
||||
} else {
|
||||
return json_encode(['success' => false, 'error' => ' KP non trouvé']);
|
||||
}
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route DELETE pour supprimer un KP
|
||||
public function deleteKpi()
|
||||
{
|
||||
try {
|
||||
$id = $_GET['id'];
|
||||
$kpiModel = KpiModel::find($id);
|
||||
if ($kpiModel) {
|
||||
$kpiModel->delete();
|
||||
return json_encode(['success' => true, 'message' => ' KP supprimé avec succès']);
|
||||
} else {
|
||||
return json_encode(['success' => false, 'error' => ' KP non trouvé']);
|
||||
}
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route POST pour envoyer un filtre
|
||||
public function sendFiltre()
|
||||
{
|
||||
try {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$filtreModel = new FiltreModel();
|
||||
$filtreModel->nom = $data['nom'];
|
||||
$filtreModel->valeur = $data['valeur'];
|
||||
$filtreModel->save();
|
||||
return json_encode(['success' => true, 'message' => ' Filtre envoyé avec succès']);
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route GET pour obtenir les KPIs filtrés
|
||||
public function getKpiFiltres()
|
||||
{
|
||||
try {
|
||||
$filtre = $_GET['filtre'];
|
||||
$kpiModels = KpiModel::where('valeur', 'like', '%' . $filtre . '%')->get();
|
||||
return json_encode(['success' => true, 'data' => $kpiModels]);
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route POST pour exporter les données
|
||||
public function exportData()
|
||||
{
|
||||
try {
|
||||
$data = json_decode(file_get_contents('php://input'), true);
|
||||
$exporterModel = new ExporterModel();
|
||||
$exporterModel->type = $data['type'];
|
||||
$exporterModel->save();
|
||||
return json_encode(['success' => true, 'message' => ' Données exportées avec succès']);
|
||||
} catch (\Exception $e) {
|
||||
return json_encode(['success' => false, 'error' => $e->getMessage()]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Création de la classe DashboardService
|
||||
class DashboardService
|
||||
{
|
||||
public function getDashboardData()
|
||||
{
|
||||
// Récupération des KPIs
|
||||
$kpiModels = KpiModel::all();
|
||||
|
||||
// Récupération des filtres
|
||||
$filtreModels = FiltreModel::all();
|
||||
|
||||
// Enrichissement des données avec les filtres
|
||||
$data = [];
|
||||
foreach ($kpiModels as $kpiModel) {
|
||||
$data[] = [
|
||||
'nom' => $kpiModel->nom,
|
||||
'valeur' => $kpiModel->valeur,
|
||||
'filtres' => $filtreModels->where('nom', 'like', '%' . $kpi
|
||||
@@ -1,183 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un dashboard analytique avec chart, KPIs, filtres, export.
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
const DB_HOST = 'localhost';
|
||||
const DB_USER = 'mon_utilisateur';
|
||||
const DB_PASSWORD = 'mon_mot_de_passe';
|
||||
const DB_NAME = 'mon_base_de_donnees';
|
||||
|
||||
// Fonction de connexion à la base de données
|
||||
function connectDB() {
|
||||
try {
|
||||
$dbname = DB_NAME;
|
||||
$dsn = "pgsql:host=" . DB_HOST . ";dbname=$dbname";
|
||||
$pdo = new PDO($dsn, DB_USER, DB_PASSWORD);
|
||||
echo "Connexion à la base de données réussie";
|
||||
} catch (PDOException $e) {
|
||||
echo 'Échec de la connexion : ' . $e->getMessage();
|
||||
}
|
||||
return $pdo;
|
||||
}
|
||||
|
||||
// Fonction de creation de la connexion
|
||||
$pdo = connectDB();
|
||||
|
||||
// Fonction de récupération des données
|
||||
function getData($req, $params) {
|
||||
try {
|
||||
$stmt = $req->prepare($params);
|
||||
$stmt->execute();
|
||||
$result = $stmt->fetchAll();
|
||||
return json_encode($result);
|
||||
} catch (PDOException $e) {
|
||||
return "Erreur de récupération des données";
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de création d'un nouveau KPI
|
||||
function createData($req, $params, $json) {
|
||||
try {
|
||||
$stmt = $req->prepare($params);
|
||||
$stmt->execute(json_decode($json, true));
|
||||
return "KPI créé avec succès";
|
||||
} catch (PDOException $e) {
|
||||
return "Erreur de création de KPI";
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un KPI existant
|
||||
function updateData($req, $params, $json) {
|
||||
try {
|
||||
$stmt = $req->prepare($params);
|
||||
$stmt->execute(json_decode($json, true));
|
||||
return "KPI mis à jour avec succès";
|
||||
} catch (PDOException $e) {
|
||||
return "Erreur de mise à jour de KPI";
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un KPI
|
||||
function deleteData($req, $params) {
|
||||
try {
|
||||
$stmt = $req->prepare($params);
|
||||
$stmt->execute();
|
||||
return "KPI supprimé avec succès";
|
||||
} catch (PDOException $e) {
|
||||
return "Erreur de suppression de KPI";
|
||||
}
|
||||
}
|
||||
|
||||
// API REST
|
||||
$routes = [
|
||||
'/kpi' => [
|
||||
'GET' => function () use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM kpi");
|
||||
},
|
||||
'POST' => function ($json) use ($pdo) {
|
||||
echo createData($pdo, "INSERT INTO kpi (nom, valeur) VALUES (:nom, :valeur)", $json);
|
||||
},
|
||||
],
|
||||
'/kpi/:id' => [
|
||||
'GET' => function ($id) use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM kpi WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
'PUT' => function ($id, $json) use ($pdo) {
|
||||
echo updateData($pdo, "UPDATE kpi SET nom = :nom, valeur = :valeur WHERE id = :id", $json);
|
||||
},
|
||||
'DELETE' => function ($id) use ($pdo) {
|
||||
echo deleteData($pdo, "DELETE FROM kpi WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
// Routes pour les filtres
|
||||
$filterRoutes = [
|
||||
'/filters' => [
|
||||
'GET' => function () use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM filters");
|
||||
},
|
||||
'POST' => function ($json) use ($pdo) {
|
||||
echo createData($pdo, "INSERT INTO filters (nom, valeur) VALUES (:nom, :valeur)", $json);
|
||||
},
|
||||
],
|
||||
'/filters/:id' => [
|
||||
'GET' => function ($id) use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM filters WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
'PUT' => function ($id, $json) use ($pdo) {
|
||||
echo updateData($pdo, "UPDATE filters SET nom = :nom, valeur = :valeur WHERE id = :id", $json);
|
||||
},
|
||||
'DELETE' => function ($id) use ($pdo) {
|
||||
echo deleteData($pdo, "DELETE FROM filters WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
// Routes pour les charts
|
||||
$chartRoutes = [
|
||||
'/charts' => [
|
||||
'GET' => function () use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM charts");
|
||||
},
|
||||
'POST' => function ($json) use ($pdo) {
|
||||
echo createData($pdo, "INSERT INTO charts (nom, valeurs) VALUES (:nom, :valeurs)", $json);
|
||||
},
|
||||
],
|
||||
'/charts/:id' => [
|
||||
'GET' => function ($id) use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM charts WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
'PUT' => function ($id, $json) use ($pdo) {
|
||||
echo updateData($pdo, "UPDATE charts SET nom = :nom, valeurs = :valeurs WHERE id = :id", $json);
|
||||
},
|
||||
'DELETE' => function ($id) use ($pdo) {
|
||||
echo deleteData($pdo, "DELETE FROM charts WHERE id = :id", ["id" => $id]);
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
// Routes pour l'export
|
||||
$exportRoutes = [
|
||||
'/export' => [
|
||||
'GET' => function () use ($pdo) {
|
||||
echo getData($pdo, "SELECT * FROM tables_export");
|
||||
},
|
||||
],
|
||||
];
|
||||
|
||||
// GET/POST/PUT/DELETE
|
||||
function requestHandler() {
|
||||
$routes = [
|
||||
'/API/kpi' => $GLOBALS['routes'],
|
||||
'/API/filters' => $GLOBALS['filterRoutes'],
|
||||
'/API/charts' => $GLOBALS['chartRoutes'],
|
||||
'/API/export' => $GLOBALS['exportRoutes'],
|
||||
];
|
||||
$params = explode("/", $_SERVER['REQUEST_URI']);
|
||||
$method = $_SERVER["REQUEST_METHOD"];
|
||||
if (array_key_exists("/API/$params[1]", $routes)) {
|
||||
if (array_key_exists($method, $routes["/API/$params[1]"])) {
|
||||
$routes["/API/$params[1]"][$method](count($params) > 2 ? $params[2] : '');
|
||||
} else {
|
||||
echo "Méthode inconnue";
|
||||
}
|
||||
} else {
|
||||
echo "Route inconnue";
|
||||
}
|
||||
}
|
||||
requestHandler();
|
||||
|
||||
?>
|
||||
```
|
||||
Voici les requêtes SQL pour créer les tables :
|
||||
```sql
|
||||
CREATE TABLE kpi (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(255),
|
||||
valeur VARCHAR(255)
|
||||
);
|
||||
|
||||
CREATE TABLE filters
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Absolument ! En tant que WEVCODE, je te génère un fichier PHP unique et complet, intégrant une API REST avec CRUD, des endpoints pour dashboard analytique (KPIs, charts, filtres, export CSV) et un tableau de bord HTML/CSS/JS frontend
|
||||
@@ -1,6 +0,0 @@
|
||||
<?php
|
||||
Absolument ! En tant que WEVCODE, je génère du code souverain, complet, fonctionnel et sans le moindre placeholder. Voici votre API REST PHP 8.5 et un dashboard analytique frontend, connectés à PostgreSQL.
|
||||
|
||||
---
|
||||
|
||||
### **Instructions d'Installation et
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Okay, WEVAL ! Je suis WEVCODE, et je vais générer pour toi une API REST COMPLÈTE et un tableau de bord analytique en un seul fichier PHP, comme tu l'as demandé. Tout sera fonctionnel, sans placeholder, prêt à être déployé
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Absolument ! WEVCODE est fier de vous présenter une solution complète et souveraine. Ce fichier unique PHP contient l'API REST pour votre tableau de bord analytique, ainsi que le code HTML/CSS/JS pour le tableau de bord client, prêt à être déployé
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE vous présente une API REST complète, fonctionnelle et prête pour la production, générée selon vos spécifications. Ce fichier PHP unique inclut la connexion PostgreSQL, la gestion des routes CRUD, des endpoints spécifiques pour un tableau de bord analytique, et des réponses JSON structur
|
||||
@@ -1,190 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet en PHP pour une API REST pour un dashboard analytique :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à PostgreSQL
|
||||
$dbHost = 'localhost';
|
||||
$dbName = 'mondb';
|
||||
$dbUser = 'monuser';
|
||||
$dbPassword = 'monmdp';
|
||||
|
||||
// Création d'une fonction pour se connecter à PostgreSQL
|
||||
function getConnection() {
|
||||
$dsn = "pgsql:host=$dbHost;dbname=$dbName";
|
||||
$pdo = new PDO($dsn, $dbUser, $dbPassword);
|
||||
return $pdo;
|
||||
}
|
||||
|
||||
// Routes pour le dashboard analytique
|
||||
$routes = [
|
||||
// Route pour afficher les données du dashboard
|
||||
'/dashboard' => [
|
||||
'method' => 'GET',
|
||||
'handler' => function() {
|
||||
// Récupération des données du dashboard
|
||||
$pdo = getConnection();
|
||||
$stmt = $pdo->prepare('SELECT * FROM dashboard');
|
||||
$stmt->execute();
|
||||
$donnees = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
return $donnees;
|
||||
}
|
||||
],
|
||||
// Route pour créer une nouvelle ligne de données
|
||||
'/dashboard' => [
|
||||
'method' => 'POST',
|
||||
'handler' => function($data) {
|
||||
// Validation des données
|
||||
if (!isset($data['kpi']['nom']) || !isset($data['kpi']['valeur'])) {
|
||||
return [
|
||||
'error' => 'Data format error',
|
||||
'code' => 400
|
||||
];
|
||||
}
|
||||
// Ajout de la ligne de données
|
||||
$pdo = getConnection();
|
||||
$stmt = $pdo->prepare('INSERT INTO dashboard (kpi, valeur) VALUES (:kpi, :valeur)');
|
||||
$stmt->bindParam(':kpi', $data['kpi']['nom']);
|
||||
$stmt->bindParam(':valeur', $data['kpi']['valeur']);
|
||||
$stmt->execute();
|
||||
return [
|
||||
'message' => 'Ligne de données ajoutée avec succès',
|
||||
'code' => 201,
|
||||
'data' => $pdo->lastInsertId()
|
||||
];
|
||||
}
|
||||
],
|
||||
// Route pour mettre à jour une ligne de données
|
||||
'/dashboard/{id}' => [
|
||||
'method' => 'PUT',
|
||||
'handler' => function($id, $data) {
|
||||
// Validation des données
|
||||
if (!isset($data['kpi']['nom']) || !isset($data['kpi']['valeur'])) {
|
||||
return [
|
||||
'error' => 'Data format error',
|
||||
'code' => 400
|
||||
];
|
||||
}
|
||||
// Mise à jour de la ligne de données
|
||||
$pdo = getConnection();
|
||||
$stmt = $pdo->prepare('UPDATE dashboard SET kpi = :kpi, valeur = :valeur WHERE id = :id');
|
||||
$stmt->bindParam(':kpi', $data['kpi']['nom']);
|
||||
$stmt->bindParam(':valeur', $data['kpi']['valeur']);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
return [
|
||||
'message' => 'Ligne de données mise à jour avec succès',
|
||||
'code' => 200,
|
||||
'data' => $data
|
||||
];
|
||||
}
|
||||
],
|
||||
// Route pour supprimer une ligne de données
|
||||
'/dashboard/{id}' => [
|
||||
'method' => 'DELETE',
|
||||
'handler' => function($id) {
|
||||
// Suppression de la ligne de données
|
||||
$pdo = getConnection();
|
||||
$stmt = $pdo->prepare('DELETE FROM dashboard WHERE id = :id');
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
if ($stmt->rowCount() > 0) {
|
||||
return [
|
||||
'message' => 'Ligne de données supprimée avec succès',
|
||||
'code' => 202,
|
||||
'data' => $id
|
||||
];
|
||||
} else {
|
||||
return [
|
||||
'error' => 'Résultat non trouvé',
|
||||
'code' => 404
|
||||
];
|
||||
}
|
||||
}
|
||||
]
|
||||
];
|
||||
|
||||
// Définition de la base de données
|
||||
require_once 'vendor/autoload.php';
|
||||
use Doctrine\DBAL DriverManager;
|
||||
|
||||
// Initialisation de Doctrine
|
||||
$db = DriverManager::_connection(array(
|
||||
'url' => 'pdo://localhost:5432/mondb',
|
||||
'username' => 'monuser',
|
||||
'password' => 'monmdp',
|
||||
));
|
||||
|
||||
// Initialisation de la requête
|
||||
$query = "
|
||||
CREATE TABLE IF NOT EXISTS `dashboard` (
|
||||
`id` int NOT NULL AUTO_INCREMENT,
|
||||
`kpi` varchar(255) NOT NULL,
|
||||
`valeur` varchar(255) NOT NULL,
|
||||
PRIMARY KEY (`id`)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
||||
";
|
||||
|
||||
// Exécution de la requête
|
||||
$db->executeQuery($query);
|
||||
|
||||
// Gestion des routes
|
||||
http_response_code($args['code']);
|
||||
switch ($args['method']) {
|
||||
case 'GET':
|
||||
// Mise en page pour les données
|
||||
$donnees = $routes[$args['route']]['handler']($data);
|
||||
echo json_encode($donnees);
|
||||
break;
|
||||
case 'POST':
|
||||
// Mise en page pour les données
|
||||
$donnees = $routes[$args['route']]['handler']($data);
|
||||
echo json_encode($donnees);
|
||||
break;
|
||||
case 'PUT':
|
||||
// Mise en page pour les données
|
||||
$donnees = $routes[$args['route']]['handler']($id, $data);
|
||||
echo json_encode($donnees);
|
||||
break;
|
||||
case 'DELETE':
|
||||
// Mise en page pour les données
|
||||
$donnees = $routes[$args['route']]['handler']($id);
|
||||
echo json_encode($donnees);
|
||||
break;
|
||||
}
|
||||
|
||||
// Affichage des données
|
||||
function afficherDonnees($donnees) {
|
||||
// Mise en page pour les données
|
||||
echo "<h1">Affichage des données</h1>";
|
||||
if (isset($donnees['error'])) {
|
||||
echo "<p style='color: red'>Message d'erreur</p>";
|
||||
echo "<p style='color: red'>Code: $donnees[code]</p>";
|
||||
} elseif (isset($donnees['message'])) {
|
||||
echo "<p>Message: $donnees[message]</p>";
|
||||
} elseif (isset($donnees['data'])) {
|
||||
echo "<p>Données: </p>";
|
||||
foreach ($donnees['data'] as $clef => $valeur) {
|
||||
echo "<p>$clef: $valeur</p>";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Récupération des données
|
||||
function recupererDonnees() {
|
||||
// Mise en page pour les données
|
||||
return $donnees;
|
||||
}
|
||||
|
||||
// Afficher les données
|
||||
$donnees = recupererDonnees();
|
||||
|
||||
?>
|
||||
```
|
||||
|
||||
Assurez-vous d'ajouter les packages suivants sous la racine de votre projet :
|
||||
```bash
|
||||
composer require doctrine/dbal
|
||||
```
|
||||
N'oubliez pas de remplacer les informations de connexion à votre base de données dans le fichier.
|
||||
@@ -1,180 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour la création d'une API REST pour le dashboard analytique avec les fonctionnalités demandées :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données PostgreSQL
|
||||
const DB_HOST = 'localhost';
|
||||
const DB_NAME = 'dashboard';
|
||||
const DB_USER = 'utilisateur';
|
||||
const DB_PASSWORD = 'mot_de_passe';
|
||||
|
||||
// Fonction pour se connecter à la base de données
|
||||
function connexionBD() {
|
||||
$connexion = new PDO('pgsql:host=' . DB_HOST . ';dbname=' . DB_NAME, DB_USER, DB_PASSWORD);
|
||||
return $connexion;
|
||||
}
|
||||
|
||||
// Fonction pour créer une table dans la base de données si elle n'existe pas encore
|
||||
function creationTable() {
|
||||
$connexion = connexionBD();
|
||||
$requete = 'CREATE TABLE IF NOT EXISTS dashboard (
|
||||
id SERIAL PRIMARY KEY,
|
||||
kpi VARCHAR(255),
|
||||
valeur VARCHAR(255),
|
||||
date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
)';
|
||||
$connexion->exec($requete);
|
||||
}
|
||||
|
||||
// Fonction pour ajouter un élément au dashboard
|
||||
function ajouterElement($requete) {
|
||||
$connexion = connexionBD();
|
||||
$connexion->exec($requete);
|
||||
}
|
||||
|
||||
// Function pour récuperer tous les éléments du dashboard
|
||||
function recupererElements() {
|
||||
$connexion = connexionBD();
|
||||
$requete = 'SELECT * FROM dashboard';
|
||||
$result = $connexion->query($requete);
|
||||
$donnees = $result->fetchAll(PDO::FETCH_ASSOC);
|
||||
return $donnees;
|
||||
}
|
||||
|
||||
// Fonction pour modifier un élément du dashboard
|
||||
function modifierElement($requete_id, $requete_kpi, $requete_valeur) {
|
||||
$connexion = connexionBD();
|
||||
$requete = "UPDATE dashboard SET kpi = '$requete_kpi', valeur = '$requete_valeur' WHERE id = $requete_id";
|
||||
$connexion->exec($requete);
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un élément du dashboard
|
||||
function supprimerElement($requete_id) {
|
||||
$connexion = connexionBD();
|
||||
$requete = "DELETE FROM dashboard WHERE id = $requete_id";
|
||||
$connexion->exec($requete);
|
||||
}
|
||||
|
||||
// Fonction pour exporter les données du tableau dans un fichier CSV
|
||||
function exporterDonnees($donnees) {
|
||||
$fichier = 'export.csv';
|
||||
$file = fopen($fichier, 'w');
|
||||
foreach ($donnees as $colonne => $valeur) {
|
||||
fputcsv($file, array($colonne));
|
||||
}
|
||||
foreach ($donnees as $ligne => $v) {
|
||||
fputcsv($file, $v);
|
||||
}
|
||||
fclose($file);
|
||||
}
|
||||
|
||||
// Routes API REST
|
||||
|
||||
// Route pour afficher tous les éléments du dashboard
|
||||
$app = new \atk4\ui\App();
|
||||
$router = $app->initRouter();
|
||||
$router->add('GET', '/', '/AfficherElelements');
|
||||
$router->map('GET', '/AfficherElelements', function () {
|
||||
$donnees = recupererElements();
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Donnees recuperer avec succes',
|
||||
'donnees' => $donnees
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Route pour ajouter un nouvel élément au dashboard
|
||||
$router->add('POST', '/', '/ajouterElement');
|
||||
$router->map('POST', '/ajouterElement', function () {
|
||||
$requete = $_POST['requete'];
|
||||
ajouterElement($requete);
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Element ajouté avec successful'
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Route pour afficher un élément spécifique du dashboard
|
||||
$router->add('GET', '/', '/AfficherElelement/{id}');
|
||||
$router->map('GET', '/AfficherElelement/{id}', function ($id) {
|
||||
$requete = "SELECT * FROM dashboard WHERE id = $id";
|
||||
$donnees = connexionBD()->query($requete)->fetch(PDO::FETCH_ASSOC);
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Donnees recuperer avec succès',
|
||||
'donnees' => $donnees
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Route pour modifier un élément spécifique du dashboard
|
||||
$router->add('PUT', '/', '/modifierElement');
|
||||
$router->map('PUT', '/modifierElement', function () {
|
||||
$requete_id = $_POST['requete_id'];
|
||||
$requete_kpi = $_POST['requete_kpi'];
|
||||
$requete_valeur = $_POST['requete_valeur'];
|
||||
modifierElement($requete_id, $requete_kpi, $requete_valeur);
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Element modifié avec succès',
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Route pour supprimer un élément spécifique du dashboard
|
||||
$router->add('DELETE', '/', '/supprimerElement/{id}');
|
||||
$router->map('DELETE', '/supprimerElement/{id}', function ($id) {
|
||||
supprimerElement($id);
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Element supprimé avec succès',
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Route pour exporter les données du tableau dans un fichier CSV
|
||||
$router->add('GET', '/', '/exporterDonnees');
|
||||
$router->map('GET', '/exporterDonnees', function () {
|
||||
$donnees = recupererElements();
|
||||
exporterDonnees($donnees);
|
||||
$reponse = [
|
||||
'status' => 200,
|
||||
'message' => 'Donnees exportées avec succès',
|
||||
];
|
||||
return json_encode($reponse);
|
||||
});
|
||||
|
||||
// Afficher le dashboard (chart, KPI, filtres, export)
|
||||
// Le reste du code ne sera pas exécuté car la route est défini pour qu'elle rend directement la réponse
|
||||
// C'est à vous de choisir comment vous souhaitez afficher le données
|
||||
?>
|
||||
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Dashboard analytique</title>
|
||||
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
|
||||
<style>
|
||||
/* Ajouter votre CSS personnalisé ici */
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="myChart"></canvas>
|
||||
|
||||
<form id="formulaire">
|
||||
<label for="requete">Ajouter un élément au dashboard :</label>
|
||||
<input type="text" id="requete" name="requete" required>
|
||||
<button type="submit">Ajouter</button>
|
||||
</form>
|
||||
|
||||
<form id="modifierFormulaire">
|
||||
<label for="requete_id">Modifier un élément spécifique :</label>
|
||||
<input type="hidden" id="requete_id" name="requete_id" required>
|
||||
<label for="requete_kpi">KPI :</label>
|
||||
<input type="text" id="requete_kpi" name="requete_kpi" required>
|
||||
<label for="requete_valeur">Valeur :</label>
|
||||
<input type="text" id="requete_valeur" name="
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE est fier de vous présenter une solution complète et souveraine pour votre API REST et votre Dashboard analytique. Ce code unique et auto-suffisant est conçu pour la production, intégrant toutes les fonctionnalités demandées : API CRUD, dashboard interactif avec charts, KPIs, fil
|
||||
@@ -1,151 +0,0 @@
|
||||
<?php
|
||||
**Avertissement :** Ce code est susceptible d'être très long et complexe, il est donc recommandé de le décomposer en plusieurs fichiers pour une meilleure maintenabilité et compréhension.
|
||||
|
||||
Voici un exemple d'API REST complète en PHP pour l'ERP avec les modules RH et Comptabilité :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion PostgreSQL
|
||||
$host = '127.0.0.1';
|
||||
$dbname = 'erp';
|
||||
$username = 'erp';
|
||||
$password = 'erp';
|
||||
|
||||
// Mise en place de la connexion PostgreSQL
|
||||
$dsn = "pgsql:host=$host;dbname=$dbname";
|
||||
$conn = new PDO($dsn, $username, $password);
|
||||
|
||||
// Fonction d'affichage des erreurs
|
||||
function afficher erreur($code, $message)
|
||||
{
|
||||
http_response_code($code);
|
||||
echo json_encode(array('erreur' => $message));
|
||||
die();
|
||||
}
|
||||
|
||||
// Fonction d'affichage des données dans un format JSON
|
||||
function afficherDonnees($donnees)
|
||||
{
|
||||
http_response_code(200);
|
||||
echo json_encode($donnees);
|
||||
die();
|
||||
}
|
||||
|
||||
// Route de connexion
|
||||
$app->group('/api', function($itself) use ($conn) {
|
||||
$itself->get('/login', function ($request, $response) use ($conn) {
|
||||
$login = $request->getParam('login');
|
||||
$password = $request->getParam('password');
|
||||
|
||||
$req = $conn->prepare("SELECT * FROM utilisateur WHERE login = :login AND password = :password");
|
||||
$req->bindParam(':login', $login);
|
||||
$req->bindParam(':password', $password);
|
||||
$req->execute();
|
||||
|
||||
$donnees = $req->fetchAll(PDO::FETCH_ASSOC);
|
||||
|
||||
if ($donnees) {
|
||||
$token = bin2hex(random_bytes(32));
|
||||
$donnees[0]['token'] = $token;
|
||||
afficherDonnees($donnees);
|
||||
} else {
|
||||
affichererreur(401, 'Utilisateur ou mot de passe incorrect');
|
||||
}
|
||||
});
|
||||
|
||||
// Route de gestion des utilisateurs
|
||||
$itself->group('/users', function ($itself) use ($conn) {
|
||||
// Route de création d'un utilisateur
|
||||
$itself->post('', function ($request, $response) use ($conn) {
|
||||
$donnees = $request->getParsedBody();
|
||||
$req = $conn->prepare("INSERT INTO utilisateur (login, password, role) VALUES (:login, :password, :role)");
|
||||
$req->bindParam(':login', $donnees['login']);
|
||||
$req->bindParam(':password', $donnees['password']);
|
||||
$req->bindParam(':role', $donnees['role']);
|
||||
$req->execute();
|
||||
afficherDonnees(array('message' => 'Utilisateur créé'));
|
||||
});
|
||||
|
||||
// Route de récupération d'un utilisateur
|
||||
$itself->get('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$req = $conn->prepare("SELECT * FROM utilisateur WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->execute();
|
||||
$donnees = $req->fetchAll(PDO::FETCH_ASSOC);
|
||||
if ($donnees) {
|
||||
afficherDonnees($donnees);
|
||||
} else {
|
||||
affichererreur(404, 'Utilisateur non trouvé');
|
||||
}
|
||||
});
|
||||
|
||||
// Route de mise à jour d'un utilisateur
|
||||
$itself->put('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$donnees = $request->getParsedBody();
|
||||
$req = $conn->prepare("UPDATE utilisateur SET login = :login, password = :password, role = :role WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->bindParam(':login', $donnees['login']);
|
||||
$req->bindParam(':password', $donnees['password']);
|
||||
$req->bindParam(':role', $donnees['role']);
|
||||
$req->execute();
|
||||
afficherDonnees(array('message' => 'Utilisateur mis à jour'));
|
||||
});
|
||||
|
||||
// Route de suppression d'un utilisateur
|
||||
$itself->delete('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$req = $conn->prepare("DELETE FROM utilisateur WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->execute();
|
||||
afficherDonnees(array('message' => 'Utilisateur supprimé'));
|
||||
});
|
||||
});
|
||||
|
||||
// Route de gestion des comptes
|
||||
$itself->group('/compte', function ($itself) use ($conn) {
|
||||
// Route de création d'un compte
|
||||
$itself->post('', function ($request, $response) use ($conn) {
|
||||
$donnees = $request->getParsedBody();
|
||||
$req = $conn->prepare("INSERT INTO compte (libelle, numero, utilisateur_id) VALUES (:libelle, :numero, :utilisateur_id)");
|
||||
$req->bindParam(':libelle', $donnees['libelle']);
|
||||
$req->bindParam(':numero', $donnees['numero']);
|
||||
$req->bindParam(':utilisateur_id', $donnees['utilisateur_id']);
|
||||
$req->execute();
|
||||
afficherDonnees(array('message' => 'Compte créé'));
|
||||
});
|
||||
|
||||
// Route de récupération d'un compte
|
||||
$itself->get('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$req = $conn->prepare("SELECT * FROM compte WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->execute();
|
||||
$donnees = $req->fetchAll(PDO::FETCH_ASSOC);
|
||||
if ($donnees) {
|
||||
afficherDonnees($donnees);
|
||||
} else {
|
||||
affichererreur(404, 'Compte non trouvé');
|
||||
}
|
||||
});
|
||||
|
||||
// Route de mise à jour d'un compte
|
||||
$itself->put('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$donnees = $request->getParsedBody();
|
||||
$req = $conn->prepare("UPDATE compte SET libelle = :libelle, numero = :numero WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->bindParam(':libelle', $donnees['libelle']);
|
||||
$req->bindParam(':numero', $donnees['numero']);
|
||||
$req->execute();
|
||||
afficherDonnees(array('message' => 'Compte mis à jour'));
|
||||
});
|
||||
|
||||
// Route de suppression d'un compte
|
||||
$itself->delete('/{id}', function ($request, $response) use ($conn) {
|
||||
$id = $request->getAttribute('id');
|
||||
$req = $conn->prepare("DELETE FROM compte WHERE id = :id");
|
||||
$req->bindParam(':id', $id);
|
||||
$req->execute();
|
||||
afficherDonnees(array('
|
||||
@@ -1,204 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un ERP complet avec les modules définis :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données PostgreSQL
|
||||
$hostname = 'localhost';
|
||||
$databasename = 'erp_database';
|
||||
$username = 'erp_user';
|
||||
$password = 'erp_password';
|
||||
|
||||
// Établit une connexion à la base de données
|
||||
$conn = pg_connect("host=$hostname dbname=$databasename user=$username password=$password");
|
||||
|
||||
// Test la connexion
|
||||
if (!$conn) {
|
||||
echo 'Connexion échouée : ' . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Configuration API
|
||||
const API_VERSION = 'v1';
|
||||
const BASE_URL = '/api/' . API_VERSION;
|
||||
|
||||
// Route de base pour les requêtes
|
||||
function route($path) {
|
||||
return BASE_URL . $path;
|
||||
}
|
||||
|
||||
// Fonction pour afficher les données sous forme JSON
|
||||
function afficherDonnees($donnees) {
|
||||
header('Content-Type: application/json');
|
||||
echo json_encode($donnees);
|
||||
}
|
||||
|
||||
// Fonction pour gérer les requêtes CURD (CREATE, READ, UPDATE, DELETE)
|
||||
function gererRequete($action, $table, $donnees = null) {
|
||||
global $conn;
|
||||
|
||||
// Règles de sécurité pour les requêtes sécurisées
|
||||
$sql = "
|
||||
SET statement_timeout = 10000;
|
||||
SET array_nulls = ON;
|
||||
SET array_escape = ON;
|
||||
";
|
||||
pg_query($conn, $sql);
|
||||
|
||||
switch ($action) {
|
||||
case 'get':
|
||||
// Lire les données à partir de la base de données
|
||||
$requete = "SELECT * FROM $table;";
|
||||
$resultat = pg_query($conn, $requete);
|
||||
|
||||
if (!$resultat) {
|
||||
$erreur = pg_last_error();
|
||||
return ['erreur' => $erreur];
|
||||
}
|
||||
|
||||
$donnees = pg_fetch_all($resultat);
|
||||
|
||||
// Libérer les ressources de la requête
|
||||
pg_free_result($resultat);
|
||||
break;
|
||||
|
||||
case 'post':
|
||||
// Créer des données dans la base de données
|
||||
$requete = "INSERT INTO $table (" . implode(', ', array_keys($donnees)) . ") VALUES (" . implode(', ', array_map(function ($valeur) {
|
||||
return "'" . pg_escape_string($valeur) . "'";
|
||||
}, array_values($donnees))) . ");";
|
||||
pg_autocommit($conn, PGSQL_TRANSACTION_AUTOCOMMIT);
|
||||
|
||||
if (!pg_query($conn, $requete)) {
|
||||
$erreur = pg_last_error();
|
||||
pg_rollback($conn);
|
||||
return ['erreur' => $erreur];
|
||||
}
|
||||
|
||||
// Ajouter le ID de la dernière ligne inserte
|
||||
$idLigneInsersee = pg_insert_id($conn);
|
||||
|
||||
// Récupérer les données insérées pour la réponse
|
||||
$requete = "SELECT * FROM $table WHERE id = $idLigneInsersee;";
|
||||
$resultat = pg_query($conn, $requete);
|
||||
$donnees = pg_fetch_assoc($resultat);
|
||||
|
||||
// Libérer les ressources de la requête
|
||||
pg_free_result($resultat);
|
||||
pg_commit($conn);
|
||||
break;
|
||||
|
||||
case 'put':
|
||||
// Mettre à jour des données dans la base de données
|
||||
$requete = "UPDATE $table SET " . implode(', ', array_map(function ($cle, $valeur) {
|
||||
return $cle . " = '" . pg_escape_string($valeur) . "'";
|
||||
}, array_keys($donnees), array_values($donnees))) . " WHERE id = " . $donnees['id'] . ";";
|
||||
pg_autocommit($conn, PGSQL_TRANSACTION_AUTOCOMMIT);
|
||||
|
||||
if (!pg_query($conn, $requete)) {
|
||||
$erreur = pg_last_error();
|
||||
pg_rollback($conn);
|
||||
return ['erreur' => $erreur];
|
||||
}
|
||||
|
||||
// Récupérer les données mise à jour pour la réponse
|
||||
$requete = "SELECT * FROM $table WHERE id = " . $donnees['id'] . ";";
|
||||
$resultat = pg_query($conn, $requete);
|
||||
$donnees = pg_fetch_assoc($resultat);
|
||||
|
||||
// Libérer les ressources de la requête
|
||||
pg_free_result($resultat);
|
||||
pg_commit($conn);
|
||||
break;
|
||||
|
||||
case 'delete':
|
||||
// Supprimer des données à partir de la base de données
|
||||
$requete = "DELETE FROM $table WHERE id = " . $donnees['id'] . ";";
|
||||
pg_autocommit($conn, PGSQL_TRANSACTION_AUTOCOMMIT);
|
||||
|
||||
if (!pg_query($conn, $requete)) {
|
||||
$erreur = pg_last_error();
|
||||
pg_rollback($conn);
|
||||
return ['erreur' => $erreur];
|
||||
}
|
||||
|
||||
// Commettre les changements
|
||||
pg_commit($conn);
|
||||
break;
|
||||
}
|
||||
|
||||
return $donnees;
|
||||
}
|
||||
|
||||
// Module Comptabilité
|
||||
function comptabilite($action, $mode = null) {
|
||||
global $conn;
|
||||
|
||||
switch ($mode) {
|
||||
case 'factures':
|
||||
return gererRequete($action, 'factures', array(
|
||||
'id' => 1,
|
||||
'designation' => 'Facture de vente',
|
||||
'montant' => 1000.00
|
||||
));
|
||||
|
||||
case 'comptes':
|
||||
return gererRequete($action, 'comptes', array(
|
||||
'id' => 1,
|
||||
'nom' => 'Compte courant',
|
||||
'solde' => 10000.00
|
||||
));
|
||||
default:
|
||||
return ['erreur' => 'Aucune information disponible'];
|
||||
}
|
||||
}
|
||||
|
||||
// Module RH (Resources Humaines)
|
||||
function rh($action, $mode = null) {
|
||||
global $conn;
|
||||
|
||||
switch ($mode) {
|
||||
case 'employes':
|
||||
return gererRequete($action, 'employes', array(
|
||||
'id' => 1,
|
||||
'nom' => 'Jean Dupont',
|
||||
'poste' => 'Développeur web'
|
||||
));
|
||||
|
||||
case 'salaires':
|
||||
return gererRequete($action, 'salaires', array(
|
||||
'id' => 1,
|
||||
'date' => '2023-01-01',
|
||||
'montant' => 5000.00
|
||||
));
|
||||
default:
|
||||
return ['erreur' => 'Aucune information disponible'];
|
||||
}
|
||||
}
|
||||
|
||||
// Module Stock
|
||||
function stock($action, $mode = null) {
|
||||
global $conn;
|
||||
|
||||
switch ($mode) {
|
||||
case 'produits':
|
||||
return gererRequete($action, 'produits', array(
|
||||
'id' => 1,
|
||||
'designation' => 'Produit de stock',
|
||||
'quantite' => 100
|
||||
));
|
||||
|
||||
case 'achats':
|
||||
return gererRequete($action, 'achats', array(
|
||||
'id' => 1,
|
||||
'date' => '2023-01-01',
|
||||
'quantite' => 50
|
||||
));
|
||||
default:
|
||||
return ['erreur' => 'Aucune information disponible'];
|
||||
}
|
||||
}
|
||||
|
||||
// Module Ventes
|
||||
function vent
|
||||
@@ -1,196 +0,0 @@
|
||||
<?php
|
||||
Voici une implémentation complète d'une API REST en PHP pour un ERP complet avec les modules suivants : Comptabilité, RH, Stock, Ventes, Achats et CRM.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'erp');
|
||||
define('DB_USER', 'root');
|
||||
define('DB_PASSWORD', '');
|
||||
|
||||
// Création de la connexion à la base de données
|
||||
$conn = pg_connect("host=" . DB_HOST . ";dbname=" . DB_NAME . ";user=" . DB_USER . ";password=" . DB_PASSWORD);
|
||||
|
||||
// Vérification de la connexion
|
||||
if (!$conn) {
|
||||
die("Erreur de connexion : " . pg_last_error());
|
||||
}
|
||||
|
||||
// Fichier de configuration pour les routes
|
||||
define('ROOT', '/erp-api/');
|
||||
define('API_VERSION', 'v1');
|
||||
|
||||
// Création des tables dans la base de données
|
||||
function createTables() {
|
||||
// Comptabilité
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS comptes (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(255) NOT NULL,
|
||||
numero INTEGER NOT NULL
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS debit (
|
||||
id SERIAL PRIMARY KEY,
|
||||
compte_id INTEGER NOT NULL REFERENCES comptes(id),
|
||||
montant DECIMAL NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS credit (
|
||||
id SERIAL PRIMARY KEY,
|
||||
compte_id INTEGER NOT NULL REFERENCES comptes(id),
|
||||
montant DECIMAL NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
// RH
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS employes (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(255) NOT NULL,
|
||||
prenom VARCHAR(255) NOT NULL,
|
||||
email VARCHAR(255) NOT NULL,
|
||||
telephone VARCHAR(20) NOT NULL
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS salaires (
|
||||
id SERIAL PRIMARY KEY,
|
||||
employe_id INTEGER NOT NULL REFERENCES employes(id),
|
||||
montant DECIMAL NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
// Stock
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS produits (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(255) NOT NULL,
|
||||
quantite DECIMAL NOT NULL
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS commandes (
|
||||
id SERIAL PRIMARY KEY,
|
||||
produit_id INTEGER NOT NULL REFERENCES produits(id),
|
||||
quantite DECIMAL NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
// Ventes
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS ventes (
|
||||
id SERIAL PRIMARY KEY,
|
||||
produit_id INTEGER NOT NULL REFERENCES produits(id),
|
||||
cliente VARCHAR(255) NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
// Achats
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS achats (
|
||||
id SERIAL PRIMARY KEY,
|
||||
produit_id INTEGER NOT NULL REFERENCES produits(id),
|
||||
fournisseur VARCHAR(255) NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
// CRM
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS clients (
|
||||
id SERIAL PRIMARY KEY,
|
||||
nom VARCHAR(255) NOT NULL,
|
||||
prenom VARCHAR(255) NOT NULL,
|
||||
email VARCHAR(255) NOT NULL
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
|
||||
$query = '
|
||||
CREATE TABLE IF NOT EXISTS opportunites (
|
||||
id SERIAL PRIMARY KEY,
|
||||
client_id INTEGER NOT NULL REFERENCES clients(id),
|
||||
projet VARCHAR(255) NOT NULL,
|
||||
date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
';
|
||||
pg_query($conn, $query);
|
||||
}
|
||||
|
||||
createTables();
|
||||
|
||||
// Routes
|
||||
function route($method, $path) {
|
||||
switch ($path) {
|
||||
case 'comptes':
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
$query = 'SELECT * FROM comptes;';
|
||||
return json_decode(pg_query($conn, $query), true);
|
||||
case 'POST':
|
||||
$body = json_decode(file_get_contents('php://input'), true);
|
||||
$query = 'INSERT INTO comptes (nom, numero) VALUES (\'' . $body['nom'] . '\', ' . $body['numero'] . ');';
|
||||
pg_query($conn, $query);
|
||||
return array('message' => 'Compte ajouté avec succès');
|
||||
default:
|
||||
return array('message' => 'Méthode non autorisée');
|
||||
}
|
||||
case 'comptes/{id}':
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
$query = 'SELECT * FROM comptes WHERE id = ' . (int)$path[1] . ';';
|
||||
return json_decode(pg_query($conn, $query), true);
|
||||
case 'PUT':
|
||||
$body = json_decode(file_get_contents('php://input'), true);
|
||||
$query = 'UPDATE comptes SET nom = \'' . $body['nom'] . '\', numero = ' . $body['numero'] . ' WHERE id = ' . (int)$path[1] . ';';
|
||||
pg_query($conn, $query);
|
||||
return array('message' => 'Compte mis à jour avec succès');
|
||||
case 'DELETE':
|
||||
$query = 'DELETE FROM comptes WHERE id = ' . (int)$path[1] . ';';
|
||||
pg_query($conn, $query);
|
||||
return array('message' => 'Compte supprimé avec succès');
|
||||
default:
|
||||
return array('message' => 'Méthode non autorisée');
|
||||
}
|
||||
case 'debit':
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
$query = 'SELECT * FROM debit;';
|
||||
return json_decode(pg_query($conn, $query), true);
|
||||
case 'POST':
|
||||
$body = json_decode(file_get_contents('php://input'), true);
|
||||
$query = 'INSERT INTO debit (compte_id, montant, date) VALUES (' . $body['compte_id'] . ', ' . $body['montant'] . ', \' ' . $body['date'] . '\');';
|
||||
pg_query($conn, $query);
|
||||
return array('message' => 'Débit ajouté avec succès');
|
||||
default:
|
||||
return array('message' => 'Méthode non autorisée');
|
||||
}
|
||||
case 'debit/{id}':
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
$query = 'SELECT * FROM debit WHERE id = ' . (int)$path[1] . ';';
|
||||
return json_decode(pg_query($conn, $query), true);
|
||||
case 'PUT':
|
||||
@@ -1,6 +0,0 @@
|
||||
<?php
|
||||
WEVCODE, Générateur de Code Souverain WEVAL
|
||||
|
||||
---
|
||||
|
||||
Bien sûr, Maître. Voici une API REST complète et fonctionnelle pour votre ERP avec tous les modules requis, contenue dans un seul fichier PHP, utilisant PHP 8.2+, PostgreSQL, et des réponses JSON
|
||||
@@ -1,220 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complet pour une API REST ERP avec les modules que vous avez mentionnés. Ce code utilise la connexion PostgreSQL pour les opérations CRUD. C'est un fichier unique PHP qui inclut toutes les classes et fonctions nécessaires.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Connexion à la base de données PostgreSQL
|
||||
function connexionBd() {
|
||||
$db_user = 'votre_utilisateur';
|
||||
$db_pass = 'votre_mot_de_passe';
|
||||
$db_name = 'votre_base_de_donnees';
|
||||
$db_host = 'localhost';
|
||||
try {
|
||||
$connexion = new PDO('pgsql:host='.$db_host.';dbname='.$db_name, $db_user, $db_pass);
|
||||
$connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
return $connexion;
|
||||
} catch (PDOException $e) {
|
||||
echo 'Erreur de connexion à la base de données : ' . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
// Classe pour les entités de la base de données
|
||||
class Compte {
|
||||
private $id;
|
||||
private $nom;
|
||||
private $prenom;
|
||||
private $adresse;
|
||||
|
||||
public function __construct($id, $nom, $prenom, $adresse) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->prenom = $prenom;
|
||||
$this->adresse = $adresse;
|
||||
}
|
||||
|
||||
public function getId() {
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function getNom() {
|
||||
return $this->nom;
|
||||
}
|
||||
|
||||
public function getPrenom() {
|
||||
return $this->prenom;
|
||||
}
|
||||
|
||||
public function getAdresse() {
|
||||
return $this->adresse;
|
||||
}
|
||||
}
|
||||
|
||||
class Fournisseur {
|
||||
private $id;
|
||||
private $nom;
|
||||
private $adresse;
|
||||
|
||||
public function __construct($id, $nom, $adresse) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->adresse = $adresse;
|
||||
}
|
||||
|
||||
public function getId() {
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function getNom() {
|
||||
return $this->nom;
|
||||
}
|
||||
|
||||
public function getAdresse() {
|
||||
return $this->adresse;
|
||||
}
|
||||
}
|
||||
|
||||
class Produit {
|
||||
private $id;
|
||||
private $description;
|
||||
private $prix;
|
||||
private $quantite;
|
||||
|
||||
public function __construct($id, $description, $prix, $quantite) {
|
||||
$this->id = $id;
|
||||
$this->description = $description;
|
||||
$this->prix = $prix;
|
||||
$this->quantite = $quantite;
|
||||
}
|
||||
|
||||
public function getId() {
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function getDescription() {
|
||||
return $this->description;
|
||||
}
|
||||
|
||||
public function getPrix() {
|
||||
return $this->prix;
|
||||
}
|
||||
|
||||
public function getQuantite() {
|
||||
return $this->quantite;
|
||||
}
|
||||
}
|
||||
|
||||
class CompteCompta extends Compte {
|
||||
private $compte;
|
||||
|
||||
public function __construct($id, $nom, $prenom, $adresse, $compte) {
|
||||
parent::__construct($id, $nom, $prenom, $adresse);
|
||||
$this->compte = $compte;
|
||||
}
|
||||
|
||||
public function getCompte() {
|
||||
return $this->compte;
|
||||
}
|
||||
}
|
||||
|
||||
class Vente extends CompteCompta {
|
||||
private $produit;
|
||||
private $quantite;
|
||||
private $date;
|
||||
|
||||
public function __construct($id, $nom, $prenom, $adresse, $compte, $produit, $quantite, $date) {
|
||||
parent::__construct($id, $nom, $prenom, $adresse, $compte);
|
||||
$this->produit = $produit;
|
||||
$this->quantite = $quantite;
|
||||
$this->date = $date;
|
||||
}
|
||||
|
||||
public function getProduit() {
|
||||
return $this->produit;
|
||||
}
|
||||
|
||||
public function getQuantite() {
|
||||
return $this->quantite;
|
||||
}
|
||||
|
||||
public function getDate() {
|
||||
return $this->date;
|
||||
}
|
||||
}
|
||||
|
||||
class Achats extends Vente {
|
||||
private $fournisseur;
|
||||
private $prix;
|
||||
private $date;
|
||||
|
||||
public function __construct($id, $nom, $prenom, $adresse, $compte, $produit, $quantite, $date, $fournisseur, $prix, $dateAchat) {
|
||||
parent::__construct($id, $nom, $prenom, $adresse, $compte, $produit, $quantite, $date);
|
||||
$this->fournisseur = $fournisseur;
|
||||
$this->prix = $prix;
|
||||
$this->dateAchat = $dateAchat;
|
||||
}
|
||||
|
||||
public function getFournisseur() {
|
||||
return $this->fournisseur;
|
||||
}
|
||||
|
||||
public function getPrix() {
|
||||
return $this->prix;
|
||||
}
|
||||
|
||||
public function getDateAchat() {
|
||||
return $this->dateAchat;
|
||||
}
|
||||
}
|
||||
|
||||
class Stock extends Produit {
|
||||
private $quantiteStock;
|
||||
|
||||
public function __construct($id, $description, $prix, $quantite, $quantiteStock) {
|
||||
parent::__construct($id, $description, $prix, $quantite);
|
||||
$this->quantiteStock = $quantiteStock;
|
||||
}
|
||||
|
||||
public function getQuantiteStock() {
|
||||
return $this->quantiteStock;
|
||||
}
|
||||
}
|
||||
|
||||
// Traitement des requêtes
|
||||
function traitement(Request $request, $connexion) {
|
||||
$method = $request->getMethod();
|
||||
switch ($method) {
|
||||
case 'GET':
|
||||
return traitementGet($request, $connexion);
|
||||
case 'POST':
|
||||
return traitementPost($request, $connexion);
|
||||
case 'PUT':
|
||||
return traitementPut($request, $connexion);
|
||||
case 'DELETE':
|
||||
return traitementDelete($request, $connexion);
|
||||
}
|
||||
}
|
||||
|
||||
function traitementGet(Request $request, $connexion) {
|
||||
$requete = $request->getQueryParams();
|
||||
if ($requete['operation'] == 'comptes') {
|
||||
$sql = 'SELECT * FROM comptes';
|
||||
$resultat = $connexion->query($sql);
|
||||
$controleurs = array();
|
||||
while ($ligne = $resultat->fetch(PDO::FETCH_ASSOC)) {
|
||||
$id = $ligne['id'];
|
||||
$nom = $ligne['nom'];
|
||||
$prenom = $ligne['prenom'];
|
||||
$adresse = $ligne['adresse'];
|
||||
$controleur = new Compte($id, $nom, $prenom, $adresse);
|
||||
$controleurs[] = $controleur;
|
||||
}
|
||||
return json_encode($controleurs);
|
||||
} elseif ($requete['operation'] == 'comptesCompta') {
|
||||
$sql = 'SELECT * FROM comptesCompta';
|
||||
$resultat = $connexion->query($sql);
|
||||
$controleursCompta = array();
|
||||
while ($ligne = $resultat->fetch(PDO::FETCH_ASSOC)) {
|
||||
$id = $ligne['id'];
|
||||
$nom = $ligne['nom
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVAL vous présente WEVCODE, un générateur de code souverain et robuste. Ce code PHP est conçu pour une API REST complète, respectant les principes SOLID autant que possible dans un fichier unique, en utilisant PHP 8.1+ (assumé pour "PHP 8.5")
|
||||
@@ -1,4 +0,0 @@
|
||||
<?php
|
||||
WEVCODE. Générateur de code souverain WEVAL. Engagement total pour un code robuste et sans compromis.
|
||||
|
||||
Préparez-vous à déployer la puissance de votre ERP avec cette API REST complète et autonome. Ce monolithe PHP encapsule les six modules essentiels, garant
|
||||
@@ -1,232 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST ERP en PHP 8.5 avec connexion PostgreSQL :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Fichier de configuration
|
||||
const DB_HOST = 'localhost';
|
||||
const DB_PORT = 5432;
|
||||
const DB_USERNAME = 'utilisateur';
|
||||
const DB_PASSWORD = 'motdepasse';
|
||||
const DB_NAME = 'erpdb';
|
||||
const API_SECRET = 'secret-api';
|
||||
|
||||
// Fichier de configuration de la base de données
|
||||
try {
|
||||
$pdo = new PDO(
|
||||
"pgsql:host=$DB_HOST;dbname=$DB_NAME",
|
||||
$DB_USERNAME,
|
||||
$DB_PASSWORD
|
||||
);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
echo 'Connexion à la base de données réussie !';
|
||||
} catch (PDOException $e) {
|
||||
echo "Erreur de connexion à la base de données : " . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Fichier de configuration de la sécurisation
|
||||
function securePostData ($data) {
|
||||
$secureData = [];
|
||||
foreach ($data as $key => $value) {
|
||||
if (!empty($value)) {
|
||||
$secureData[$key] = htmlspecialchars( trim($value) );
|
||||
}
|
||||
}
|
||||
return $secureData;
|
||||
}
|
||||
|
||||
// Fonction pour encryption & decryption data
|
||||
function genRandomString() {
|
||||
$caractères = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
|
||||
$raz = '';
|
||||
for ($i = 0; $i < 32; $i++) {
|
||||
$raz .= $caractères[rand(0, strlen($caractères) - 1)];
|
||||
}
|
||||
return $raz;
|
||||
}
|
||||
|
||||
// Fonction pour validation api_key
|
||||
function validApikey() {
|
||||
$input = $_SERVER['HTTP_API_KEY'];
|
||||
$decrypted = openssl_decrypt(base64_decode($input), 'AES-128-CBC', genRandomString(), 0, genRandomString());
|
||||
return base64_decode($decrypted)===API_SECRET;
|
||||
}
|
||||
|
||||
// Fonctions pour les requêtes CRUD
|
||||
function getComptabilite() {
|
||||
$statement = $pdo->prepare("
|
||||
SELECT *
|
||||
FROM comptabilité
|
||||
");
|
||||
$statement->execute();
|
||||
return $statement->fetchAll();
|
||||
}
|
||||
|
||||
function crearComptabilite(&$data) {
|
||||
$data['created_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
INSERT INTO comptabilité (
|
||||
name, content, created_at
|
||||
)
|
||||
VALUES (
|
||||
:name, :content, :created_at
|
||||
)
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':created_at' => $data['created_at'],
|
||||
]);
|
||||
// return last insert id
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
|
||||
function updateComptabilite($id, &$data) {
|
||||
$data['updated_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
UPDATE comptabilité
|
||||
SET
|
||||
name = :name,
|
||||
content = :content,
|
||||
updated_at = :updated_at
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':updated_at' => $data['updated_at'],
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
|
||||
function deleteComptabilite($id) {
|
||||
$statement = $pdo->prepare("
|
||||
DELETE FROM comptabilité
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
|
||||
function getRH() {
|
||||
$statement = $pdo->prepare("
|
||||
SELECT *
|
||||
FROM rh
|
||||
");
|
||||
$statement->execute();
|
||||
return $statement->fetchAll();
|
||||
}
|
||||
function crearRH(&$data) {
|
||||
$data['created_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
INSERT INTO rh (
|
||||
name, content, created_at
|
||||
)
|
||||
VALUES (
|
||||
:name, :content, :created_at
|
||||
)
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':created_at' => $data['created_at'],
|
||||
]);
|
||||
// return last insert id
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
function updateRH($id, &$data) {
|
||||
$data['updated_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
UPDATE rh
|
||||
SET
|
||||
name = :name,
|
||||
content = :content,
|
||||
updated_at = :updated_at
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':updated_at' => $data['updated_at'],
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
function deleteRH($id) {
|
||||
$statement = $pdo->prepare("
|
||||
DELETE FROM rh
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
|
||||
function getStock() {
|
||||
$statement = $pdo->prepare("
|
||||
SELECT *
|
||||
FROM stock
|
||||
");
|
||||
$statement->execute();
|
||||
return $statement->fetchAll();
|
||||
}
|
||||
function crearStock(&$data) {
|
||||
$data['created_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
INSERT INTO stock (
|
||||
name, content, created_at
|
||||
)
|
||||
VALUES (
|
||||
:name, :content, :created_at
|
||||
)
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':created_at' => $data['created_at'],
|
||||
]);
|
||||
// return last insert id
|
||||
return $pdo->lastInsertId();
|
||||
}
|
||||
function updateStock($id, &$data) {
|
||||
$data['updated_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
UPDATE stock
|
||||
SET
|
||||
name = :name,
|
||||
content = :content,
|
||||
updated_at = :updated_at
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':name' => $data['name'],
|
||||
':content' => $data['content'],
|
||||
':updated_at' => $data['updated_at'],
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
function deleteStock($id) {
|
||||
$statement = $pdo->prepare("
|
||||
DELETE FROM stock
|
||||
WHERE id = :id
|
||||
");
|
||||
$statement->execute([
|
||||
':id' => $id,
|
||||
]);
|
||||
}
|
||||
|
||||
function getVente() {
|
||||
$statement = $pdo->prepare("
|
||||
SELECT *
|
||||
FROM vente
|
||||
");
|
||||
$statement->execute();
|
||||
return $statement->fetchAll();
|
||||
}
|
||||
function crearVente(&$data) {
|
||||
$data['created_at'] = date('Y-m-d H:i:s');
|
||||
$statement = $pdo->prepare("
|
||||
INSERT INTO vente (
|
||||
name,
|
||||
@@ -1,184 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour un ERP complet avec les modules que vous avez listés :
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données PostgreSQL
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'erp');
|
||||
define('DB_USER', 'erp');
|
||||
define('DB_PASSWORD', 'erp');
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=" . DB_HOST . " dbname=" . DB_NAME . " user=" . DB_USER . " password=" . DB_PASSWORD);
|
||||
|
||||
if (!$conn) {
|
||||
echo 'Échec de la connexion à la base de données : ' . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Fonction pour effectuer une requête SQL
|
||||
function executeQuery($requete) {
|
||||
global $conn;
|
||||
$resultat = pg_query($conn, $requete);
|
||||
if (!$resultat) {
|
||||
echo 'Erreur SQL : ' . pg_last_error();
|
||||
}
|
||||
return $resultat;
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les données en format JSON
|
||||
function getData($table, $conditions = '') {
|
||||
global $conn;
|
||||
if (!empty($conditions)) {
|
||||
$requete = "SELECT * FROM $table WHERE $conditions";
|
||||
} else {
|
||||
$requete = "SELECT * FROM $table";
|
||||
}
|
||||
$resultat = pg_query($conn, $requete);
|
||||
$donnees = pg_fetch_all($resultat);
|
||||
pg_free_result($resultat);
|
||||
return json_encode($donnees);
|
||||
}
|
||||
|
||||
// Fonction pour insérer des données
|
||||
function insertData($table, $donnees) {
|
||||
global $conn;
|
||||
$colonnes = implode(', ', array_keys($donnees));
|
||||
$valeurs = "'" . implode("', '", $donnees) . "'";
|
||||
$requete = "INSERT INTO $table ($colonnes) VALUES ($valeurs)";
|
||||
executeQuery($requete);
|
||||
return pg_insert_result($conn, $requete);
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour des données
|
||||
function updateData($table, $donnees, $conditions) {
|
||||
global $conn;
|
||||
$colonnes = implode(', ', array_keys($donnees));
|
||||
$valeurs = '';
|
||||
foreach ($donnees as $cle => $valeur) {
|
||||
$valeurs .= "$cle = '$valeur', ";
|
||||
}
|
||||
$valeurs = rtrim($valeurs, ', ');
|
||||
$requete = "UPDATE $table SET $valeurs WHERE $conditions";
|
||||
executeQuery($requete);
|
||||
return pg_commit($conn);
|
||||
}
|
||||
|
||||
// Fonction pour supprimer des données
|
||||
function deleteData($table, $conditions) {
|
||||
global $conn;
|
||||
$requete = "DELETE FROM $table WHERE $conditions";
|
||||
executeQuery($requete);
|
||||
return pg_commit($conn);
|
||||
}
|
||||
|
||||
// Module Comptabilité
|
||||
$tableComptabilite = 'comptabilite';
|
||||
|
||||
// Module RH
|
||||
$tableRH = 'rh';
|
||||
|
||||
// Module Stock
|
||||
$tableStock = 'stock';
|
||||
|
||||
// Module Ventes
|
||||
$tableVentes = 'ventes';
|
||||
|
||||
// Module Achats
|
||||
$tableAchats = 'achats';
|
||||
|
||||
// Module CRM
|
||||
$tableCRM = 'crm';
|
||||
|
||||
// Routes API REST
|
||||
$app = new \Slim\App();
|
||||
|
||||
$app->group('/comptabilite', function () {
|
||||
$this->get('/tout', function ($request, $response, $args) {
|
||||
return $response->withJson(getData($tableComptabilite));
|
||||
});
|
||||
|
||||
$this->get('/{:id}', function ($request, $response, $args) use ($tableComptabilite) {
|
||||
$id = $args['id'];
|
||||
$conditions = "id = '$id'";
|
||||
return $response->withJson(getData($tableComptabilite, $conditions));
|
||||
});
|
||||
|
||||
$this->post('/', function ($request, $response, $args) {
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(insertData($tableComptabilite, $donnees));
|
||||
});
|
||||
|
||||
$this->put('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
$conditions = "id = '$id'";
|
||||
return $response->withJson(updateData($tableComptabilite, $donnees, $conditions));
|
||||
});
|
||||
|
||||
$this->delete('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$conditions = "id = '$id'";
|
||||
return $response->withJson(deleteData($tableComptabilite, $conditions));
|
||||
});
|
||||
});
|
||||
|
||||
$app->group('/rh', function () {
|
||||
$this->get('/tout', function ($request, $response, $args) {
|
||||
return $response->withJson(getData($tableRH));
|
||||
});
|
||||
|
||||
$this->post('/', function ($request, $response, $args) {
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(insertData($tableRH, $donnees));
|
||||
});
|
||||
|
||||
$this->put('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(updateData($tableRH, $donnees));
|
||||
});
|
||||
|
||||
$this->delete('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
return $response->withJson(deleteData($tableRH, "id = '$id'"));
|
||||
});
|
||||
});
|
||||
|
||||
$app->group('/stocks', function () {
|
||||
$this->get('/tout', function ($request, $response, $args) {
|
||||
return $response->withJson(getData($tableStock));
|
||||
});
|
||||
|
||||
$this->post('/', function ($request, $response, $args) {
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(insertData($tableStock, $donnees));
|
||||
});
|
||||
|
||||
$this->put('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(updateData($tableStock, $donnees));
|
||||
});
|
||||
|
||||
$this->delete('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
return $response->withJson(deleteData($tableStock, "id = '$id'"));
|
||||
});
|
||||
});
|
||||
|
||||
$app->group('/ventes', function () {
|
||||
$this->get('/tout', function ($request, $response, $args) {
|
||||
return $response->withJson(getData($tableVentes));
|
||||
});
|
||||
|
||||
$this->post('/', function ($request, $response, $args) {
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->withJson(insertData($tableVentes, $donnees));
|
||||
});
|
||||
|
||||
$this->put('/{:id}', function ($request, $response, $args) {
|
||||
$id = $args['id'];
|
||||
$donnees = $request->getParsedBody();
|
||||
return $response->with
|
||||
@@ -1,148 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple d'API REST complète en PHP pour un ERP complet avec les modules demandés. Ce code utilise PHP 8.5 et PostgreSQL.
|
||||
|
||||
**erp_api.php**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration PostgreSQL
|
||||
$db_host = 'localhost';
|
||||
$db_name = 'erp_db';
|
||||
$db_user = 'erp_user';
|
||||
$db_password = 'erp_password';
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=$db_host dbname=$db_name user=$db_user password=$db_password")
|
||||
or die ('Erreur : ' . pg_last_error());
|
||||
|
||||
// Fonction de cryptage de mot de passe
|
||||
function cryptage($password) {
|
||||
$salt = 'secret_salt';
|
||||
return hash('sha256', $salt . $password);
|
||||
}
|
||||
|
||||
// Route de connexion
|
||||
$app->post('/connexion', function ($request, $response) use ($conn) {
|
||||
$login = $request->getParsedBody()['login'];
|
||||
$password = $request->getParsedBody()['password'];
|
||||
|
||||
$password_crypt = cryptage($password);
|
||||
|
||||
$sql = "SELECT * FROM utilisateurs WHERE login = :login AND mot_de_passe = :password_crypt";
|
||||
$stmt = pg_prepare($conn, ' preparation_name', $sql);
|
||||
pg_bind($stmt, ':login', $login);
|
||||
pg_bind($stmt, ':password_crypt', $password_crypt);
|
||||
|
||||
$result = pg_execute($conn, ' preparation_name');
|
||||
|
||||
if (pg_num_rows($result) > 0) {
|
||||
return $response->withJson(['token' => 'token_value', 'message' => 'Connexion réussie'], 200);
|
||||
} else {
|
||||
return $response->withJson(['message' => 'Erreur de connexion'], 401);
|
||||
}
|
||||
});
|
||||
|
||||
// Route de gestion des comptes
|
||||
$app->group('/comptabilite', function ($gr) use ($conn) {
|
||||
// Route de Récupération de toutes les comptes
|
||||
$gr->get('/tous', function ($request, $response) use ($conn) {
|
||||
$sql = "SELECT * FROM comptes";
|
||||
$result = pg_query($conn, $sql);
|
||||
return $response->withJson(pg_fetch_all($result), 200);
|
||||
});
|
||||
|
||||
// Route de création d'un compte
|
||||
$gr->post('/create', function ($request, $response) use ($conn) {
|
||||
$titre = $request->getParsedBody()['titre'];
|
||||
$description = $request->getParsedBody()['description'];
|
||||
|
||||
$sql = "INSERT INTO comptes (titre, description) VALUES (:titre, :description)";
|
||||
$stmt = pg_prepare($conn, 'preparation_name', $sql);
|
||||
pg_bind($stmt, ':titre', $titre);
|
||||
pg_bind($stmt, ':description', $description);
|
||||
|
||||
$result = pg_execute($conn, 'preparation_name');
|
||||
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return $response->withJson(['message' => 'Compte créé avec succès'], 201);
|
||||
} else {
|
||||
return $response->withJson(['message' => 'Erreur de création de compte'], 500);
|
||||
}
|
||||
});
|
||||
|
||||
// Route de mise à jour d'un compte
|
||||
$gr->put('/update/{id}', function ($request, $response, $args) use ($conn) {
|
||||
$id = $args['id'];
|
||||
$titre = $request->getParsedBody()['titre'];
|
||||
$description = $request->getParsedBody()['description'];
|
||||
|
||||
$sql = "UPDATE comptes SET titre = :titre, description = :description WHERE id = :id";
|
||||
$stmt = pg_prepare($conn, 'preparation_name', $sql);
|
||||
pg_bind($stmt, ':id', $id);
|
||||
pg_bind($stmt, ':titre', $titre);
|
||||
pg_bind($stmt, ':description', $description);
|
||||
|
||||
$result = pg_execute($conn, 'preparation_name');
|
||||
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return $response->withJson(['message' => 'Compte mis à jour avec succès'], 200);
|
||||
} else {
|
||||
return $response->withJson(['message' => 'Erreur de mise à jour de compte'], 500);
|
||||
}
|
||||
});
|
||||
|
||||
// Route de suppression d'un compte
|
||||
$gr->delete('/delete/{id}', function ($request, $response, $args) use ($conn) {
|
||||
$id = $args['id'];
|
||||
|
||||
$sql = "DELETE FROM comptes WHERE id = :id";
|
||||
$stmt = pg_prepare($conn, 'preparation_name', $sql);
|
||||
pg_bind($stmt, ':id', $id);
|
||||
|
||||
$result = pg_execute($conn, 'preparation_name');
|
||||
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return $response->withJson(['message' => 'Compte supprimé avec succès'], 200);
|
||||
} else {
|
||||
return $response->withJson(['message' => 'Erreur de suppression de compte'], 500);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// Route de gestion des RH
|
||||
$app->group('/rh', function ($gr) use ($conn) {
|
||||
// Route de Récupération de toutes les fiches de poste
|
||||
$gr->get('/tous', function ($request, $response) use ($conn) {
|
||||
$sql = "SELECT * FROM fiches_de_poste";
|
||||
$result = pg_query($conn, $sql);
|
||||
return $response->withJson(pg_fetch_all($result), 200);
|
||||
});
|
||||
|
||||
// Route de création d'une fiche de poste
|
||||
$gr->post('/create', function ($request, $response) use ($conn) {
|
||||
$titre = $request->getParsedBody()['titre'];
|
||||
$description = $request->getParsedBody()['description'];
|
||||
|
||||
$sql = "INSERT INTO fiches_de_poste (titre, description) VALUES (:titre, :description)";
|
||||
$stmt = pg_prepare($conn, 'preparation_name', $sql);
|
||||
pg_bind($stmt, ':titre', $titre);
|
||||
pg_bind($stmt, ':description', $description);
|
||||
|
||||
$result = pg_execute($conn, 'preparation_name');
|
||||
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return $response->withJson(['message' => 'Fiche de poste créée avec succès'], 201);
|
||||
} else {
|
||||
return $response->withJson(['message' => 'Erreur de création de fiche de poste'], 500);
|
||||
}
|
||||
});
|
||||
|
||||
// Route de mise à jour d'une fiche de poste
|
||||
$gr->put('/update/{id}', function ($request, $response, $args) use ($conn) {
|
||||
$id = $args['id'];
|
||||
$titre = $request->getParsedBody()['titre'];
|
||||
$description = $request->getParsedBody()['description'];
|
||||
|
||||
$sql = "UPDATE fiches_de_poste SET titre = :titre, description = :description WHERE id = :id";
|
||||
$stmt = pg_prepare($conn, 'preparation_name', $sql);
|
||||
pg_bind
|
||||
@@ -1,4 +0,0 @@
|
||||
<?php
|
||||
WEVCODE, générateur de code souverain WEVAL, est honoré de générer un système ERP REST API complet, fonctionnel et de qualité production, respectant les standards PHP 8.5, PostgreSQL, et une architecture en un seul fichier.
|
||||
|
||||
Ce code inclut :
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE, generateur de code souverain WEVAL, est fier de vous présenter une API REST PHP 8.5+ complète pour votre ERP. Ce fichier unique est conçu pour être directement fonctionnel, sans placeholders, avec une connexion PostgreSQL robuste et des réponses JSON structurées
|
||||
@@ -1,3 +0,0 @@
|
||||
<?php
|
||||
Ah, WEVCODE à l'œuvre ! Le code souverain de WEVAL, complet, fonctionnel, sans compromis. Préparons une API REST d'ERP robuste pour PHP 8.5 et PostgreSQL, encapsulée dans un unique fichier, prête pour la production.
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
<?php
|
||||
// 2. config.php – variables d’env + autoload
|
||||
define('DB_DSN', 'mysql:host=localhost;dbname=erp;charset=utf8mb4');
|
||||
define('DB_USER', $_ENV['DB_USER'] ?? 'root');
|
||||
define('DB_PASS', $_ENV['DB_PASS'] ?? '']);
|
||||
|
||||
spl_autoload_register(function ($c) {
|
||||
$c = str_replace('\\', '/', $c);
|
||||
require_once __DIR__ . "/$c.php";
|
||||
});
|
||||
1
generated/gen-20260416-225504.svg
Normal file
1
generated/gen-20260416-225504.svg
Normal file
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 200"><rect width="400" height="200" rx="20" fill="#0f172a"/><text x="200" y="110" text-anchor="middle" font-family="sans-serif" font-size="48" font-weight="bold" fill="#4d84ff">WEVAL</text></svg>
|
||||
|
After Width: | Height: | Size: 252 B |
@@ -1,150 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code source pour une API REST complète en PHP pour les microservices suivants :
|
||||
|
||||
- API Gateway
|
||||
- User Service
|
||||
- Product Service
|
||||
- Order Service
|
||||
- Message Queue ( RabbitMQ )
|
||||
|
||||
```php
|
||||
// api-gateway.php
|
||||
<?php
|
||||
|
||||
// Configuration PostgreSQL
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_USER', 'postgres');
|
||||
define('DB_PASSWORD', 'password');
|
||||
define('DB_NAME', 'société');
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=" . DB_HOST . ";dbname=" . DB_NAME . " user=" . DB_USER . " password=" . DB_PASSWORD);
|
||||
|
||||
if (!$conn) {
|
||||
die('Erreur de connexion ' . pg_last_error());
|
||||
}
|
||||
|
||||
// Fonction de gestion de microservices
|
||||
$microservices = [
|
||||
'users' => 'http://localhost:8080/users',
|
||||
'products' => 'http://localhost:8081/products',
|
||||
'orders' => 'http://localhost:8082/orders',
|
||||
];
|
||||
|
||||
// Fonction de routeur
|
||||
function routeer($methode, $route) {
|
||||
$strRoute = '/' . $route;
|
||||
switch ($methode) {
|
||||
case 'GET':
|
||||
return requeteGet($strRoute);
|
||||
case 'POST':
|
||||
return requetePost($strRoute);
|
||||
case 'PUT':
|
||||
return requetePut($strRoute);
|
||||
case 'DELETE':
|
||||
return requeteDelete($strRoute);
|
||||
default:
|
||||
return ['error' => 'Méthode non reconnue'];
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de requête Get
|
||||
function requeteGet($route) {
|
||||
if (strpos($route, 'users/') !== false) {
|
||||
$array = pg_query_params("SELECT * FROM users WHERE id = $1", array($id));
|
||||
} elseif (strpos($route, 'products/') !== false) {
|
||||
$array = pg_query_params("SELECT * FROM products WHERE id = $1", array($id));
|
||||
} elseif (strpos($route, 'orders/') !== false) {
|
||||
$array = pg_query_params("SELECT * FROM orders WHERE id = $1", array($id));
|
||||
} elseif ($route == 'users') {
|
||||
$array = pg_query_params("SELECT * FROM users");
|
||||
} elseif ($route == 'products') {
|
||||
$array = pg_query_params("SELECT * FROM products");
|
||||
} elseif ($route == 'orders') {
|
||||
$array = pg_query_params("SELECT * FROM orders");
|
||||
} else {
|
||||
return ['error' => "Route non reconnue"];
|
||||
}
|
||||
$res = array();
|
||||
while ($ligne = pg_fetch_array($array)) {
|
||||
$res[] = $ligne;
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
|
||||
// Fonction de requête Post
|
||||
function requetePost($route) {
|
||||
if ($route == 'users') {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("INSERT INTO users (name, age) VALUES ($1, $2)", array($json['name'], $json['age']));
|
||||
return ['message' => 'Utilisateur ajouté'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} elseif ($route == 'products') {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("INSERT INTO products (name, price) VALUES ($1, $2)", array($json['name'], $json['price']));
|
||||
return ['message' => 'Produit ajouté'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} elseif ($route == 'orders') {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("INSERT INTO orders (user_id, product_id) VALUES ($1, $2)", array($json['user_id'], $json['product_id']));
|
||||
return ['message' => 'Commande ajoutée'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} else {
|
||||
return ['error' => "Route non reconnue"];
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de requête Put
|
||||
function requetePut($route) {
|
||||
if (strpos($route, 'users/') !== false) {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("UPDATE users SET name = $1, age = $2 WHERE id = $3", array($json['name'], $json['age'], $id));
|
||||
return ['message' => 'Utilisateur mis à jour'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} elseif (strpos($route, 'products/') !== false) {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("UPDATE products SET name = $1, price = $2 WHERE id = $3", array($json['name'], $json['price'], $id));
|
||||
return ['message' => 'Produit mis à jour'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} elseif (strpos($route, 'orders/') !== false) {
|
||||
try {
|
||||
$json = json_decode(file_get_contents('php://stdin'), true);
|
||||
$array = pg_query_params("UPDATE orders SET user_id = $1, product_id = $2 WHERE id = $3", array($json['user_id'], $json['product_id'], $id));
|
||||
return ['message' => 'Commande mis à jour'];
|
||||
} catch (Exception $e) {
|
||||
return ['error' => 'Erreur de requête'];
|
||||
}
|
||||
} else {
|
||||
return ['error' => "Route non reconnue"];
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de requête Delete
|
||||
function requeteDelete($route) {
|
||||
if (strpos($route, 'users/') !== false) {
|
||||
pg_query_params("DELETE FROM users WHERE id = $1", array($id));
|
||||
return ['message' => 'Utilisateur supprimé'];
|
||||
} elseif (strpos($route, 'products/') !== false) {
|
||||
pg_query_params("DELETE FROM products WHERE id = $1", array($id));
|
||||
return ['message' => 'Produit supprimé'];
|
||||
} elseif (strpos($route, 'orders/') !== false) {
|
||||
pg_query_params("DELETE FROM orders WHERE id = $1", array($id));
|
||||
return ['message' => 'Commande supprimée'];
|
||||
} else {
|
||||
return ['error' => "Route non reconnue"];
|
||||
}
|
||||
@@ -1,228 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de microservice PHP pour le gestion de produits. Ce microservice utilise Docker Compose pour la containerisation, un message queue pour la gestion des communications entre services et une base de données PostgreSQL pour la persistence des données.
|
||||
|
||||
**Docker Compose :**
|
||||
```yaml
|
||||
version: '3'
|
||||
services:
|
||||
api-gateway:
|
||||
build: .
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
- product-service
|
||||
environment:
|
||||
- API_GATEWAY_URL=http://localhost:8080
|
||||
- PRODUCT_SERVICE_URL=http://product-service:8080
|
||||
|
||||
product-service:
|
||||
build: .
|
||||
ports:
|
||||
- "8081:8081"
|
||||
environment:
|
||||
- DATABASE_HOST=database
|
||||
- DATABASE_USER=postgres
|
||||
- DATABASE_PASSWORD=postgres
|
||||
- DATABASE_NAME=products
|
||||
depends_on:
|
||||
- database
|
||||
restart: always
|
||||
|
||||
database:
|
||||
image: postgres
|
||||
environment:
|
||||
- POSTGRES_USER=postgres
|
||||
- POSTGRES_PASSWORD=postgres
|
||||
- POSTGRES_DB=products
|
||||
volumes:
|
||||
- products-data:/var/lib/postgresql/data
|
||||
|
||||
message-queue:
|
||||
image: rabbitmq:latest
|
||||
ports:
|
||||
- 5672:5672
|
||||
- 15672:15672
|
||||
environment:
|
||||
- RABBITMQ_DEFAULT_USER=admin
|
||||
- RABBITMQ_DEFAULT_PASS=password
|
||||
|
||||
volumes:
|
||||
products-data:
|
||||
```
|
||||
**Microservice Product (fichier PHP unique complet) :**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Include des bibliothèques
|
||||
require_once __DIR__ . '/vendor/autoload.php';
|
||||
use Illuminate\Database\Capsule\Manager as Capsule;
|
||||
use Predis\Client;
|
||||
use Ramsey\Uuid\Uuid;
|
||||
|
||||
// Configuration de la base de données
|
||||
$capsule = new Capsule;
|
||||
$capsule->addConnection([
|
||||
'driver' => 'pgsql',
|
||||
'host' => $_ENV['DATABASE_HOST'],
|
||||
'database' => $_ENV['DATABASE_NAME'],
|
||||
'username' => $_ENV['DATABASE_USER'],
|
||||
'password' => $_ENV['DATABASE_PASSWORD'],
|
||||
'charset' => 'utf8',
|
||||
'prefix' => '',
|
||||
]);
|
||||
$capsule->setAsGlobal();
|
||||
$capsule->bootEloquent();
|
||||
|
||||
// Configuration de RabbitMQ
|
||||
$predis = new Client();
|
||||
$predis->connect('localhost');
|
||||
|
||||
// Configuration de l'API
|
||||
$api = new \Slim\App();
|
||||
|
||||
// Middleware d'authentification
|
||||
$api->add(\App\Middlewares\TokenMiddleware::class);
|
||||
|
||||
// Routes API
|
||||
// Lister tous les produits
|
||||
$api->get('/products', function (Request $request, Response $response) {
|
||||
$products = Product::all();
|
||||
return $response->withJson($products);
|
||||
});
|
||||
|
||||
// Créer un nouveau produit
|
||||
$api->post('/products', function (Request $request, Response $response) {
|
||||
$data = $request->getParsedBody();
|
||||
$product = new Product();
|
||||
$product->fill($data);
|
||||
$product->uuid = Uuid::uuid4()->toString();
|
||||
$product->save();
|
||||
return $response->withJson($product);
|
||||
});
|
||||
|
||||
// Lire un produit
|
||||
$api->get('/products/{uuid}', function (Request $request, Response $response, array $args) {
|
||||
$product = Product::find($args['uuid']);
|
||||
if (!$product) {
|
||||
return $response->withStatus(404)->withJson([]);
|
||||
}
|
||||
return $response->withJson($product);
|
||||
});
|
||||
|
||||
// Mettre à jour un produit
|
||||
$api->put('/products/{uuid}', function (Request $request, Response $response, array $args) {
|
||||
$product = Product::find($args['uuid']);
|
||||
if (!$product) {
|
||||
return $response->withStatus(404)->withJson([]);
|
||||
}
|
||||
$data = $request->getParsedBody();
|
||||
$product->fill($data);
|
||||
$product->save();
|
||||
return $response->withJson($product);
|
||||
});
|
||||
|
||||
// Supprimer un produit
|
||||
$api->delete('/products/{uuid}', function (Request $request, Response $response, array $args) {
|
||||
$product = Product::find($args['uuid']);
|
||||
if (!$product) {
|
||||
return $response->withStatus(404)->withJson([]);
|
||||
}
|
||||
$product->delete();
|
||||
return $response->withJson([]);
|
||||
});
|
||||
|
||||
// Enregister le routeur
|
||||
$container = $api->getContainer();
|
||||
$container['db'] = $capsule;
|
||||
|
||||
// Exécuter l'API
|
||||
$app = new \Slim\App($container);
|
||||
$container['router']->addRouteResource('products', 'Product');
|
||||
$container['router']->setRouteParser(new \App\Router\ReverseProxy());
|
||||
$container['request']->setUriResolver(new \Slim\Http\UriResolver());
|
||||
$container['router']->setNotFoundResponse(function (Request $request) {
|
||||
return $this->get('response')
|
||||
->withStatus(404)
|
||||
->withJson(['error' => 'Resource not found'], 404);
|
||||
});
|
||||
$container['router']->group(function (\Psr\Http\Message\ServerRequestInterface $request) {
|
||||
return $this->get('response')
|
||||
->withHeader('Content-Type', 'application/json')
|
||||
->withJson([], 200);
|
||||
}, ['prefix' => '/api/v1'])->register($app);
|
||||
$container['response']->rewriteBody(function () {
|
||||
return $container->shift();
|
||||
});
|
||||
|
||||
// Exécuter l'API dans Docker
|
||||
$app->run();
|
||||
```
|
||||
**Classe Product :**
|
||||
```php
|
||||
<?php
|
||||
|
||||
namespace App\Models;
|
||||
|
||||
use Illuminate\Database\Eloquent\Model;
|
||||
|
||||
class Product extends Model
|
||||
{
|
||||
protected $fillable = ['name', 'description', 'price'];
|
||||
protected $uuid;
|
||||
}
|
||||
```
|
||||
**Fichier Vendor autoloader :**
|
||||
```json
|
||||
{
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
"App\\": "src/"
|
||||
}
|
||||
},
|
||||
"autoload-dev": {
|
||||
"psr-4": {
|
||||
"Tests\\": "tests/"
|
||||
}
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^9.5.3",
|
||||
"fabpot/goutte": "^6.2.0",
|
||||
"slevomat/coder": "^7.0.1"
|
||||
}
|
||||
}
|
||||
```
|
||||
**Fichier docker-compose.yml :**
|
||||
```yaml
|
||||
version: '3'
|
||||
services:
|
||||
api-gateway:
|
||||
build: .
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
- product-service
|
||||
environment:
|
||||
- API_GATEWAY_URL=http://localhost:8080
|
||||
- PRODUCT_SERVICE_URL=http://product-service:8080
|
||||
|
||||
product-service:
|
||||
build: .
|
||||
ports:
|
||||
- "8081:8081"
|
||||
environment:
|
||||
- DATABASE_HOST=database
|
||||
- DATABASE_USER=postgres
|
||||
- DATABASE_PASSWORD=postgres
|
||||
- DATABASE_NAME=products
|
||||
depends_on:
|
||||
- database
|
||||
restart: always
|
||||
|
||||
database:
|
||||
image: postgres
|
||||
environment:
|
||||
- POSTGRES_USER=postgres
|
||||
- POSTGRES_PASSWORD=postgres
|
||||
- POSTGRES_DB=products
|
||||
volumes:
|
||||
-
|
||||
@@ -1,256 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour un microservice d'API Gateway en PHP qui met en œuvre rate limiting et authentification JWT, ainsi que la documentation OpenAPI 3.0.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Composer pour les dépendances
|
||||
require __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
// Configuration du serveur
|
||||
$serv = new class extends Fiji\Serve {
|
||||
protected function config(): array
|
||||
{
|
||||
return [
|
||||
"listeners" => [
|
||||
["listener-0" => "0.0.0.0:8080"]
|
||||
],
|
||||
"router" => [
|
||||
"strategy" => "multiplex"
|
||||
],
|
||||
"services" => [
|
||||
"http" => [
|
||||
"class" => "Fiji\Http\HttpApp",
|
||||
"args" => [
|
||||
new Fiji\Http\Message\RequestHandlerStack()
|
||||
]
|
||||
]
|
||||
]
|
||||
];
|
||||
}
|
||||
};
|
||||
|
||||
// Configuration JWT
|
||||
usefirebase\JWT\JWT;
|
||||
$secretKey = 'votre-clé-secrets-ici';
|
||||
|
||||
// Configuration PDO pour PostgreSQL
|
||||
try {
|
||||
$pdo = new PDO('pgsql:host=localhost;dbname=yourdatabase', 'votre_utilisateur', 'votre_mot_de_passe');
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo 'CONNEXION AU SERVEUR BDD ECHOUÉE : ', $e->getMessage(), "\n";
|
||||
exit;
|
||||
}
|
||||
|
||||
// Dictionnaire des routes API
|
||||
$routes = [
|
||||
'/users' => [
|
||||
['GET', '/', 'UsersController::read'],
|
||||
['POST', '/', 'UsersController::create'],
|
||||
],
|
||||
'/products' => [
|
||||
['GET', '/', 'ProductsController::read'],
|
||||
['POST', '/', 'ProductsController::create'],
|
||||
['GET', '/{id}', 'ProductsController::readById'],
|
||||
['PUT', '/{id}', 'ProductsController::update'],
|
||||
['DELETE', '/{id}', 'ProductsController::delete'],
|
||||
],
|
||||
];
|
||||
|
||||
// Documentation OpenAPI
|
||||
$openApi = [
|
||||
'info' => [
|
||||
'title' => 'API Gateway',
|
||||
'version' => '1.0.0',
|
||||
],
|
||||
'paths' => [
|
||||
'/users' => [
|
||||
['get' => [
|
||||
'operationId' => 'Users_get',
|
||||
'summary' => 'Lire les utilisateurs',
|
||||
'responses' => [
|
||||
'200' => [
|
||||
'description' => 'Utilisateurs récupérés',
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'users' => [
|
||||
'type' => 'array',
|
||||
'items' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'id' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
]],
|
||||
['post' => [
|
||||
'operationId' => 'Users_post',
|
||||
'summary' => 'Créer un utilisateur',
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
'responses' => [
|
||||
'200' => [
|
||||
'description' => 'Utilisateur créé',
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'id' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
]],
|
||||
],
|
||||
'/products' => [
|
||||
['get' => [
|
||||
'operationId' => 'Products_get',
|
||||
'summary' => 'Lire les produits',
|
||||
'responses' => [
|
||||
'200' => [
|
||||
'description' => 'Produits récupérés',
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'products' => [
|
||||
'type' => 'array',
|
||||
'items' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'id' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
]],
|
||||
['post' => [
|
||||
'operationId' => 'Products_post',
|
||||
'summary' => 'Créer un produit',
|
||||
'requestBody' => [
|
||||
'required' => true,
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
'responses' => [
|
||||
'200' => [
|
||||
'description' => 'Produit créé',
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'id' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
]],
|
||||
['get' => [
|
||||
'operationId' => 'Products_getById',
|
||||
'summary' => 'Lire un produit par son id',
|
||||
'parameters' => [
|
||||
[
|
||||
'in' => 'path',
|
||||
'name' => 'id',
|
||||
'description' => 'Identifiant du produit',
|
||||
'required' => true,
|
||||
'schema' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
],
|
||||
],
|
||||
'responses' => [
|
||||
'200' => [
|
||||
'description' => 'Produit récupéré',
|
||||
'content' => [
|
||||
'application/json' => [
|
||||
'schema' => [
|
||||
'type' => 'object',
|
||||
'properties' => [
|
||||
'id' => [
|
||||
'type' => 'integer',
|
||||
],
|
||||
'name' => [
|
||||
'type' => 'string',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
]],
|
||||
['put' => [
|
||||
'operationId' => 'Products_put',
|
||||
'summary' => 'Mettre à jour un produit',
|
||||
'parameters' => [
|
||||
[
|
||||
'in' => 'path',
|
||||
'name' => 'id',
|
||||
'description' => 'Identifiant du produit',
|
||||
'required' => true
|
||||
@@ -1,211 +0,0 @@
|
||||
<?php
|
||||
**Architecture Microservices avec API Gateway, User Service, Product Service, Order Service, Message Queue**
|
||||
=====================================================
|
||||
|
||||
Voici un exemple d'architecture microservices avec API Gateway, User Service, Product Service, Order Service, Message Queue et un microservice auth. Nous utiliserons PHP 8.5, PostgreSQL, Docker et Docker Compose pour les déployer.
|
||||
|
||||
### microservices
|
||||
|
||||
**apiGateway.php** (API Gateway)
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données
|
||||
$dsn = 'pgsql:host=localhost;dbname=shop';
|
||||
$username = 'mon_nom_utilisateur';
|
||||
$password = 'mon_mot_de_passe';
|
||||
|
||||
// Création de l'hôte
|
||||
$hote = new PDO($dsn, $username, $password);
|
||||
|
||||
// API Gateway
|
||||
class APIGateway
|
||||
{
|
||||
public static function getItems()
|
||||
{
|
||||
// Récupération des données du service Product
|
||||
$items = self::callProductService('GET');
|
||||
return $items;
|
||||
}
|
||||
|
||||
public static function addItem($item)
|
||||
{
|
||||
// Envoi de la requête à Order Service
|
||||
self::callOrderService('POST', $item);
|
||||
}
|
||||
|
||||
public static function getItem($id)
|
||||
{
|
||||
// Envoi de la requête à Product Service
|
||||
$item = self::callProductService('GET', ['id' => $id]);
|
||||
return $item;
|
||||
}
|
||||
|
||||
public static function updateItem($item)
|
||||
{
|
||||
// Envoi de la requête à Product Service
|
||||
self::callProductService('PUT', $item);
|
||||
}
|
||||
|
||||
public static function deleteItem($id)
|
||||
{
|
||||
// Envoi de la requête à Order Service
|
||||
self::callOrderService('DELETE', ['id' => $id]);
|
||||
}
|
||||
|
||||
public static function callProductService($method, $data = null)
|
||||
{
|
||||
// Envoi de la requête au service Product
|
||||
$ch = curl_init('http://product-service:8080/api/items');
|
||||
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
||||
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
|
||||
if ($data) {
|
||||
curl_setopt($ch, CURLOPT_POST, true);
|
||||
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
|
||||
}
|
||||
$response = curl_exec($ch);
|
||||
curl_close($ch);
|
||||
return json_decode($response, true);
|
||||
}
|
||||
|
||||
public static function callOrderService($method, $data = null)
|
||||
{
|
||||
// Envoi de la requête au service Order
|
||||
$ch = curl_init('http://order-service:8080/api/orders');
|
||||
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
||||
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
|
||||
if ($data) {
|
||||
curl_setopt($ch, CURLOPT_POST, true);
|
||||
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
|
||||
}
|
||||
$response = curl_exec($ch);
|
||||
curl_close($ch);
|
||||
return json_decode($response, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Test
|
||||
// Définition d'un item
|
||||
$item = [
|
||||
'name' => 'Produit Test',
|
||||
'prix' => 10,
|
||||
'quantite' => 20
|
||||
];
|
||||
|
||||
// Appel de la méthode addItem
|
||||
$r = APIGateway::addItem($item);
|
||||
echo json_encode($r);
|
||||
|
||||
```
|
||||
### Product Service
|
||||
|
||||
**userService.php (Product Service)**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données
|
||||
$dsn = 'pgsql:host=localhost;dbname=shop';
|
||||
$username = 'mon_nom_utilisateur';
|
||||
$password = 'mon_mot_de_passe';
|
||||
|
||||
// Création de l'hôte
|
||||
$hote = new PDO($dsn, $username, $password);
|
||||
|
||||
// Service Product
|
||||
class ProductService
|
||||
{
|
||||
public static function getItems($args = [])
|
||||
{
|
||||
// Récupération des données de la base de données
|
||||
$sql = "SELECT id, name, prix, quantite FROM items";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
public static function addItem($item)
|
||||
{
|
||||
// insertion des données dans la base de données
|
||||
$sql = "INSERT INTO items (name, prix, quantite) VALUES (:name, :prix, :quantite)";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute($item);
|
||||
}
|
||||
|
||||
public static function getItem($id)
|
||||
{
|
||||
// Récupération des données de la base de données
|
||||
$sql = "SELECT id, name, prix, quantite FROM items WHERE id = :id";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
public static function updateItem($item)
|
||||
{
|
||||
// Mise à jour des données dans la base de données
|
||||
$sql = "UPDATE items SET name = :name, prix = :prix, quantite = :quantite WHERE id = :id";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute($item);
|
||||
}
|
||||
|
||||
public static function deleteItem($id)
|
||||
{
|
||||
// Suppression des données de la base de données
|
||||
$sql = "DELETE FROM items WHERE id = :id";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute(['id' => $id]);
|
||||
}
|
||||
}
|
||||
|
||||
// Test
|
||||
// Appel de la méthode getItems
|
||||
$r = ProductService::getItems();
|
||||
echo json_encode($r);
|
||||
|
||||
```
|
||||
|
||||
### User Service
|
||||
|
||||
**userService.php (User Service)**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données
|
||||
$dsn = 'pgsql:host=localhost;dbname=shop';
|
||||
$username = 'mon_nom_utilisateur';
|
||||
$password = 'mon_mot_de_passe';
|
||||
|
||||
// Création de l'hôte
|
||||
$hote = new PDO($dsn, $username, $password);
|
||||
|
||||
// Service User
|
||||
class UserService
|
||||
{
|
||||
public static function getUser($email)
|
||||
{
|
||||
// Récupération des données de la base de données
|
||||
$sql = "SELECT * FROM users WHERE email = :email";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute(['email' => $email]);
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
public static function addUser($user)
|
||||
{
|
||||
// Insertion des données dans la base de données
|
||||
$sql = "INSERT INTO users (name, email, password) VALUES (:name, :email, :password)";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute($user);
|
||||
}
|
||||
|
||||
public static function updateUser($user)
|
||||
{
|
||||
// Mise à jour des données dans la base de données
|
||||
$sql = "UPDATE users SET name = :name, email = :email, password = :password WHERE id = :id";
|
||||
$stmt = $hote->prepare($sql);
|
||||
$stmt->execute($user);
|
||||
}
|
||||
|
||||
public static function deleteUser($id)
|
||||
{
|
||||
// Suppression des données de la base de
|
||||
@@ -1,226 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour un microservice User Service en PHP, utilisant la technologie REST, microservices avec docker-compose, PostgreSQL et un fichier PHP unique complets.
|
||||
|
||||
**Fichier docker-compose.yml**
|
||||
```yaml
|
||||
version: '3'
|
||||
services:
|
||||
api-gateway:
|
||||
build: .
|
||||
ports:
|
||||
- "80:80"
|
||||
gateway:
|
||||
build: .
|
||||
depends_on:
|
||||
- api-gateway
|
||||
environment:
|
||||
- API_GATEWAY=api-gateway
|
||||
postgres:
|
||||
image: postgres
|
||||
environment:
|
||||
- POSTGRES_DB=users
|
||||
- POSTGRES_USER=postgres
|
||||
- POSTGRES_PASSWORD=postgres
|
||||
volumes:
|
||||
- db-data:/var/lib/postgresql/data
|
||||
user-service:
|
||||
build: .
|
||||
depends_on:
|
||||
- gateway
|
||||
environment:
|
||||
- API_GATEWAY=gateway
|
||||
- MESSAGE_QUEUE=amqp://guest:guest@rabbitmq:5672//
|
||||
product-service:
|
||||
build: .
|
||||
depends_on:
|
||||
- gateway
|
||||
environment:
|
||||
- API_GATEWAY=gateway
|
||||
order-service:
|
||||
build: .
|
||||
depends_on:
|
||||
- gateway
|
||||
environment:
|
||||
- API_GATEWAY=gateway
|
||||
rabbitmq:
|
||||
image: rabbitmq
|
||||
|
||||
volumes:
|
||||
db-data:
|
||||
```
|
||||
|
||||
**Fichier microservice/ UserService/Dockerfile**
|
||||
```dockerfile
|
||||
FROM php:8.5-fpm-alpine
|
||||
RUN docker-php-ext-install pgsql
|
||||
WORKDIR /var/www/html
|
||||
COPY ./src/UserService.php /var/www/html/
|
||||
RUN chown -R www-data:www-data /var/www/html/
|
||||
CMD ["php", "-S", "0.0.0.0:80"]
|
||||
```
|
||||
|
||||
**Fichier src/UserService.php complet**
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Définition des constantes
|
||||
defined('BASEPATH') or exit('No direct script access allowed');
|
||||
|
||||
// Constantes de connexion à la base de données
|
||||
const DB_HOST = 'postgres';
|
||||
const DB_NAME = 'users';
|
||||
const DB_USER = 'postgres';
|
||||
const DB_PASSWORD = 'postgres';
|
||||
|
||||
// Constantes de configuration
|
||||
const API_GATEWAY = 'http://gateway:80';
|
||||
const MESSAGE_QUEUE = 'amqp://guest:guest@rabbitmq:5672//';
|
||||
|
||||
// Connexion à la base de données
|
||||
try {
|
||||
$pdo = new PDO('pgsql:host=' . DB_HOST . ';dbname=' . DB_NAME, DB_USER, DB_PASSWORD);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo 'Erreur de connexion à la base de données : ' . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Classes Utiles
|
||||
class UserService
|
||||
{
|
||||
// Méthode pour générer une UUID
|
||||
public static function generateUUID()
|
||||
{
|
||||
$key = bin2hex(random_bytes(16));
|
||||
return substr($key, 0, 8) . '-' . substr($key, 8, 4) . '-' . substr($key, 12, 4) . '-' . substr($key, 16, 4) . '-' . substr($key, 20, 12);
|
||||
}
|
||||
|
||||
// Méthode pour générer un jeton d'accès
|
||||
public static function generateToken($username)
|
||||
{
|
||||
return hash_hmac('sha256', $username, 'secret_key', true);
|
||||
}
|
||||
|
||||
// Méthode pour supprimer la dernière ligne
|
||||
public static function truncateTable($table)
|
||||
{
|
||||
global $pdo;
|
||||
$stmt = $pdo->prepare('truncate table ' . $table . ' cascade');
|
||||
$stmt->execute();
|
||||
}
|
||||
|
||||
// Méthode pour vider la table Users en purgeant l'historique
|
||||
public static function purge()
|
||||
{
|
||||
UserService::truncateTable('users');
|
||||
UserService::truncateTable('user_history');
|
||||
UserService::truncateTable('user_token');
|
||||
}
|
||||
}
|
||||
|
||||
// Classe de Gestion des Utilisateurs
|
||||
class User
|
||||
{
|
||||
private $id;
|
||||
private $username;
|
||||
private $password;
|
||||
private $email;
|
||||
|
||||
public function __construct($id = null, $username = null, $password = null, $email = null)
|
||||
{
|
||||
$this->id = $id;
|
||||
$this->username = $username;
|
||||
$this->password = $password;
|
||||
$this->email = $email;
|
||||
}
|
||||
|
||||
public function getId()
|
||||
{
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function getUsername()
|
||||
{
|
||||
return $this->username;
|
||||
}
|
||||
|
||||
public function getPassword()
|
||||
{
|
||||
return $this->password;
|
||||
}
|
||||
|
||||
public function getEmail()
|
||||
{
|
||||
return $this->email;
|
||||
}
|
||||
|
||||
public function setId($id)
|
||||
{
|
||||
$this->id = $id;
|
||||
}
|
||||
|
||||
public function setUsername($username)
|
||||
{
|
||||
$this->username = $username;
|
||||
}
|
||||
|
||||
public function setPassword($password)
|
||||
{
|
||||
$this->password = $password;
|
||||
}
|
||||
|
||||
public function setEmail($email)
|
||||
{
|
||||
$this->email = $email;
|
||||
}
|
||||
}
|
||||
|
||||
class Handler
|
||||
{
|
||||
// Fonction pour gérer la création d'un utilisateur
|
||||
public function createUser($username, $password, $email)
|
||||
{
|
||||
$user = new User(UserService::generateUUID(), $username, hash('sha256', $password), $email);
|
||||
$stmt = $pdo->prepare('insert into users (id, username, password, email) values (:id, :username, :password, :email)');
|
||||
$stmt->bindParam(':id', $user->getId());
|
||||
$stmt->bindParam(':username', $user->getUsername());
|
||||
$stmt->bindParam(':password', $user->getPassword());
|
||||
$stmt->bindParam(':email', $user->getEmail());
|
||||
$stmt->execute();
|
||||
return $user->getId();
|
||||
}
|
||||
|
||||
// Fonction pour gérer la lecture des utilisateurs
|
||||
public function getUsers()
|
||||
{
|
||||
$users = array();
|
||||
$stmt = $pdo->prepare('select * from users');
|
||||
$stmt->execute();
|
||||
$result = $stmt->fetchAll();
|
||||
foreach ($result as $row) {
|
||||
$user = new User($row['id'], $row['username'], $row['password'], $row['email']);
|
||||
$users[] = $user;
|
||||
}
|
||||
return $users;
|
||||
}
|
||||
|
||||
// Fonction pour gérer la lecture d'un utilisateur
|
||||
public function getUser($id)
|
||||
{
|
||||
$user = null;
|
||||
$stmt = $pdo->prepare('select * from users where id = :id');
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$row = $stmt->fetch();
|
||||
if ($row) {
|
||||
$user = new User($row['id'], $row['username'], $row['password'], $row['email']);
|
||||
}
|
||||
return $user;
|
||||
}
|
||||
|
||||
// Fonction pour gérer la mise à jour d'un utilisateur
|
||||
public function updateUser($id, $username, $password, $email)
|
||||
{
|
||||
$user = $this->getUser($id);
|
||||
if ($user) {
|
||||
$user->set
|
||||
@@ -1,218 +0,0 @@
|
||||
<?php
|
||||
**Microservice: User Service**
|
||||
|
||||
Cette API sera déployée avec les autres microservices via Docker Compose. Elle se connecte à une base de données PostgreSQL pour stocker les données d'utilisateurs.
|
||||
|
||||
**Docker Compose**
|
||||
|
||||
Créez un fichier `docker-compose.yml` pour définir les services :
|
||||
|
||||
```yaml
|
||||
version: '3'
|
||||
|
||||
services:
|
||||
api-gateway:
|
||||
build: ./api-gateway/
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
- user-service
|
||||
|
||||
user-service:
|
||||
build: ./user-service/
|
||||
depends_on:
|
||||
- database
|
||||
|
||||
database:
|
||||
image: postgres
|
||||
environment:
|
||||
POSTGRES_DB: user-db
|
||||
POSTGRES_USER: user
|
||||
POSTGRES_PASSWORD: password
|
||||
volumes:
|
||||
- user-db-data:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "5432:5432"
|
||||
|
||||
message-queue:
|
||||
image: rabbitmq:3-management
|
||||
ports:
|
||||
- "15672:15672"
|
||||
- "5672:5672"
|
||||
|
||||
volumes:
|
||||
user-db-data:
|
||||
```
|
||||
|
||||
**User Service (PHP)**
|
||||
|
||||
Créez un fichier `index.php` pour définir la structure de votre microservice :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration base de données
|
||||
$config = [
|
||||
'dsn' => 'pgsql:host=localhost;dbname=user-db',
|
||||
'username' => 'user',
|
||||
'password' => 'password',
|
||||
];
|
||||
|
||||
// Configuration des routes
|
||||
$routes = [
|
||||
'/users' => [
|
||||
'GET' => 'getListUsers',
|
||||
'POST' => 'createUser',
|
||||
],
|
||||
'/users/{id}' => [
|
||||
'GET' => 'getUsers',
|
||||
'PUT' => 'updateUser',
|
||||
'DELETE' => 'deleteUser',
|
||||
],
|
||||
];
|
||||
|
||||
// Initialisation
|
||||
$app = new stdClass();
|
||||
|
||||
// Fonctions de base de données
|
||||
function executeQuery($query) {
|
||||
global $config;
|
||||
try {
|
||||
$pdo = new PDO($config['dsn'], $config['username'], $config['password']);
|
||||
$result = $pdo->query($query);
|
||||
return $result->fetchAll();
|
||||
} catch (PDOException $e) {
|
||||
echo 'Connection failed: ' . $e->getMessage();
|
||||
exit();
|
||||
}
|
||||
}
|
||||
|
||||
function createUser($data) {
|
||||
$query = "INSERT INTO users (name, email) VALUES (:name, :email)";
|
||||
$stmt = executeQuery($query);
|
||||
return $stmt;
|
||||
}
|
||||
|
||||
function getListUsers() {
|
||||
$query = "SELECT * FROM users";
|
||||
return executeQuery($query);
|
||||
}
|
||||
|
||||
function getUser($id) {
|
||||
$query = "SELECT * FROM users WHERE id = :id";
|
||||
$stmt = executeQuery($query);
|
||||
return $stmt;
|
||||
}
|
||||
|
||||
function updateUser($id, $data) {
|
||||
$query = "UPDATE users SET name = :name, email = :email WHERE id = :id";
|
||||
$stmt = executeQuery($query);
|
||||
return $stmt;
|
||||
}
|
||||
|
||||
function deleteUser($id) {
|
||||
$query = "DELETE FROM users WHERE id = :id";
|
||||
$stmt = executeQuery($query);
|
||||
return $stmt;
|
||||
}
|
||||
|
||||
// Fonctions de route
|
||||
function getListUsersRoute() {
|
||||
$users = getListUsers();
|
||||
return json_encode($users);
|
||||
}
|
||||
|
||||
function createUserRoute($data) {
|
||||
$res = createUser($data);
|
||||
return json_encode($res);
|
||||
}
|
||||
|
||||
function getUserRoute($id) {
|
||||
$user = getUser($id);
|
||||
return json_encode($user);
|
||||
}
|
||||
|
||||
function updateUserRoute($id, $data) {
|
||||
$res = updateUser($id, $data);
|
||||
return json_encode($res);
|
||||
}
|
||||
|
||||
function deleteUserRoute($id) {
|
||||
$res = deleteUser($id);
|
||||
return json_encode($res);
|
||||
}
|
||||
|
||||
// Traitement des routes
|
||||
function route($method, $route) {
|
||||
global $routes, $app;
|
||||
if (isset($routes[$route][$method])) {
|
||||
return $routes[$route][$method]();
|
||||
} else {
|
||||
http_response_code(405);
|
||||
return json_encode(['msg' => 'Méthode non autorisée']);
|
||||
}
|
||||
}
|
||||
|
||||
function initRoutes() {
|
||||
global $app, $routes;
|
||||
// Traitement des routes pour les méthodes GET, POST, PUT et DELETE
|
||||
}
|
||||
|
||||
initRoutes();
|
||||
|
||||
// Traitement du requete
|
||||
$method = $_SERVER['REQUEST_METHOD'];
|
||||
$route = explode('/', $_SERVER['REQUEST_URI'])[1];
|
||||
$req = route($method, $route);
|
||||
echo $req;
|
||||
```
|
||||
|
||||
**Exemple de utilisation**
|
||||
|
||||
Pour créer un utilisateur :
|
||||
|
||||
```bash
|
||||
curl -X POST \
|
||||
http://localhost:8080/users \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"name": "John", "email": "john@example.com"}'
|
||||
```
|
||||
|
||||
Pour obtenir la liste des utilisateurs :
|
||||
|
||||
```bash
|
||||
curl -X GET http://localhost:8080/users
|
||||
```
|
||||
|
||||
Pour obtenir les informations d'un utilisateur spécifique :
|
||||
|
||||
```bash
|
||||
curl -X GET http://localhost:8080/users/1
|
||||
```
|
||||
|
||||
Pour mettre à jour les informations d'un utilisateur :
|
||||
|
||||
```bash
|
||||
curl -X PUT \
|
||||
http://localhost:8080/users/1 \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"name": "Jane", "email": "jane@example.com"}'
|
||||
```
|
||||
|
||||
Pour supprimer un utilisateur :
|
||||
|
||||
```bash
|
||||
curl -X DELETE http://localhost:8080/users/1
|
||||
```
|
||||
|
||||
**Déploiement**
|
||||
|
||||
Définissez le port 8080 pour l'API Gateway et assurez-vous que la base de données PostgreSQL est accessible à l'adresse `localhost`.
|
||||
|
||||
Exécutez Docker Compose pour démarrer les microservices :
|
||||
|
||||
```bash
|
||||
docker-compose up --build
|
||||
```
|
||||
|
||||
Vous devriez maintenant voir les microservices s'exécuter et être accessibles via `http://localhost:8080`.
|
||||
@@ -1,177 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de microservice de commande qui utilise les technologies que vous avez mentionnées :
|
||||
|
||||
**microservice.php** :
|
||||
```php
|
||||
<?php
|
||||
|
||||
use PDO;
|
||||
use PDOException;
|
||||
|
||||
class Commande {
|
||||
private $id;
|
||||
private $id_client;
|
||||
private $id_produit;
|
||||
private $quantite;
|
||||
private $date commande;
|
||||
|
||||
public function __construct($id = null, $id_client = null, $id_produit = null, $quantite = null, $date_commande = null) {
|
||||
$this->id = $id;
|
||||
$this->id_client = $id_client;
|
||||
$this->id_produit = $id_produit;
|
||||
$this->quantite = $quantite;
|
||||
$this->date_commande = $date_commande;
|
||||
}
|
||||
|
||||
public function getId() {
|
||||
return $this->id;
|
||||
}
|
||||
|
||||
public function setId($id) {
|
||||
$this->id = $id;
|
||||
}
|
||||
|
||||
public function getIdClient() {
|
||||
return $this->id_client;
|
||||
}
|
||||
|
||||
public function setIdClient($id_client) {
|
||||
$this->id_client = $id_client;
|
||||
}
|
||||
|
||||
public function getIdProduit() {
|
||||
return $this->id_produit;
|
||||
}
|
||||
|
||||
public function setIdProduit($id_produit) {
|
||||
$this->id_produit = $id_produit;
|
||||
}
|
||||
|
||||
public function getQuantite() {
|
||||
return $this->quantite;
|
||||
}
|
||||
|
||||
public function setQuantite($quantite) {
|
||||
$this->quantite = $quantite;
|
||||
}
|
||||
|
||||
public function getDateCommande() {
|
||||
return $this->date_commande;
|
||||
}
|
||||
|
||||
public function setDateCommande($date_commande) {
|
||||
$this->date_commande = $date_commande;
|
||||
}
|
||||
|
||||
public static function tousLesCommandes() {
|
||||
$conn = new PDO('pgsql:host=localhost;dbname=commerc', 'username', 'motdepasse');
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
$requete = "SELECT * FROM commande";
|
||||
|
||||
$stmt = $conn->prepare($requete);
|
||||
$stmt->execute();
|
||||
|
||||
$data = $stmt->fetchAll();
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
public static function commanderUnProduit($id_commande, $id_client, $id_produit, $quantite) {
|
||||
$conn = new PDO('pgsql:host=localhost;dbname=commerc', 'username', 'motdepasse');
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
$requete = "INSERT INTO commande (id_commande, id_client, id_produit, quantite) VALUES (:id_commande, :id_client, :id_produit, :quantite)";
|
||||
|
||||
$stmt = $conn->prepare($requete);
|
||||
$stmt->bindParam(':id_commande', $id_commande);
|
||||
$stmt->bindParam(':id_client', $id_client);
|
||||
$stmt->bindParam(':id_produit', $id_produit);
|
||||
$stmt->bindParam(':quantite', $quantite);
|
||||
|
||||
if ($stmt->execute()) {
|
||||
echo "Commande créée avec succès.";
|
||||
} else {
|
||||
echo "Erreur lors de la création de la commande.";
|
||||
}
|
||||
}
|
||||
|
||||
public static function commanderUnProduitUpdate($id_commande, $id_client, $id_produit, $quantite) {
|
||||
$conn = new PDO('pgsql:host=localhost;dbname=commerc', 'username', 'motdepasse');
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
$requete = "UPDATE commande SET id_client = :id_client, id_produit = :id_produit, quantite = :quantite WHERE id_commande = :id_commande";
|
||||
|
||||
$stmt = $conn->prepare($requete);
|
||||
$stmt->bindParam(':id_commande', $id_commande);
|
||||
$stmt->bindParam(':id_client', $id_client);
|
||||
$stmt->bindParam(':id_produit', $id_produit);
|
||||
$stmt->bindParam(':quantite', $quantite);
|
||||
|
||||
if ($stmt->execute()) {
|
||||
echo "Commande mise à jour avec succès.";
|
||||
} else {
|
||||
echo "Erreur lors de la mise à jour de la commande.";
|
||||
}
|
||||
}
|
||||
|
||||
public static function supprimerUneCommande($id_commande) {
|
||||
$conn = new PDO('pgsql:host=localhost;dbname=commerc', 'username', 'motdepasse');
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
|
||||
$requete = "DELETE FROM commande WHERE id_commande = :id_commande";
|
||||
|
||||
$stmt = $conn->prepare($requete);
|
||||
$stmt->bindParam(':id_commande', $id_commande);
|
||||
|
||||
if ($stmt->execute()) {
|
||||
echo "Commande supprimée avec succès.";
|
||||
} else {
|
||||
echo "Erreur lors de la suppression de la commande.";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Microservice {
|
||||
private $server;
|
||||
private $port;
|
||||
|
||||
public function __construct($server = "0.0.0.0", $port = 80) {
|
||||
$this->server = $server;
|
||||
$this->port = $port;
|
||||
}
|
||||
|
||||
public function run() {
|
||||
$options = array(
|
||||
'debug' => true
|
||||
);
|
||||
|
||||
$app = new \Slim\App($options);
|
||||
|
||||
$app->get('/tousLesCommandes', function (Request $request, Response $response) {
|
||||
$donnees = Commande::tousLesCommandes();
|
||||
return $response->withJson($donnees);
|
||||
});
|
||||
|
||||
$app->post('/commanderUnProduit', function (Request $request, Response $response) {
|
||||
$id_commande = $request->getParsedBody()["id_commande"];
|
||||
$id_client = $request->getParsedBody()["id_client"];
|
||||
$id_produit = $request->getParsedBody()["id_produit"];
|
||||
$quantite = $request->getParsedBody()["quantite"];
|
||||
Commande::commanderUnProduit($id_commande, $id_client, $id_produit, $quantite);
|
||||
return $response->write("Commande créée avec succès.");
|
||||
});
|
||||
|
||||
$app->put('/commanderUnProduitUpdate', function (Request $request, Response $response) {
|
||||
$id_commande = $request->getParsedBody()["id_commande"];
|
||||
$id_client = $request->getParsedBody()["id_client"];
|
||||
$id_produit = $request->getParsedBody()["id_produit"];
|
||||
$quantite = $request->getParsedBody()["quantite"];
|
||||
Commande::commanderUnProduitUpdate($id_commande, $id_client, $id_produit, $quantite);
|
||||
return $response->write("Commande mise à jour avec succès.");
|
||||
});
|
||||
|
||||
$app->delete('/supprimerUneCommande', function (Request $request, Response $response) {
|
||||
$id_commande = $request->getParsedBody()["id_commande"];
|
||||
Commande::supprimerUneCommande($id_commande);
|
||||
return $response->write
|
||||
@@ -1,207 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour un microservice API REST complet en PHP pour le User Service. Ce microservice utilisera PostgreSQL comme base de données et effectuera des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer) sur les utilisateurs.
|
||||
|
||||
**Attention** : ce code est un exemple complet pour un seul microservice User Service. La gestion des autres microservices (API Gateway, Product Service, Order Service, Message Queue) nécessiterait des codes supplémentaires.
|
||||
|
||||
**fichier `docker-compose.yml`** :
|
||||
```yml
|
||||
version: '3'
|
||||
|
||||
services:
|
||||
postgresql:
|
||||
image: postgres
|
||||
restart: always
|
||||
environment:
|
||||
- POSTGRES_USER=myuser
|
||||
- POSTGRES_PASSWORD=mypassword
|
||||
- POSTGRES_DB=mydatabase
|
||||
ports:
|
||||
- "5432:5432"
|
||||
volumes:
|
||||
- ./data/postgresql:/var/lib/postgresql/data
|
||||
|
||||
users-service:
|
||||
build: .
|
||||
restart: always
|
||||
ports:
|
||||
- "8000:8000"
|
||||
depends_on:
|
||||
- postgresql
|
||||
```
|
||||
|
||||
**fichier PHP unique `UsersService.php`** :
|
||||
```php
|
||||
<?php
|
||||
|
||||
require 'vendor/autoload.php';
|
||||
|
||||
use App\Model\UserModel;
|
||||
use App\Service\UserService;
|
||||
use App\Repository\UserRepository;
|
||||
use App\Repository\ConnectionRepository;
|
||||
use GuzzleHttp\Exception\RequestException;
|
||||
use Psr\Http\Message\ResponseInterface;
|
||||
use Psy\Utils\Exception;
|
||||
use Aura\SqlEntityManager\ConnectionFactory;
|
||||
use Psr\Http\Message\StreamInterface;
|
||||
use JsonException;
|
||||
|
||||
class UsersService {
|
||||
private $userRepository;
|
||||
private $connection;
|
||||
|
||||
public function __construct() {
|
||||
$this->connection = (new ConnectionRepository())->getPdoPgsql();
|
||||
$this->userRepository = new UserRepository($this->connection);
|
||||
}
|
||||
|
||||
public function getAllUsers() {
|
||||
$users = $this->userRepository->getAll();
|
||||
return json_encode($users);
|
||||
}
|
||||
|
||||
public function getUser($id) {
|
||||
try {
|
||||
$user = $this->userRepository->getById($id);
|
||||
return json_encode($user);
|
||||
} catch (Exception $e) {
|
||||
throw new Exception($e->getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public function saveUser(Request $request) {
|
||||
try {
|
||||
$body = $request->getBody();
|
||||
$userData = json_decode($body->getContents(), true);
|
||||
$newUser = new UserModel();
|
||||
$newUser->setName($userData['name']);
|
||||
$newUser->setEmail($userData['email']);
|
||||
$this->userRepository->save($newUser);
|
||||
return new Response(201, [], json_encode(['message' => 'L\'utilisateur a été créé avec succès.']));
|
||||
} catch (Exception $e) {
|
||||
return new Response(500, [], json_encode(['message' => 'Une erreur est survenue lors de la création de l\'utilisateur.']));
|
||||
}
|
||||
}
|
||||
|
||||
public function deleteUser($id) {
|
||||
try {
|
||||
$this->userRepository->deleteById($id);
|
||||
return json_encode(['message' => 'L\'utilisateur a été supprimé avec succès.']);
|
||||
} catch (Exception $e) {
|
||||
return new Response(500, [], json_encode(['message' => 'Une erreur est survenue lors de la suppression de l\'utilisateur.']));
|
||||
}
|
||||
}
|
||||
|
||||
public function updateUser($id, Request $request) {
|
||||
try {
|
||||
$body = $request->getBody();
|
||||
$userData = json_decode($body->getContents(), true);
|
||||
$user = $this->userRepository->getById($id);
|
||||
if (!empty($user)) {
|
||||
$user->setName($userData['name']);
|
||||
$user->setEmail($userData['email']);
|
||||
$this->userRepository->update($user);
|
||||
return json_encode(['message' => 'L\'utilisateur a été mis à jour avec succès.']);
|
||||
} else {
|
||||
return new Response(404, [], json_encode(['message' => 'L\'utilisateur n\'existe pas.']));
|
||||
}
|
||||
} catch (Exception $e) {
|
||||
return new Response(500, [], json_encode(['message' => 'Une erreur est survenue lors de la mise à jour de l\'utilisateur.']));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Utilisation de PSR-7
|
||||
use GuzzleHttp\Psr7\Response;
|
||||
|
||||
// Utilisation d'Aura.SqlEntityManager
|
||||
use Aura\SqlEntityManager\MapperAware;
|
||||
|
||||
// Utilisation de Doctrine
|
||||
use Doctrine\ORM\EntityManagerInterface;
|
||||
use App\Entity\User;
|
||||
|
||||
// Utilisation de JsonSerializable
|
||||
use JsonSerializable;
|
||||
|
||||
// Utilisation de Exception
|
||||
use Exception;
|
||||
|
||||
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
|
||||
$dotenv->load();
|
||||
|
||||
// Connexion à PostgreSQL
|
||||
$dsn = 'pgsql:host=localhost;dbname=mydatabase';
|
||||
$username = 'myuser';
|
||||
$password = 'mypassword';
|
||||
|
||||
try {
|
||||
$pdo = new PDO($dsn, $username, $password);
|
||||
print("Connexion établie.");
|
||||
} catch (PDOException $e) {
|
||||
print('Erreur : ' . $e->getMessage());
|
||||
}
|
||||
```
|
||||
|
||||
**Traitement des requêtes**
|
||||
```php
|
||||
// Traitement de GET
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'GET') {
|
||||
switch ($_GET['action']) {
|
||||
case 'all':
|
||||
$usersService = (new UsersService())->getAllUsers();
|
||||
break;
|
||||
case 'userId':
|
||||
$usersService = (new UsersService())->getUser($_GET['id']);
|
||||
break;
|
||||
default:
|
||||
throw new Exception('La méthode GET n\'est pas autorisée pour cette route.');
|
||||
}
|
||||
header('Content-Type: application/json');
|
||||
echo $usersService;
|
||||
}
|
||||
|
||||
// Traitement de POST
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
|
||||
$usersService = (new UsersService())->saveUser($_POST);
|
||||
header('Content-Type: application/json');
|
||||
echo $usersService;
|
||||
}
|
||||
|
||||
// Traitement de PUT
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'PUT') {
|
||||
parse_str(file_get_contents('php://input'), $vars);
|
||||
$usersService = (new UsersService())->updateUser($vars['userId'], $vars);
|
||||
header('Content-Type: application/json');
|
||||
echo $usersService;
|
||||
}
|
||||
|
||||
// Traitement de DELETE
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'DELETE') {
|
||||
$usersService = (new UsersService())->deleteUser($_GET['id']);
|
||||
header('Content-Type: application/json');
|
||||
echo $usersService;
|
||||
}
|
||||
```
|
||||
|
||||
**Cible du navigateur**
|
||||
```php
|
||||
if (isset($_SERVER['SERVER_NAME'])) {
|
||||
// Pour le développement local
|
||||
$serverUrl = 'http://' . $_SERVER['SERVER_NAME'];
|
||||
$url = $serverUrl . '/users-service' . $_SERVER['REQUEST_URI'];
|
||||
|
||||
// Pour le déploiement en prod
|
||||
$serverUrl = $_SERVER['SERVER_NAME'];
|
||||
$port = $_SERVER['SERVER_PORT'];
|
||||
$url = 'http://' . $serverUrl . ':' . $port;
|
||||
|
||||
echo $url;
|
||||
}
|
||||
```
|
||||
|
||||
Ce code permet de :
|
||||
|
||||
* Créer une billettière (User) ;
|
||||
* Lire toutes les billeteries (Users) ;
|
||||
* Lire
|
||||
@@ -1,6 +0,0 @@
|
||||
<?php
|
||||
Bien sûr ! En tant que WEVCODE, je vais générer pour vous une architecture microservices complète avec Docker Compose et implémenter un microservice PHP unique et fonctionnel pour la gestion des produits, avec connexion PostgreSQL et API REST CRUD.
|
||||
|
||||
---
|
||||
|
||||
### **Architecture Microservices WE
|
||||
@@ -1,4 +0,0 @@
|
||||
<?php
|
||||
Superbe initiative ! En tant que WEVCODE, je suis ravi de générer du code souverain WEVAL, complet, fonctionnel et production-ready pour votre architecture microservices.
|
||||
|
||||
**Remarque importante concernant la version de PHP :** PHP 8.5 n'existe pas
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Salut ! Je suis WEVCODE, ton générateur de code souverain WEVAL. Tu veux une API REST PHP complète, architecturée en microservices, avec Docker Compose, connexion PostgreSQL, et le tout en JSON. Et un seul fichier PHP par microservice pour l'exemple.
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
Absolument ! En tant que WEVCODE, je suis votre générateur de code souverain WEVAL. Je vais vous fournir une architecture microservices complète, avec un microservice PHP fonctionnel pour la gestion des produits, un Docker Compose pour orchestrer l'ensemble, et les instructions
|
||||
@@ -1,198 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST en PHP qui répond aux exigences mentionnées ci-dessus :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'saassql');
|
||||
define('DB_USER', 'saassql');
|
||||
define('DB_PASSWORD', 'saassql');
|
||||
|
||||
// Connexion à la base de données
|
||||
function dbConnect() {
|
||||
$host = DB_HOST;
|
||||
$database = DB_NAME;
|
||||
$username = DB_USER;
|
||||
$password = DB_PASSWORD;
|
||||
|
||||
try {
|
||||
$conn = pg_connect("host=$host dbname=$database user=$username password=$password");
|
||||
if (!$conn) {
|
||||
echo "Connexion à la base de données échouée : erreur de PGSQL";
|
||||
die();
|
||||
}
|
||||
return $conn;
|
||||
} catch (PDOException $e) {
|
||||
echo "Une erreur est survenue : " . $e->getMessage();
|
||||
die();
|
||||
}
|
||||
}
|
||||
|
||||
function createTable() {
|
||||
$conn = dbConnect();
|
||||
$sql = "CREATE TABLE IF NOT EXISTS users (
|
||||
id SERIAL PRIMARY KEY,
|
||||
username VARCHAR(255) UNIQUE NOT NULL,
|
||||
password VARCHAR(255) NOT NULL,
|
||||
email VARCHAR(255) NOT NULL
|
||||
);";
|
||||
|
||||
pg_query($conn, $sql);
|
||||
$sql = "CREATE TABLE IF NOT EXISTS billing (
|
||||
id SERIAL PRIMARY KEY,
|
||||
userId INTEGER NOT NULL,
|
||||
plan VARCHAR(255) NOT NULL,
|
||||
price DECIMAL(10,2) NOT NULL,
|
||||
expiration DATE NOT NULL,
|
||||
FOREIGN KEY (userId) REFERENCES users(id)
|
||||
);";
|
||||
|
||||
pg_query($conn, $sql);
|
||||
$sql = "CREATE TABLE IF NOT EXISTS api (
|
||||
id SERIAL PRIMARY KEY,
|
||||
userId INTEGER NOT NULL,
|
||||
apikey VARCHAR(255) UNIQUE NOT NULL,
|
||||
FOREIGN KEY (userId) REFERENCES users(id)
|
||||
);";
|
||||
|
||||
pg_query($conn, $sql);
|
||||
}
|
||||
|
||||
function userCreate($username, $password, $email) {
|
||||
$conn = dbConnect();
|
||||
$sql = "INSERT INTO users (username, password, email) VALUES ('$username', '$password', '$email') RETURNING *;";
|
||||
|
||||
$result = pg_query($conn, $sql);
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function userRead($userId) {
|
||||
$conn = dbConnect();
|
||||
$sql = "SELECT * FROM users WHERE id = $1;";
|
||||
|
||||
$result = pg_prepare($conn, "read_user", $sql);
|
||||
$result = pg_execute($conn, "read_user", array($userId));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function userUpdate($userId, $username, $password, $email) {
|
||||
$conn = dbConnect();
|
||||
$sql = "UPDATE users SET username = $2, password = $3, email = $4 WHERE id = $1 RETURNING *;";
|
||||
|
||||
$result = pg_prepare($conn, "update_user", $sql);
|
||||
$result = pg_execute($conn, "update_user", array($userId, $username, $password, $email));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function userDelete($userId) {
|
||||
$conn = dbConnect();
|
||||
$sql = "DELETE FROM users WHERE id = $1;";
|
||||
|
||||
$result = pg_prepare($conn, "delete_user", $sql);
|
||||
$result = pg_execute($conn, "delete_user", array($userId));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
}
|
||||
|
||||
function billingCreate($userId, $plan, $price, $expiration) {
|
||||
$conn = dbConnect();
|
||||
$sql = "INSERT INTO billing (userId, plan, price, expiration) VALUES ($1, $2, $3, $4) RETURNING *;";
|
||||
|
||||
$result = pg_prepare($conn, "create_billing", $sql);
|
||||
$result = pg_execute($conn, "create_billing", array($userId, $plan, $price, $expiration));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function billingRead($billingId) {
|
||||
$conn = dbConnect();
|
||||
$sql = "SELECT * FROM billing WHERE id = $1;";
|
||||
|
||||
$result = pg_prepare($conn, "read_billing", $sql);
|
||||
$result = pg_execute($conn, "read_billing", array($billingId));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function billingUpdate($billingId, $plan, $price, $expiration) {
|
||||
$conn = dbConnect();
|
||||
$sql = "UPDATE billing SET plan = $2, price = $3, expiration = $4 WHERE id = $1 RETURNING *;";
|
||||
|
||||
$result = pg_prepare($conn, "update_billing", $sql);
|
||||
$result = pg_execute($conn, "update_billing", array($billingId, $plan, $price, $expiration));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
function billingDelete($billingId) {
|
||||
$conn = dbConnect();
|
||||
$sql = "DELETE FROM billing WHERE id = $1;";
|
||||
|
||||
$result = pg_prepare($conn, "delete_billing", $sql);
|
||||
$result = pg_execute($conn, "delete_billing", array($billingId));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
}
|
||||
|
||||
function apiCreate($userId, $apikey) {
|
||||
$conn = dbConnect();
|
||||
$sql = "INSERT INTO api (userId, apikey) VALUES ($1, $2) RETURNING *;";
|
||||
|
||||
$result = pg_prepare($conn, "create_api", $sql);
|
||||
$result = pg_execute($conn, "create_api", array($userId, $apikey));
|
||||
|
||||
if (!$result) {
|
||||
echo "Erreur de requête : " . pg_last_error($conn);
|
||||
die();
|
||||
}
|
||||
|
||||
$row = pg_fetch_array($result, null, PGSQL_ASSOC);
|
||||
return $row;
|
||||
}
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
<?php
|
||||
**API REST SaaS avec Auth, Dashboard, Billing, API et Panel d'Administration**
|
||||
|
||||
### Informations sur le projet
|
||||
|
||||
Ce projet est une application SaaS complète qui offre plusieurs fonctionnalités : authentification, dashboard, gestion des plans de facturation, API pour permettre l'intégration avec d'autres applications, et un panel d'administration pour les administrateurs.
|
||||
|
||||
### Technologies utilisées
|
||||
|
||||
* PHP 8.5
|
||||
* PostgreSQL
|
||||
* HTML5/CSS3/JS (pour les APIs et les requêtes)
|
||||
* JSON (pour les réponses)
|
||||
|
||||
### Code complet
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la connexion à la base de données
|
||||
$host = 'localhost';
|
||||
$dbname = 'saassql';
|
||||
$user = 'saassql';
|
||||
$password = 'password';
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = new PDO("pgsql:host=$host;dbname=$dbname", $user, $password);
|
||||
|
||||
// Fonction pour générer un token de connexion
|
||||
function generateToken() {
|
||||
$token = bin2hex(random_bytes(32));
|
||||
return $token;
|
||||
}
|
||||
|
||||
// Fonction pour valider un token de connexion
|
||||
function validateToken($token) {
|
||||
if (strlen($token) === 64) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Classe pour gérer les utilisateurs
|
||||
class User {
|
||||
public $id;
|
||||
public $name;
|
||||
public $email;
|
||||
public $password;
|
||||
public $role;
|
||||
|
||||
public function __construct($id, $name, $email, $password, $role) {
|
||||
$this->id = $id;
|
||||
$this->name = $name;
|
||||
$this->email = $email;
|
||||
$this->password = $password;
|
||||
$this->role = $role;
|
||||
}
|
||||
}
|
||||
|
||||
// Méthodes pour les utilisateurs
|
||||
function getUsers($token) {
|
||||
$query = "SELECT * FROM users";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->execute();
|
||||
$users = $stmt->fetchAll();
|
||||
return $users;
|
||||
}
|
||||
|
||||
function getUser($id, $token) {
|
||||
$query = "SELECT * FROM users WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$user = $stmt->fetch();
|
||||
return $user;
|
||||
}
|
||||
|
||||
function createUser($name, $email, $password, $role, $token) {
|
||||
$query = "INSERT INTO users (name, email, password, role) VALUES (:name, :email, :password, :role)";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':name', $name);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->bindParam(':password', $password);
|
||||
$stmt->bindParam(':role', $role);
|
||||
$stmt->execute();
|
||||
$userId = $GLOBALS['conn']->lastInsertId();
|
||||
return $userId;
|
||||
}
|
||||
|
||||
function updateUser($id, $name, $email, $password, $role, $token) {
|
||||
$query = "UPDATE users SET name = :name, email = :email, password = :password, role = :role WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->bindParam(':name', $name);
|
||||
$stmt->bindParam(':email', $email);
|
||||
$stmt->bindParam(':password', $password);
|
||||
$stmt->bindParam(':role', $role);
|
||||
$stmt->execute();
|
||||
return $id;
|
||||
}
|
||||
|
||||
function deleteUser($id, $token) {
|
||||
$query = "DELETE FROM users WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
return $id;
|
||||
}
|
||||
|
||||
// Méthodes pour les plans de facturation
|
||||
function getPlans() {
|
||||
$query = "SELECT * FROM plans";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->execute();
|
||||
$plans = $stmt->fetchAll();
|
||||
return $plans;
|
||||
}
|
||||
|
||||
function getPlan($id) {
|
||||
$query = "SELECT * FROM plans WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
$plan = $stmt->fetch();
|
||||
return $plan;
|
||||
}
|
||||
|
||||
function createPlan($name, $price, $description) {
|
||||
$query = "INSERT INTO plans (name, price, description) VALUES (:name, :price, :description)";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':name', $name);
|
||||
$stmt->bindParam(':price', $price);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->execute();
|
||||
$planId = $GLOBALS['conn']->lastInsertId();
|
||||
return $planId;
|
||||
}
|
||||
|
||||
function updatePlan($id, $name, $price, $description) {
|
||||
$query = "UPDATE plans SET name = :name, price = :price, description = :description WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->bindParam(':name', $name);
|
||||
$stmt->bindParam(':price', $price);
|
||||
$stmt->bindParam(':description', $description);
|
||||
$stmt->execute();
|
||||
return $id;
|
||||
}
|
||||
|
||||
function deletePlan($id) {
|
||||
$query = "DELETE FROM plans WHERE id = :id";
|
||||
$stmt = $GLOBALS['conn']->prepare($query);
|
||||
$stmt->bindParam(':id', $id);
|
||||
$stmt->execute();
|
||||
return $id;
|
||||
}
|
||||
|
||||
// Gestion du dashboard
|
||||
function getDashboardData($token) {
|
||||
$data = array();
|
||||
if (validateToken($token)) {
|
||||
$data['message'] = 'Bienvenue !';
|
||||
$data['plans'] = getPlans();
|
||||
} else {
|
||||
$data['message'] = 'Token invalide';
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Gestion de l'API
|
||||
function getAPI($token) {
|
||||
$data = array();
|
||||
if (validateToken($token)) {
|
||||
$data['message'] = 'API accessible !';
|
||||
$data['plans'] = getPlans();
|
||||
} else {
|
||||
$data['message'] = 'Token invalide';
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Gestion du panel d'administration
|
||||
function getAdminPanel($token) {
|
||||
$data = array();
|
||||
if (validateToken($token)) {
|
||||
$data['message'] = 'Panel d\'administration accessible !';
|
||||
$data['users'] = getUsers($token);
|
||||
} else {
|
||||
$data['message'] = 'Token invalide';
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
// Fonction pour traiter les requêtes
|
||||
function handleRequest($method, $url, $data, $token) {
|
||||
switch ($method)
|
||||
@@ -1,154 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complete en PHP pour une application SaaS avec auth, dashboard, billing, API, admin panel et sandbox de code execution :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de PostgreSQL
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_USER', 'utilisateur');
|
||||
define('DB_PASSWORD', 'motdepasseseul');
|
||||
define('DB_NAME', 'saassql');
|
||||
|
||||
// Configuration de l'application
|
||||
define('TOKEN_EXPIRATION', 3600); // 1 heure
|
||||
define('TOKEN_SECRET', 'secret_token');
|
||||
|
||||
// Fonction pour générer un token JWT
|
||||
function generateToken($payload) {
|
||||
$header = json_encode(['typ' => 'JWT', 'alg' => 'HS256']);
|
||||
$payload = json_encode($payload);
|
||||
$signature = hash_hmac('sha256', $header . '.' . $payload, TOKEN_SECRET, true);
|
||||
return $header . '.' . $payload . '.' . bin2hex($signature);
|
||||
}
|
||||
|
||||
// Fonction pour vérifier un token JWT
|
||||
function verifyToken($token) {
|
||||
try {
|
||||
$decoded = json_decode(base64_decode(explode('.', $token)[1]), true);
|
||||
if (strlen(explode('.', $token)[0] . '.' . explode('.', $token)[1]) !== 250) {
|
||||
throw new Exception('Invalid token');
|
||||
}
|
||||
$header = json_decode(base64_decode(explode('.', $token)[0]), true);
|
||||
$signature = hash_hmac('sha256', explode('.', $token)[0] . '.' . explode('.', $token)[1], TOKEN_SECRET, true);
|
||||
return $decoded;
|
||||
} catch (Exception $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Connexion à PostgreSQL
|
||||
$dsn = 'pgsql:host=' . DB_HOST . ';dbname=' . DB_NAME;
|
||||
$options = [
|
||||
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_EMULATE_PREPARES => false,
|
||||
];
|
||||
$pdo = new PDO($dsn, DB_USER, DB_PASSWORD, $options);
|
||||
|
||||
// Route pour obtenir le dashboard
|
||||
$app->get('/dashboard', function() use ($pdo) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM utilisateur WHERE id = :id');
|
||||
$stmt->execute(['id' => $_SESSION['id']]);
|
||||
$utilisateur = $stmt->fetch();
|
||||
http_response_code(200);
|
||||
echo json_encode(['utilisateur' => $utilisateur]);
|
||||
});
|
||||
|
||||
// Route pour obtenir la liste des utilisateurs
|
||||
$app->get('/utilisateurs', function() use ($pdo) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM utilisateur');
|
||||
$stmt->execute();
|
||||
http_response_code(200);
|
||||
echo json_encode($stmt->fetchAll());
|
||||
});
|
||||
|
||||
// Route pour créer un utilisateur
|
||||
$app->post('/utilisateur', function() use ($pdo) {
|
||||
if (empty($_POST['nom']) || empty($_POST['prenom'])) {
|
||||
http_response_code(400);
|
||||
echo json_encode(['erreur' => 'Veuillez saisir un nom et un prénom']);
|
||||
return;
|
||||
}
|
||||
$stmt = $pdo->prepare('INSERT INTO utilisateur (nom, prenom) VALUES (:nom, :prenom)');
|
||||
$stmt->execute(['nom' => $_POST['nom'], 'prenom' => $_POST['prenom']]);
|
||||
http_response_code(201);
|
||||
echo json_encode(['message' => 'Utilisateur créé avec succès']);
|
||||
});
|
||||
|
||||
// Route pour mettre à jour un utilisateur
|
||||
$app->put('/utilisateur/{id}', function($id) use ($pdo) {
|
||||
if (!verifyToken($_COOKIE['token'])) {
|
||||
http_response_code(401);
|
||||
echo json_encode(['erreur' => 'Vous n\'avez pas le droit de modifier cet utilisateur']);
|
||||
return;
|
||||
}
|
||||
if (empty($_POST['nom']) || empty($_POST['prenom'])) {
|
||||
http_response_code(400);
|
||||
echo json_encode(['erreur' => 'Veuillez saisir un nom et un prénom']);
|
||||
return;
|
||||
}
|
||||
$stmt = $pdo->prepare('UPDATE utilisateur SET nom = :nom, prenom = :prenom WHERE id = :id');
|
||||
$stmt->execute(['nom' => $_POST['nom'], 'prenom' => $_POST['prenom'], 'id' => $id]);
|
||||
http_response_code(200);
|
||||
echo json_encode(['message' => 'Utilisateur mis à jour avec succès']);
|
||||
});
|
||||
|
||||
// Route pour supprimer un utilisateur
|
||||
$app->delete('/utilisateur/{id}', function($id) use ($pdo) {
|
||||
if (!verifyToken($_COOKIE['token'])) {
|
||||
http_response_code(401);
|
||||
echo json_encode(['erreur' => 'Vous n\'avez pas le droit de supprimer cet utilisateur']);
|
||||
return;
|
||||
}
|
||||
$stmt = $pdo->prepare('DELETE FROM utilisateur WHERE id = :id');
|
||||
$stmt->execute(['id' => $id]);
|
||||
http_response_code(204);
|
||||
echo json_encode(['message' => 'Utilisateur supprimé avec succès']);
|
||||
});
|
||||
|
||||
// Route pour obtenir la liste des factures
|
||||
$app->get('/factures', function() use ($pdo) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM facture');
|
||||
$stmt->execute();
|
||||
http_response_code(200);
|
||||
echo json_encode($stmt->fetchAll());
|
||||
});
|
||||
|
||||
// Route pour créer une facture
|
||||
$app->post('/facture', function() use ($pdo) {
|
||||
if (empty($_POST['date']) || empty($_POST['montant'])) {
|
||||
http_response_code(400);
|
||||
echo json_encode(['erreur' => 'Veuillez saisir une date et un montant']);
|
||||
return;
|
||||
}
|
||||
$stmt = $pdo->prepare('INSERT INTO facture (date, montant) VALUES (:date, :montant)');
|
||||
$stmt->execute(['date' => $_POST['date'], 'montant' => $_POST['montant']]);
|
||||
http_response_code(201);
|
||||
echo json_encode(['message' => 'Facture créée avec succès']);
|
||||
});
|
||||
|
||||
// Route pour obtenir la liste des codes
|
||||
$app->get('/codes', function() use ($pdo) {
|
||||
$stmt = $pdo->prepare('SELECT * FROM code');
|
||||
$stmt->execute();
|
||||
http_response_code(200);
|
||||
echo json_encode($stmt->fetchAll());
|
||||
});
|
||||
|
||||
// Route pour créer un code
|
||||
$app->post('/code', function() use ($pdo) {
|
||||
if (empty($_POST['nom']) || empty($_POST['code'])) {
|
||||
http_response_code(400);
|
||||
echo json_encode(['erreur' => 'Veuillez saisir un nom et un code']);
|
||||
return;
|
||||
}
|
||||
$stmt = $pdo->prepare('INSERT INTO code (nom, code) VALUES (:nom, :code)');
|
||||
$stmt->execute(['nom' => $_POST['nom'], 'code' => $_POST['code']]);
|
||||
http_response_code(201);
|
||||
echo json_encode(['message' => 'Code créé avec succès']);
|
||||
});
|
||||
|
||||
// Route pour exécuter du code
|
||||
$app->post('/code/execution', function() use ($pdo) {
|
||||
if (empty($_POST
|
||||
@@ -1,245 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet en PHP pour l'API REST que vous avez demandé :
|
||||
|
||||
```php
|
||||
// Fichier init.php : Connexion à PostgreSQL, configuration du framework et autoload
|
||||
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'saastrac');
|
||||
define('DB_USER', 'saastrac');
|
||||
define('DB_PASSWORD', 'password');
|
||||
|
||||
// Connexion à PostgreSQL
|
||||
try {
|
||||
$dsn = "pgsql:host=" . DB_HOST . ";dbname=" . DB_NAME;
|
||||
$pdo = new PDO($dsn, DB_USER, DB_PASSWORD, array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION));
|
||||
echo "Connexion à la base de données réussie";
|
||||
} catch (PDOException $e) {
|
||||
echo 'erreur', $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Configuration du framework
|
||||
require __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
// Autoload les classes nécessaires
|
||||
$container = new League\Container\Container();
|
||||
$container->add(Laminas\Diactoros\ServerRequestFactory::class);
|
||||
$container->add(Laminas\Diactoros\Response\HtmlResponse::class);
|
||||
|
||||
$container->add(function () use ($pdo) {
|
||||
return new MyApp\Db\Pgsql($pdo);
|
||||
});
|
||||
|
||||
$container->add(function (MyApp\Db\Pgsql $db) {
|
||||
return new MyApp\Repository\Dashboard($db);
|
||||
});
|
||||
|
||||
$container->add(function (MyApp\Repository\Dashboard $dashboardRepository) {
|
||||
return new MyApp\UseCase\Dashboard($dashboardRepository);
|
||||
});
|
||||
|
||||
$container->add(function (MyApp\UseCase\Dashboard $dashboardUseCase, ServerRequestFactory $requestFactory) {
|
||||
return new MyApp\Controller\DashboardController($dashboardUseCase, $requestFactory);
|
||||
});
|
||||
|
||||
// Ajouter d'autres dépendances si nécessaire
|
||||
|
||||
// Demander la route actuelle
|
||||
$routerFactory = $container->get(Laminas\Router\FastRoute\DispatcherFactory::class);
|
||||
$router = $routerFactory->createRouter();
|
||||
$router->addRoute([
|
||||
'name' => 'dashboard',
|
||||
'options' => [
|
||||
'route' => '/',
|
||||
'constraints' => [
|
||||
'saeai' => '[^/]+',
|
||||
],
|
||||
'defaults' => [
|
||||
'controller' => MyApp\Controller\DashboardController::class,
|
||||
'action' => 'index',
|
||||
],
|
||||
],
|
||||
]);
|
||||
|
||||
// Autoloader
|
||||
require __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
// Démarrage de l'application
|
||||
$container->get(ServerRequestFactory::class);
|
||||
$request = $container->get(ServerRequestFactory::class)->createRequest();
|
||||
$dispatcher = $router->getDispatcher();
|
||||
$dispatcher->dispatch($request);
|
||||
|
||||
// Traitement des exceptions
|
||||
if ($request->getAttribute('exception')) {
|
||||
$exception = $request->getAttribute('exception');
|
||||
http_response_code($exception->getCode());
|
||||
$content = (new ExceptionRenderer())->__invoke($exception);
|
||||
return $response->write($content);
|
||||
}
|
||||
|
||||
// Afficher le contenu
|
||||
$html = (new HtmlResponse($content))->getHeader();
|
||||
foreach ($html as $header) {
|
||||
header($header);
|
||||
}
|
||||
return $content;
|
||||
```
|
||||
|
||||
```php
|
||||
// Fichier MyApp\Db\Pgsql.php : Modèle de gestion de la base de données PostgreSQL
|
||||
|
||||
<?php
|
||||
|
||||
namespace MyApp\Db;
|
||||
|
||||
use PDO;
|
||||
|
||||
class Pgsql
|
||||
{
|
||||
private $pdo;
|
||||
|
||||
public function __construct(PDO $pdo)
|
||||
{
|
||||
$this->pdo = $pdo;
|
||||
}
|
||||
|
||||
public function prepare($query)
|
||||
{
|
||||
return $this->pdo->prepare($query);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```php
|
||||
// Fichier MyApp\Repository\Dashboard.php : Référentiel de gestion des données sur le tableau de bord
|
||||
|
||||
<?php
|
||||
|
||||
namespace MyApp\Repository;
|
||||
|
||||
use MyApp\Db\Pgsql;
|
||||
|
||||
class Dashboard
|
||||
{
|
||||
private $db;
|
||||
|
||||
public function __construct(Pgsql $db)
|
||||
{
|
||||
$this->db = $db;
|
||||
}
|
||||
|
||||
public function findAll()
|
||||
{
|
||||
$query = "SELECT * FROM dashboard";
|
||||
$stmt = $this->db->prepare($query);
|
||||
$stmt->execute();
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
public function find($id)
|
||||
{
|
||||
$query = "SELECT * FROM dashboard WHERE id = :id";
|
||||
$stmt = $this->db->prepare($query);
|
||||
$stmt->setParameter('id', $id);
|
||||
$stmt->execute();
|
||||
return $stmt->fetch();
|
||||
}
|
||||
|
||||
public function save(DashboardEntity $entity)
|
||||
{
|
||||
if ($entity->getId()) {
|
||||
$query = "UPDATE dashboard SET name = :name, description = :description WHERE id = :id";
|
||||
$stmt = $this->db->prepare($query);
|
||||
$stmt->setParameter('id', $entity->getId());
|
||||
$stmt->setParameter('name', $entity->getName());
|
||||
$stmt->setParameter('description', $entity->getDescription());
|
||||
$stmt->execute();
|
||||
} else {
|
||||
$query = "INSERT INTO dashboard (name, description) VALUES (:name, :description)";
|
||||
$stmt = $this->db->prepare($query);
|
||||
$stmt->setParameter('name', $entity->getName());
|
||||
$stmt->setParameter('description', $entity->getDescription());
|
||||
$stmt->execute();
|
||||
$entity->setId($this->db->lastInsertId());
|
||||
}
|
||||
}
|
||||
|
||||
public function delete($id)
|
||||
{
|
||||
$query = "DELETE FROM dashboard WHERE id = :id";
|
||||
$stmt = $this->db->prepare($query);
|
||||
$stmt->setParameter('id', $id);
|
||||
$stmt->execute();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```php
|
||||
// Fichier MyApp\UseCase\Dashboard.php : Utilité de gestion logique des données sur le tableau de bord
|
||||
|
||||
<?php
|
||||
|
||||
namespace MyApp\UseCase;
|
||||
|
||||
use MyApp\Repository\Dashboard;
|
||||
use MyApp\Request\Request;
|
||||
|
||||
class Dashboard
|
||||
{
|
||||
private $repository;
|
||||
|
||||
public function __construct(Dashboard $repository)
|
||||
{
|
||||
$this->repository = $repository;
|
||||
}
|
||||
|
||||
public function getAll(DashboardRequest $request)
|
||||
{
|
||||
return $this->repository->findAll();
|
||||
}
|
||||
|
||||
public function getOne(DashboardRequest $request)
|
||||
{
|
||||
return $this->repository->find($request->getId());
|
||||
}
|
||||
|
||||
public function save(DashboardRequest $request)
|
||||
{
|
||||
$entity = new DashboardEntity();
|
||||
$entity->setId($request->getId());
|
||||
$entity->setName($request->getName());
|
||||
$entity->setDescription($request->getDescription());
|
||||
$this->repository->save($entity);
|
||||
return $entity;
|
||||
}
|
||||
|
||||
public function delete(DashboardRequest $request)
|
||||
{
|
||||
$this->repository->delete($request->getId());
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```php
|
||||
// Fichier MyApp\Controller\DashboardController.php : Contrôleur de gestion de la vue
|
||||
|
||||
<?php
|
||||
|
||||
namespace MyApp\Controller;
|
||||
|
||||
use Symfony\Component\HttpFoundation\JsonResponse;
|
||||
use Symfony\Component\HttpFoundation\Request;
|
||||
use Laminas\Diactoros\Response\HtmlResponse;
|
||||
use MyApp\UseCase\Dashboard;
|
||||
use MyApp\Request\DashboardRequest;
|
||||
|
||||
class DashboardController
|
||||
{
|
||||
private $dashboardUseCase;
|
||||
|
||||
public function __construct(Dashboard $dashboardUseCase)
|
||||
@@ -1,206 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST en PHP pour une application SaaS avec les fonctionnalités suivantes :
|
||||
|
||||
- Authentification
|
||||
- Dashboard
|
||||
- Billetterie
|
||||
- API REST pour les tests automatisés avec Playwright et Chromedriver
|
||||
- Admin panel
|
||||
- Connexion à une base de données PostgreSQL
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Définition des constantes
|
||||
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_USER', 'votre_utilisateur');
|
||||
define('DB_PASSWORD', 'votre_mot_de_passe');
|
||||
define('DB_NAME', 'votre_nom_de_base_de_donnees');
|
||||
|
||||
// Connexion à la base de données
|
||||
|
||||
$conn = new PDO('pgsql:host=' . DB_HOST . ';dbname=' . DB_NAME, DB_USER, DB_PASSWORD);
|
||||
|
||||
// Fonction pour générer un token JWT
|
||||
|
||||
function generateToken($id, $email, $role) {
|
||||
$token = JWT::encode(['id' => $id, 'email' => $email, 'role' => $role], ' votre_secret_clé', 'HS256');
|
||||
return $token;
|
||||
}
|
||||
|
||||
// Fonction pour vérifier un token JWT
|
||||
|
||||
function verifyToken($token) {
|
||||
try {
|
||||
$decoded = JWT::decode($token, 'votre_secret_clé', ['HS256']);
|
||||
return $decoded;
|
||||
} catch (Exception $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour exécuter une requête SQL
|
||||
|
||||
function executeQuery($query, $params = []) {
|
||||
try {
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute($params);
|
||||
return $stmt->fetchALL(PDO::FETCH_ASSOC);
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour exécuter une requête SQL avec fetch
|
||||
|
||||
function executeQueryFetch($query, $params = []) {
|
||||
try {
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute($params);
|
||||
return $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
} catch (PDOException $e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Création du tableaux utilisateurs
|
||||
|
||||
define('TABLE_USERS', 'users');
|
||||
define('COLUMN_USERS_ID', 'id');
|
||||
define('COLUMN_USERS_EMAIL', 'email');
|
||||
define('COLUMN_USERS_PASSWORD', 'password');
|
||||
define('COLUMN_USERS_ROLE', 'role');
|
||||
|
||||
// Création du tableau tests
|
||||
|
||||
define('TABLE_TESTS', 'tests');
|
||||
define('COLUMN_TESTS_ID', 'id');
|
||||
define('COLUMN_TESTS_NAME', 'name');
|
||||
define('COLUMN_TESTS_DESCRIPTION', 'description');
|
||||
|
||||
// Création du tableau résultats
|
||||
|
||||
define('TABLE_RESULTS', 'results');
|
||||
define('COLUMN_RESULTS_ID', 'id');
|
||||
define('COLUMN_RESULTS_TEST_ID', 'test_id');
|
||||
define('COLUMN_RESULTS_RESULT', 'result');
|
||||
|
||||
// Fonction pour définir le header HTTP
|
||||
|
||||
header('Content-Type: application/json');
|
||||
|
||||
// Fonction pour générer un ID unique
|
||||
|
||||
function generateId() {
|
||||
return uniqid('', true);
|
||||
}
|
||||
|
||||
// Fonction pour définir la date et heure actuelles
|
||||
|
||||
date_default_timezone_set('Europe/Paris');
|
||||
date_default_set_timezone_mode('current');
|
||||
|
||||
// Route pour la création de la table des utilisateurs
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/users') {
|
||||
$query = 'CREATE TABLE IF NOT EXISTS '.TABLE_USERS.' (
|
||||
'.COLUMN_USERS_ID.' SERIAL PRIMARY KEY,
|
||||
'.COLUMN_USERS_EMAIL.' VARCHAR(255) NOT NULL,
|
||||
'.COLUMN_USERS_PASSWORD.' VARCHAR(255) NOT NULL,
|
||||
'.COLUMN_USERS_ROLE.' VARCHAR(255) NOT NULL
|
||||
);';
|
||||
executeQuery($query);
|
||||
}
|
||||
|
||||
// Route pour la connexion
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/login') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
|
||||
$email = $_POST['email'];
|
||||
$password = $_POST['password'];
|
||||
$query = 'SELECT * FROM '.TABLE_USERS.' WHERE '.COLUMN_USERS_EMAIL.' = :email AND '.COLUMN_USERS_PASSWORD.' = :password;';
|
||||
$params = [
|
||||
':email' => $email,
|
||||
':password' => $password,
|
||||
];
|
||||
$result = executeQueryFetch($query, $params);
|
||||
if ($result) {
|
||||
$token = generateToken($result[COLUMN_USERS_ID], $email, $result[COLUMN_USERS_ROLE]);
|
||||
echo json_encode(['token' => $token]);
|
||||
exit;
|
||||
} else {
|
||||
echo json_encode(['message' => 'Nom d\'utilisateur ou mot de passe incorrect']);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour l\'inscription
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/signup') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
|
||||
$email = $_POST['email'];
|
||||
$password = $_POST['password'];
|
||||
$query = 'INSERT INTO '.TABLE_USERS.' ( '.COLUMN_USERS_EMAIL.', '.COLUMN_USERS_PASSWORD.', '.COLUMN_USERS_ROLE.') VALUES (:email, :password, \'user\');';
|
||||
$params = [
|
||||
':email' => $email,
|
||||
':password' => $password,
|
||||
];
|
||||
executeQuery($query, $params);
|
||||
echo json_encode(['message' => 'Utilisateur créé avec succès']);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour l\'affichage des utilisateurs
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/users') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'GET') {
|
||||
$query = 'SELECT * FROM '.TABLE_USERS.';';
|
||||
$users = executeQuery($query);
|
||||
echo json_encode($users);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour la création d\'un test
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/tests') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
|
||||
$name = $_POST['name'];
|
||||
$description = $_POST['description'];
|
||||
$query = 'INSERT INTO '.TABLE_TESTS.' ( '.COLUMN_TESTS_NAME.', '.COLUMN_TESTS_DESCRIPTION.') VALUES (:name, :description);';
|
||||
$params = [
|
||||
':name' => $name,
|
||||
':description' => $description,
|
||||
];
|
||||
executeQuery($query, $params);
|
||||
echo json_encode(['message' => 'Test créé avec succès']);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour la liste des tests
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/tests') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'GET') {
|
||||
$query = 'SELECT * FROM '.TABLE_TESTS.';';
|
||||
$tests = executeQuery($query);
|
||||
echo json_encode($tests);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour l\'affichage du résultat d\'un test
|
||||
|
||||
if (strtolower($_SERVER['REQUEST_URI']) == '/api/test/{id}') {
|
||||
if ($_SERVER['REQUEST_METHOD'] == 'GET') {
|
||||
$id = $_GET['id'];
|
||||
$query = 'SELECT * FROM '.TABLE_RESULTS.' WHERE '.COLUMN_RESULTS_TEST_ID.' = :id;';
|
||||
$params = [
|
||||
':id' => $id,
|
||||
];
|
||||
$result = executeQueryFetch($query, $params);
|
||||
if ($result) {
|
||||
|
||||
@@ -1,180 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code PHP complets pour une API REST SaaS :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Config pour la connexion à PostgreSQL
|
||||
$config = [
|
||||
'host' => 'localhost',
|
||||
'database' => 'saaadb',
|
||||
'username' => 'saaau',
|
||||
'password' => 'saaapassword'
|
||||
];
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=$config['host'] port=5432 dbname=$config['database'] user=$config['username'] password=$config['password']");
|
||||
if (!$conn) {
|
||||
echo 'Connexion échouée : ' . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
|
||||
// Funktion de sécurité pour les données entrées
|
||||
function sécuriserDonnées($donnees) {
|
||||
return htmlspecialchars(strip_tags($donnees), ENT_QUOTES);
|
||||
}
|
||||
|
||||
// Class pour les utilisateurs
|
||||
class Utilisateur {
|
||||
public $id;
|
||||
public $nom;
|
||||
public $prenom;
|
||||
public $email;
|
||||
public $motDePasse;
|
||||
public $admin;
|
||||
|
||||
function __construct($id, $nom, $prenom, $email, $motDePasse, $admin = 0) {
|
||||
$this->id = $id;
|
||||
$this->nom = $nom;
|
||||
$this->prenom = $prenom;
|
||||
$this->email = $email;
|
||||
$this->motDePasse = $motDePasse;
|
||||
$this->admin = $admin;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour créer un utilisateur
|
||||
function créerUtilisateur($nom, $prenom, $email, $motDePasse) {
|
||||
$result = pg_query_params($conn, '
|
||||
INSERT INTO utilisateur (nom, prenom, email, motDePasse)
|
||||
VALUES ($1, $2, $3, $4)
|
||||
RETURNING *
|
||||
', [$securiserDonnées($nom), $securiserDonnées($prenom), $securiserDonnées($email), $securiserDonnées($motDePasse)]);
|
||||
if ($result && pg_num_rows($result) > 0) {
|
||||
return new Utilisateur(pg_fetch_result($result, 0, 'id'), pg_fetch_result($result, 0, 'nom'), pg_fetch_result($result, 0, 'prenom'), pg_fetch_result($result, 0, 'email'), pg_fetch_result($result, 0, 'motDePasse'));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour récupérer les utilisateurs
|
||||
function getListeUtilisateurs() {
|
||||
$result = pg_query_params($conn, '
|
||||
SELECT * FROM utilisateur ORDER BY id ASC
|
||||
');
|
||||
$utilisateurs = [];
|
||||
while ($utilisateur = pg_fetch_assoc($result)) {
|
||||
$utilisateurs[] = new Utilisateur($utilisateur['id'], $utilisateur['nom'], $utilisateur['prenom'], $utilisateur['email'], $utilisateur['motDePasse'], $utilisateur['admin']);
|
||||
}
|
||||
return $utilisateurs;
|
||||
}
|
||||
|
||||
// Fonction pour récupérer un utilisateur
|
||||
function getUtilisateur($id) {
|
||||
$result = pg_query_params($conn, '
|
||||
SELECT * FROM utilisateur WHERE id = $1
|
||||
', [pg_escape_string($id)]);
|
||||
|
||||
$utilisateur = pg_fetch_assoc($result);
|
||||
if (isset($utilisateur['id'])) {
|
||||
return new Utilisateur($utilisateur['id'], $utilisateur['nom'], $utilisateur['prenom'], $utilisateur['email'], $utilisateur['motDePasse'], $utilisateur['admin']);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour mettre à jour un utilisateur
|
||||
function mettreAJourUtilisateur($id, $nom, $prenom, $email, $motDePasse) {
|
||||
$result = pg_query_params($conn, '
|
||||
UPDATE utilisateur
|
||||
SET nom = $1, prenom = $2, email = $3, motDePasse = $4
|
||||
WHERE id = $5
|
||||
', [$securiserDonnées($nom), $securiserDonnées($prenom), $securiserDonnées($email), $securiserDonnées($motDePasse), pg_escape_string($id)]);
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return getUtilisateur($id);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction pour supprimer un utilisateur
|
||||
function supprimerUtilisateur($id) {
|
||||
$result = pg_query_params($conn, '
|
||||
DELETE FROM utilisateur WHERE id = $1
|
||||
', [pg_escape_string($id)]);
|
||||
if (pg_affected_rows($result) > 0) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour créer un utilisateur
|
||||
function créerUtilisateurRoute() {
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
|
||||
$nom = $_POST['nom'];
|
||||
$prenom = $_POST['prenom'];
|
||||
$email = $_POST['email'];
|
||||
$motDePasse = $_POST['motDePasse'];
|
||||
$utilisateur = créerUtilisateur($nom, $prenom, $email, $motDePasse);
|
||||
if ($utilisateur) {
|
||||
http_response_code(201);
|
||||
echo json_encode([
|
||||
'success' => true,
|
||||
'message' => 'Utilisateur créé avec succès',
|
||||
'utilisateur' => $utilisateur
|
||||
]);
|
||||
} else {
|
||||
http_response_code(400);
|
||||
echo json_encode([
|
||||
'success' => false,
|
||||
'message' => 'Erreur lors de la création de l\'utilisateur'
|
||||
]);
|
||||
}
|
||||
} else {
|
||||
http_response_code(405);
|
||||
echo json_encode([
|
||||
'success' => false,
|
||||
'message' => 'Méthode non autorisée'
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour récupérer les utilisateurs
|
||||
function getListeUtilisateursRoute() {
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'GET') {
|
||||
$utilisateurs = getListeUtilisateurs();
|
||||
if ($utilisateurs) {
|
||||
http_response_code(200);
|
||||
echo json_encode([
|
||||
'success' => true,
|
||||
'utilisateurs' => $utilisateurs
|
||||
]);
|
||||
} else {
|
||||
http_response_code(404);
|
||||
echo json_encode([
|
||||
'success' => false,
|
||||
'message' => 'Aucun utilisateur trouvé'
|
||||
]);
|
||||
}
|
||||
} else {
|
||||
http_response_code(405);
|
||||
echo json_encode([
|
||||
'success' => false,
|
||||
'message' => 'Méthode non autorisée'
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// Route pour récupérer un utilisateur
|
||||
function getUtilisateurRoute() {
|
||||
if ($_SERVER['REQUEST_METHOD'] === 'GET') {
|
||||
$id = $_GET['id'];
|
||||
$utilisateur = getUtilisateur($id);
|
||||
if ($utilisateur) {
|
||||
http_response_code(200);
|
||||
echo json_encode([
|
||||
'success' => true,
|
||||
'utilisateur' => $utilisateur
|
||||
]);
|
||||
} else
|
||||
@@ -1,156 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API SaaS avec auth, dashboard, billing, API et administration créé à l'aide de PHP 8.5, PostgreSQL et HTML5/CSS3/JS.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration PostgreSQL
|
||||
$-host = 'localhost';
|
||||
-$db-name = 'saastr';
|
||||
-$user = 'admin';
|
||||
-$pwd = 'password';
|
||||
|
||||
// Connexion à la base de données
|
||||
$dsn = "pgsql:host=$host;dbname=$db-name";
|
||||
$options = [
|
||||
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_EMULATE_PREPARES => false,
|
||||
];
|
||||
try {
|
||||
$pdo = new PDO($dsn, $user, $pwd, $options);
|
||||
} catch (PDOException $e) {
|
||||
throw new PDOException($e->getMessage(), (int)$e->getCode());
|
||||
}
|
||||
|
||||
// Configuration de la security
|
||||
$secret_key = 'super_secret_key';
|
||||
|
||||
// Fonction pour générer un token JWT
|
||||
function generate_token($secret_key, $data) {
|
||||
$header = array(
|
||||
'alg' => 'HS256',
|
||||
'typ' => 'JWT'
|
||||
);
|
||||
$payload = $data;
|
||||
$base64UrlHeader = str_replace('+', '-', base64_encode(json_encode($header)));
|
||||
$base64UrlHeader = str_replace('/', '_', $base64UrlHeader);
|
||||
$base64UrlPayload = str_replace('+', '-', base64_encode(json_encode($payload)));
|
||||
$base64UrlPayload = str_replace('/', '_', $base64UrlPayload);
|
||||
$signature = hash_hmac('sha256', $base64UrlHeader . '.' . $base64UrlPayload, $secret_key, true);
|
||||
$base64UrlSignature = str_replace('+', '-', base64_encode($signature));
|
||||
$base64UrlSignature = str_replace('/', '_', $base64UrlSignature);
|
||||
return $base64UrlHeader . '.' . $base64UrlPayload . '.' . $base64UrlSignature;
|
||||
}
|
||||
|
||||
// Fonction pour verifier token
|
||||
function verify_token($token) {
|
||||
$secret_key = 'super_secret_key';
|
||||
$parts = explode('.', $token);
|
||||
$signature = hash_hmac('sha256', $parts[0] . '.' . $parts[1], $secret_key, true);
|
||||
$base64UrlSignature = str_replace('+', '-', base64_encode($signature));
|
||||
$base64UrlSignature = str_replace('/', '_', $base64UrlSignature);
|
||||
return $parts[2] === $base64UrlSignature;
|
||||
}
|
||||
|
||||
// API de connexion
|
||||
$app->post('/login', function ($req, $res) {
|
||||
try {
|
||||
$email = $req->getParsedBody()['email'];
|
||||
$password = $req->getParsedBody()['password'];
|
||||
$query = $pdo->prepare('SELECT * FROM users WHERE email = ? AND password = ?');
|
||||
$query->execute([$email, $password]);
|
||||
$user = $query->fetch();
|
||||
if ($user) {
|
||||
$data = [
|
||||
'id' => $user['id'],
|
||||
'name' => $user['name'],
|
||||
'email' => $user['email']
|
||||
];
|
||||
$token = generate_token($secret_key, $data);
|
||||
return $res->withHeader('Authorization', 'Bearer ' . $token)->withJson(['token' => $token]);
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de création de compte
|
||||
$app->post('/register', function ($req, $res) {
|
||||
try {
|
||||
$name = $req->getParsedBody()['name'];
|
||||
$email = $req->getParsedBody()['email'];
|
||||
$password = $req->getParsedBody()['password'];
|
||||
$query = $pdo->prepare('INSERT INTO users (name, email, password) VALUES (?, ?, ?)');
|
||||
$query->execute([$name, $email, $password]);
|
||||
return $res->withJson(['message' => 'Compte créé avec succès']);
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de dashboard
|
||||
$app->get('/dashboard', function ($req, $res) {
|
||||
try {
|
||||
$token = $req->getHeader('Authorization')[0];
|
||||
if (verify_token($token)) {
|
||||
$query = $pdo->query('SELECT * FROM dashboard');
|
||||
$data = $query->fetchAll();
|
||||
return $res->withJson($data);
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de facturation
|
||||
$app->get('/billing', function ($req, $res) {
|
||||
try {
|
||||
$token = $req->getHeader('Authorization')[0];
|
||||
if (verify_token($token)) {
|
||||
$query = $pdo->query('SELECT * FROM billing');
|
||||
$data = $query->fetchAll();
|
||||
return $res->withJson($data);
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de administration
|
||||
$app->get('/admin', function ($req, $res) {
|
||||
try {
|
||||
$token = $req->getHeader('Authorization')[0];
|
||||
if (verify_token($token)) {
|
||||
$query = $pdo->query('SELECT * FROM admin');
|
||||
$data = $query->fetchAll();
|
||||
return $res->withJson($data);
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de création de compte admin
|
||||
$app->post('/register/admin', function ($req, $res) {
|
||||
try {
|
||||
$name = $req->getParsedBody()['name'];
|
||||
$email = $req->getParsedBody()['email'];
|
||||
$password = $req->getParsedBody()['password'];
|
||||
$query = $pdo->prepare('INSERT INTO admin (name, email, password) VALUES (?, ?, ?)');
|
||||
$query->execute([$name, $email, $password]);
|
||||
return $res->withJson(['message' => 'Compte administrateur créé avec succès']);
|
||||
} catch (PDOException $e) {
|
||||
return $res->withStatus(500)->withJson(['error' => $e->getMessage()]);
|
||||
}
|
||||
});
|
||||
|
||||
// API de suppression de compte admin
|
||||
$app->delete('/admin/{id}', function ($req, $res) {
|
||||
try {
|
||||
$id = $req->getRouteParam('id');
|
||||
$query = $pdo->prepare('DELETE FROM admin WHERE id = ?');
|
||||
$query->execute([$id]);
|
||||
return $res->withJson(['message' => 'Compte administrateur supprimé avec succès']);
|
||||
} catch (PDOException $e) {
|
||||
return $res->
|
||||
@@ -1,160 +0,0 @@
|
||||
<?php
|
||||
Voici une implémentation d'une API REST complète en PHP pour une application SaaS avec auth, dashboard, billing, API et admin panel. Ce code utilise le framework PHP PDO pour se connecter à la base de données PostgreSQL.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// CONFIGURATION DE LA BASE DE DONNEES
|
||||
$host = 'localhost';
|
||||
$dbName = 'saastransaksi';
|
||||
$user = 'saastransaksi';
|
||||
$pass = 'saastransaksi';
|
||||
|
||||
// CONNEXION A LA BASE DE DONNEES
|
||||
try {
|
||||
$pdo = new PDO("pgsql:host=$host;dbname=$dbName", $user, $pass);
|
||||
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
} catch (PDOException $e) {
|
||||
echo "Connexion echouee: " . $e->getMessage();
|
||||
exit;
|
||||
}
|
||||
|
||||
// FONCTIONS DE SECURITE
|
||||
function hashPassword($password) {
|
||||
return password_hash($password, PASSWORD_DEFAULT);
|
||||
}
|
||||
|
||||
function verifyPassword($password, $hashedPassword) {
|
||||
return password_verify($password, $hashedPassword);
|
||||
}
|
||||
|
||||
// FONCTIONS DE ROUTE
|
||||
function routeGet($callback) {
|
||||
return function($request) use ($callback) {
|
||||
return $callback($request);
|
||||
};
|
||||
}
|
||||
|
||||
function routePost($callback) {
|
||||
return function($request) use ($callback) {
|
||||
return $callback($request);
|
||||
};
|
||||
}
|
||||
|
||||
function routePut($callback) {
|
||||
return function($request) use ($callback) {
|
||||
return $callback($request);
|
||||
};
|
||||
}
|
||||
|
||||
function routeDelete($callback) {
|
||||
return function($request) use ($callback) {
|
||||
return $callback($request);
|
||||
};
|
||||
}
|
||||
|
||||
function generateToken() {
|
||||
$tokens = str_split(strlen(json_encode(time())));
|
||||
$token = array();
|
||||
foreach ($tokens as $i => $token_i) {
|
||||
$token[] = substr($token_i, 0, 1);
|
||||
}
|
||||
$tokenString = implode('', $token);
|
||||
return $tokenString;
|
||||
}
|
||||
|
||||
// ROUTEUR GLOBAL
|
||||
$router = [
|
||||
'/login' => routePost(function($request) {
|
||||
$username = $request->getMethodParams('username');
|
||||
$password = $request->getMethodParams('password');
|
||||
$result = $pdo->prepare('SELECT * FROM users WHERE username = :username AND password = :password');
|
||||
$result->execute(['username' => $username, 'password' => $password]);
|
||||
if ($row = $result->fetch()) {
|
||||
$token = generateToken();
|
||||
$pdo->prepare('UPDATE users SET token = :token WHERE id = :id')->execute(['token' => $token, 'id' => $row->id]);
|
||||
return ['token' => $token];
|
||||
}
|
||||
return ['message' => 'Mauvais identifiant ou mot de passe'];
|
||||
}),
|
||||
'/dashboard' => routeGet(function($request) {
|
||||
$token = $request->getMethodParams('token');
|
||||
$result = $pdo->prepare('SELECT * FROM users WHERE token = :token');
|
||||
$result->execute(['token' => $token]);
|
||||
if ($row = $result->fetch()) {
|
||||
return [
|
||||
'name' => $row->name,
|
||||
'email' => $row->email,
|
||||
'balance' => $row->balance
|
||||
];
|
||||
}
|
||||
return ['message' => 'Le token est incorrect'];
|
||||
}),
|
||||
'/billing' => routeGet(function($request) {
|
||||
$token = $request->getMethodParams('token');
|
||||
$result = $pdo->prepare('SELECT * FROM users WHERE token = :token');
|
||||
$result->execute(['token' => $token]);
|
||||
if ($row = $result->fetch()) {
|
||||
return [
|
||||
'balance' => $row->balance,
|
||||
'transactions' => json_encode($pdo->query('SELECT * FROM transactions WHERE user_id = :id')->fetchAll())
|
||||
];
|
||||
}
|
||||
return ['message' => 'Le token est incorrect'];
|
||||
}),
|
||||
'/api/incomes' => routeGet(function($request) {
|
||||
$token = $request->getMethodParams('token');
|
||||
$result = $pdo->prepare('SELECT * FROM users WHERE token = :token');
|
||||
$result->execute(['token' => $token]);
|
||||
if ($row = $result->fetch()) {
|
||||
return json_encode($pdo->query('SELECT * FROM incomes WHERE user_id = :id')->fetchAll());
|
||||
}
|
||||
return ['message' => 'Le token est incorrect'];
|
||||
}),
|
||||
'/api/expenses' => routeGet(function($request) {
|
||||
$token = $request->getMethodParams('token');
|
||||
$result = $pdo->prepare('SELECT * FROM users WHERE token = :token');
|
||||
$result->execute(['token' => $token]);
|
||||
if ($row = $result->fetch()) {
|
||||
return json_encode($pdo->query('SELECT * FROM expenses WHERE user_id = :id')->fetchAll());
|
||||
}
|
||||
return ['message' => 'Le token est incorrect'];
|
||||
}),
|
||||
'/admin/users' => routeGet(function($request) {
|
||||
$token = $request->getMethodParams('token');
|
||||
if ($token == generateToken()) {
|
||||
return json_encode($pdo->query('SELECT * FROM users')->fetchAll());
|
||||
}
|
||||
return ['message' => 'Accès refusé'];
|
||||
}),
|
||||
'/admin/users' => routePost(function($request) use ($router) {
|
||||
$name = $request->getMethodParams('name');
|
||||
$email = $request->getMethodParams('email');
|
||||
$password = hashPassword($request->getMethodParams('password'));
|
||||
$pdo->prepare('INSERT INTO users (name, email, password) VALUES (:name, :email, :password)')->execute(['name' => $name, 'email' => $email, 'password' => $password]);
|
||||
return ['message' => 'L\'utilisateur a été créé avec succès'];
|
||||
}),
|
||||
'/admin/users/{id}' => routePut(function($request) use ($router) {
|
||||
$id = $request->getMethodParams('id');
|
||||
$name = $request->getMethodParams('name');
|
||||
$email = $request->getMethodParams('email');
|
||||
$password = $name ? hashPassword($name) : null;
|
||||
$pdo->prepare('UPDATE users SET name = :name, email = :email, password = :password WHERE id = :id')->execute(['name' => $name, 'email' => $email, 'password' => $password, 'id' => $id]);
|
||||
return ['message' => 'L\'utilisateur a été mis à jour avec succès'];
|
||||
}),
|
||||
'/admin/users/{id}' => routeDelete(function($request) use ($router) {
|
||||
$id = $request->getMethodParams('id');
|
||||
$pdo->query('DELETE FROM users WHERE id = :id')->execute(['id' => $id]);
|
||||
return ['message' => 'L\'utilisateur a été supprimé avec succès'];
|
||||
}),
|
||||
];
|
||||
|
||||
// ROUTEUR
|
||||
Request::setRouter($router);
|
||||
Request::setResponseFormat('json');
|
||||
|
||||
// CLASS REQUEST
|
||||
class Request {
|
||||
private static $response;
|
||||
private static $router;
|
||||
|
||||
@@ -1,200 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour l'API REST SaaS avec auth, dashboard, billing, API, admin panel en PHP 8.5 et PostgreSQL. Ce code utilise le framework PSR-7 et PSR-15 pour les routeurs et les dépendances.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Définition des constantes pour les bases de données
|
||||
define('DB_HOST', 'localhost');
|
||||
define('DB_NAME', 'saaas');
|
||||
define('DB_USER', 'saaas');
|
||||
define('DB_PASSWORD', 'saaas');
|
||||
|
||||
// Installation des dépendances
|
||||
composers.json
|
||||
{
|
||||
"require": {
|
||||
"php": "^8.5",
|
||||
"symfony/psr-http-message-bridge": "^2.0",
|
||||
"symfony/http-foundation": "^5.4",
|
||||
"symfony/http-kernel": "^5.4",
|
||||
"doctrine/dbal": "^3.0",
|
||||
"psr/http-server-handler": "^1.0",
|
||||
"zendframework/zend-diactoros": "^2.10",
|
||||
}
|
||||
}
|
||||
|
||||
// Import des dépendances
|
||||
require_once __DIR__ . '/vendor/autoload.php';
|
||||
|
||||
// Configuration de la base de données
|
||||
$pdo = new PDO("pgsql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
|
||||
|
||||
// Utilisation de la bibliothèque Zend Diactoros
|
||||
use Zend\Diactoros\Response;
|
||||
use Zend\Diactoros\ServerRequest;
|
||||
use Zend\Diactoros\Response\JsonResponse;
|
||||
use Zend\Diactoros\Response\HtmlResponse;
|
||||
|
||||
// Utilisation de Doctrine DBAL
|
||||
use Doctrine\DBAL\Driver\Connection;
|
||||
use Doctrine\DBAL\Schema\TableSchema;
|
||||
|
||||
// Création de la table utilisateurs
|
||||
$tableSchema = '
|
||||
CREATE TABLE IF NOT EXISTS users(
|
||||
id SERIAL PRIMARY KEY,
|
||||
username VARCHAR(255),
|
||||
password VARCHAR(255),
|
||||
email VARCHAR(255),
|
||||
role VARCHAR(255)
|
||||
)
|
||||
';
|
||||
|
||||
$stmt = $pdo-> prepare($tableSchema);
|
||||
$stmt->execute();
|
||||
|
||||
// Classes pour la gestion des utilisateurs
|
||||
class User
|
||||
{
|
||||
public $id;
|
||||
public $username;
|
||||
public $password;
|
||||
public $email;
|
||||
public $role;
|
||||
|
||||
public function __construct($id, $username, $password, $email, $role)
|
||||
{
|
||||
$this->id = $id;
|
||||
$this->username = $username;
|
||||
$this->password = $password;
|
||||
$this->email = $email;
|
||||
$this->role = $role;
|
||||
}
|
||||
}
|
||||
|
||||
class UserHandler
|
||||
{
|
||||
public function getUsers(ServerRequest $request)
|
||||
{
|
||||
$stmt = $pdo->query('SELECT * FROM users');
|
||||
$results = $stmt->fetchAll();
|
||||
return new JsonResponse($results);
|
||||
}
|
||||
|
||||
public function getUser(ServerRequest $request)
|
||||
{
|
||||
$id = $request->getAttribute('id');
|
||||
$stmt = $pdo->query('SELECT * FROM users WHERE id = '. $id);
|
||||
$results = $stmt->fetch();
|
||||
return new JsonResponse($results);
|
||||
}
|
||||
|
||||
public function createUser(ServerRequest $request)
|
||||
{
|
||||
$data = (array) $request->getParsedBody();
|
||||
$stmt = $pdo->prepare('INSERT INTO users (username, password, email, role) VALUES (:username, :password, :email, :role)');
|
||||
$stmt->execute([
|
||||
'username' => $data['username'],
|
||||
'password' => $data['password'],
|
||||
'email' => $data['email'],
|
||||
'role' => $data['role'],
|
||||
]);
|
||||
return new JsonResponse(['success' => true]);
|
||||
|
||||
}
|
||||
|
||||
public function updateUser(ServerRequest $request)
|
||||
{
|
||||
$data = (array) $request->getParsedBody();
|
||||
$id = $request->getAttribute('id');
|
||||
$stmt = $pdo->prepare('UPDATE users SET username = "'. $data['username'] .' ", password = "' . $data['password'] .' ", email = "' . $data['email'] .' ", role = "' . $data['role'] .' " WHERE id = '. $id);
|
||||
$stmt->execute();
|
||||
return new JsonResponse(['success' => true]);
|
||||
}
|
||||
|
||||
public function deleteUser(ServerRequest $request)
|
||||
{
|
||||
$id = $request->getAttribute('id');
|
||||
$stmt = $pdo->prepare('DELETE FROM users WHERE id = '. $id);
|
||||
$stmt->execute();
|
||||
return new JsonResponse(['success' => true]);
|
||||
}
|
||||
|
||||
public function login(ServerRequest $request)
|
||||
{
|
||||
$data = (array) $request->getParsedBody();
|
||||
$stmt = $pdo->prepare('SELECT * FROM users WHERE username = "'. $data['username'] .' " AND password = "' . $data['password'] .' " LIMIT 1');
|
||||
$user = $stmt->fetch();
|
||||
if (!empty($user)) {
|
||||
return new JsonResponse(['success' => true]);
|
||||
} else {
|
||||
return new JsonResponse(['success' => false], 401);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Création de la table projets
|
||||
$tableSchema = '
|
||||
CREATE TABLE IF NOT EXISTS projects(
|
||||
id SERIAL PRIMARY KEY,
|
||||
name VARCHAR(255),
|
||||
description VARCHAR(255),
|
||||
user_id INT
|
||||
)
|
||||
';
|
||||
|
||||
$stmt = $pdo->prepare($tableSchema);
|
||||
$stmt->execute();
|
||||
|
||||
// Classes pour la gestion des projets
|
||||
class Project
|
||||
{
|
||||
public $id;
|
||||
public $name;
|
||||
public $description;
|
||||
public $user_id;
|
||||
|
||||
public function __construct($id, $name, $description, $user_id)
|
||||
{
|
||||
$this->id = $id;
|
||||
$this->name = $name;
|
||||
$this->description = $description;
|
||||
$this->user_id = $user_id;
|
||||
}
|
||||
}
|
||||
|
||||
class ProjectHandler
|
||||
{
|
||||
public function getProjects(ServerRequest $request)
|
||||
{
|
||||
$stmt = $pdo->query('SELECT * FROM projects');
|
||||
$results = $stmt->fetchAll();
|
||||
return new JsonResponse($results);
|
||||
}
|
||||
|
||||
public function getProject(ServerRequest $request)
|
||||
{
|
||||
$id = $request->getAttribute('id');
|
||||
$stmt = $pdo->query('SELECT * FROM projects WHERE id = '. $id);
|
||||
$results = $stmt->fetch();
|
||||
return new JsonResponse($results);
|
||||
}
|
||||
|
||||
public function createProject(ServerRequest $request)
|
||||
{
|
||||
$data = (array) $request->getParsedBody();
|
||||
$stmt = $pdo->prepare('INSERT INTO projects (name, description, user_id) VALUES (:name, :description, :user_id)');
|
||||
$stmt->execute([
|
||||
'name' => $data['name'],
|
||||
'description' => $data['description'],
|
||||
'user_id' => $data['user_id'],
|
||||
]);
|
||||
return new JsonResponse(['success' => true]);
|
||||
}
|
||||
|
||||
public function updateProject(ServerRequest $request)
|
||||
{
|
||||
$data = (array) $request->getParsedBody();
|
||||
$id = $request->getAttribute('id');
|
||||
$stmt = $pdo->prepare('UPDATE projects SET name = "'. $data['name'] .' ", description = "' . $data['description'] .' ", user_id = '. $data['user_id'] .'
|
||||
@@ -1,185 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code pour une API REST complète en PHP pour une application SaaS :
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Configuration de la base de données
|
||||
$dbHost = 'localhost';
|
||||
$dbUsername = 'votre_nom_utilisateur';
|
||||
$dbPassword = 'votre_mot_de_passe';
|
||||
$dbName = 'your_saaas';
|
||||
|
||||
// Connexion à la base de données
|
||||
$conn = pg_connect("host=$dbHost dbname=$dbName user=$dbUsername password=$dbPassword");
|
||||
|
||||
if (!$conn) {
|
||||
throw new Exception('Erreur de connexion à la base de données : ' . pg_last_error());
|
||||
}
|
||||
|
||||
// Fonction de cryptage du mot de passe
|
||||
function cryptage_password($password) {
|
||||
return crypt($password, '$2y$10$abcdefghijklmnopqrstuvwxyz');
|
||||
}
|
||||
|
||||
// Fonction de détection du format de date
|
||||
function date_format($date_string) {
|
||||
$date_format_detect = DateTime::createFromFormat('Y-m-d', $date_string);
|
||||
if ($date_format_detect !== false) {
|
||||
return 'Y-m-d';
|
||||
} else {
|
||||
$date_format_detect = DateTime::createFromFormat('d-m-Y', $date_string);
|
||||
if ($date_format_detect !== false) {
|
||||
return 'd-m-Y';
|
||||
} else {
|
||||
throw new Exception('Format de date invalid : ' . $date_string);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction d'enregistrement de l'utilisateur
|
||||
function register_user($nom, $prenom, $email, $mot_de_passe) {
|
||||
$mot_de_passe = cryptage_password($mot_de_passe);
|
||||
$query = "INSERT INTO utilisateur(nom, prenom, email, mot_de_passe) VALUES ('$nom', '$prenom', '$email', '$mot_de_passe')";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// Fonction de connexion de l'utilisateur
|
||||
function login_user($email, $mot_de_passe) {
|
||||
$mot_de_passe = cryptage_password($mot_de_passe);
|
||||
$query = "SELECT * FROM utilisateur WHERE email = '$email' AND mot_de_passe = '$mot_de_passe'";
|
||||
$result = pg_query($conn, $query);
|
||||
return pg_fetch_assoc($result);
|
||||
}
|
||||
|
||||
// Fonction de gestion de la session de l'utilisateur
|
||||
function gestion_session($user_id, $tableau_clé) {
|
||||
session_start();
|
||||
$_SESSION['user_id'] = $user_id;
|
||||
$_SESSION[$tableau_clé] = true;
|
||||
}
|
||||
|
||||
// Fonction de suppression de la session de l'utilisateur
|
||||
function supprimer_session() {
|
||||
session_unset();
|
||||
session_destroy();
|
||||
}
|
||||
|
||||
// Fonction de création d'un utilisateur
|
||||
function create_user($nom, $prenom, $email, $mot_de_passe) {
|
||||
$result = register_user($nom, $prenom, $email, $mot_de_passe);
|
||||
if ($result) {
|
||||
return array(
|
||||
'error' => false,
|
||||
'message' => 'Utilisateur créé avec succès.'
|
||||
);
|
||||
} else {
|
||||
return array(
|
||||
'error' => true,
|
||||
'message' => 'Erreur lors de la création de l\'utilisateur.'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de récupération des utilisateurs
|
||||
function get_users() {
|
||||
$query = "SELECT * FROM utilisateur";
|
||||
$result = pg_query($conn, $query);
|
||||
$users = array();
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$users[] = $row;
|
||||
}
|
||||
return $users;
|
||||
}
|
||||
|
||||
// Fonction de récuperation d'un utilisateur en fonction de son ID
|
||||
function get_user($id) {
|
||||
$query = "SELECT * FROM utilisateur WHERE id = '$id'";
|
||||
$result = pg_query($conn, $query);
|
||||
if ($row = pg_fetch_assoc($result)) {
|
||||
return $row;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fonction de mise à jour d'un utilisateur
|
||||
function update_user($id, $nom, $prenom, $email, $mot_de_passe) {
|
||||
$query = "UPDATE utilisateur SET nom = '$nom', prenom = '$prenom', email = '$email', mot_de_passe = '$mot_de_passe' WHERE id = '$id'";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un utilisateur
|
||||
function delete_user($id) {
|
||||
$query = "DELETE FROM utilisateur WHERE id = '$id'";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// Récupération des statistiques par utilisateur
|
||||
function get_statistiques($user_id) {
|
||||
$query = "SELECT * FROM statistiques WHERE utilisateur_id = '$user_id'";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// Enregistrement des statistiques par utilisateur
|
||||
function enregistrer_statistiques($user_id, $statistique) {
|
||||
$query = "INSERT INTO statistiques(utilisateur_id, statistique) VALUES ('$user_id', '$statistique')";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// suppression des statistiques par utilisateur
|
||||
function supprimer_statistiques($user_id) {
|
||||
$query = "DELETE FROM statistiques WHERE utilisateur_id = '$user_id'";
|
||||
return pg_query($conn, $query);
|
||||
}
|
||||
|
||||
// API
|
||||
|
||||
// API Utilisateur
|
||||
$saaas = array(
|
||||
'utilisateurs' => array(
|
||||
'GET' => function() {
|
||||
return get_users();
|
||||
},
|
||||
'POST' => function() {
|
||||
$nom = strip_tags(trim($_POST['nom']));
|
||||
$prenom = strip_tags(trim($_POST['prenom']));
|
||||
$email = strip_tags(trim($_POST['email']));
|
||||
$mot_de_passe = strip_tags(trim($_POST['mot_de_passe']));
|
||||
return create_user($nom, $prenom, $email, $mot_de_passe);
|
||||
},
|
||||
'GET/:id' => function($id) {
|
||||
return get_user($id);
|
||||
},
|
||||
'PUT/:id' => function($id) {
|
||||
$nom = strip_tags(trim($_POST['nom']));
|
||||
$prenom = strip_tags(trim($_POST['prenom']));
|
||||
$email = strip_tags(trim($_POST['email']));
|
||||
$mot_de_passe = strip_tags(trim($_POST['mot_de_passe']));
|
||||
return update_user($id, $nom, $prenom, $email, $mot_de_passe);
|
||||
},
|
||||
'DELETE/:id' => function($id) {
|
||||
return delete_user($id);
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
// API Statistiques
|
||||
$saaas['statistiques'] = array(
|
||||
'GET/:id' => function($id) {
|
||||
return get_statistiques($id);
|
||||
},
|
||||
'POST/:id' => function($id) {
|
||||
$statistique = strip_tags(trim($_POST['statistique']));
|
||||
return enregistrer_statistiques($id, $statistique);
|
||||
},
|
||||
'DELETE/:id' => function($id) {
|
||||
return supprimer_statistiques($id);
|
||||
}
|
||||
);
|
||||
|
||||
// Fonction API
|
||||
function appeler_api() {
|
||||
$route = explode('/', $_SERVER['PATH_INFO']);
|
||||
$module = $route[1];
|
||||
$action = $route[
|
||||
@@ -1,176 +0,0 @@
|
||||
<?php
|
||||
Voici un exemple de code complet pour une API REST en PHP pour une application SaaS avec auth, dashboard, billing, API et un panneau d'administration. Ce code utilise PHP 8.5, PostgreSQL, HTML5, CSS3, JS pour les réponses JSON.
|
||||
|
||||
```php
|
||||
<?php
|
||||
|
||||
// Fichier de configuration pour la base de données
|
||||
$dbHost = 'localhost';
|
||||
$dbName = 'saaas';
|
||||
$dbUser = 'saaas';
|
||||
$dbPassword = 'saaas';
|
||||
|
||||
// Fichier de configuration pour l'API
|
||||
$apiPrefix = 'api';
|
||||
$apiVersion = 'v1';
|
||||
|
||||
// Connexion à la base de données
|
||||
function getDbConnection() {
|
||||
$conn = pg_connect("host=$dbHost dbname=$dbName user=$dbUser password=$dbPassword");
|
||||
if (!$conn) {
|
||||
echo "Echec de la connexion à la base de données : " . pg_last_error();
|
||||
exit;
|
||||
}
|
||||
return $conn;
|
||||
}
|
||||
|
||||
// Fonction d'autorisation (simple, sécurisation dans un prochain stade)
|
||||
function isAuthorized($method, $path) {
|
||||
if ($method == "GET") {
|
||||
return true;
|
||||
}
|
||||
if (strpos($path, '/api/v1/login') !== false || strpos($path, '/api/v1/signup') !== false) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Fonction de création d'un token de session (à sécuriser avec une clé de sessions)
|
||||
function createSessionToken($username) {
|
||||
return "session_" . $username;
|
||||
}
|
||||
|
||||
// Fonction de vérification du token de session (à sécuriser avec une clé de sessions)
|
||||
function verifySessionToken($token) {
|
||||
$username = substr($token, 9);
|
||||
// Connexion à la base de données pour vérification de l'username
|
||||
$conn = getDbConnection();
|
||||
$query = "SELECT * FROM users WHERE username = '$username'";
|
||||
$result = pg_query($conn, $query);
|
||||
if (pg_num_rows($result) == 1) {
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return true;
|
||||
}
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Fonction de récupération des données de l'utilisateur connecté
|
||||
function getUserData($token) {
|
||||
// Connexion à la base de données pour récupération des données de l'utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "SELECT * FROM users WHERE username = '$token' LIMIT 1";
|
||||
$result = pg_query($conn, $query);
|
||||
if (pg_num_rows($result) == 1) {
|
||||
$userData = pg_fetch_assoc($result);
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return $userData;
|
||||
}
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return [];
|
||||
}
|
||||
|
||||
// Fonction de création d'un nouveau utilisateur
|
||||
function createUser($username, $password, $email, $name) {
|
||||
// Connexion à la base de données pour création du nouvel utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "INSERT INTO users (username, password, email, name) VALUES ('$username', '$password', '$email', '$name')";
|
||||
pg_query($conn, $query);
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return [];
|
||||
}
|
||||
|
||||
// Fonction de modification des informations d'un utilisateur
|
||||
function updateUser($username, $password, $email, $name) {
|
||||
// Connexion à la base de données pour modification des informations de l'utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "UPDATE users SET password = '$password', email = '$email', name = '$name' WHERE username = '$username'";
|
||||
pg_query($conn, $query);
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return [];
|
||||
}
|
||||
|
||||
// Fonction de suppression d'un utilisateur
|
||||
function deleteUser($username) {
|
||||
// Connexion à la base de données pour suppression de l'utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "DELETE FROM users WHERE username = '$username'";
|
||||
pg_query($conn, $query);
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return [];
|
||||
}
|
||||
|
||||
// Fonction de récupération des utilisateurs
|
||||
function getUsers() {
|
||||
// Connexion à la base de données pour récupération des utilisateurs
|
||||
$conn = getDbConnection();
|
||||
$query = "SELECT * FROM users";
|
||||
$result = pg_query($conn, $query);
|
||||
$users = [];
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$users[] = $row;
|
||||
}
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return $users;
|
||||
}
|
||||
|
||||
// Fonction de récupération d'un utilisateur
|
||||
function getUser($username) {
|
||||
// Connexion à la base de données pour récupération de l'utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "SELECT * FROM users WHERE username = '$username'";
|
||||
$result = pg_query($conn, $query);
|
||||
$user = [];
|
||||
if (pg_num_rows($result) == 1) {
|
||||
$user = pg_fetch_assoc($result);
|
||||
}
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return $user;
|
||||
}
|
||||
|
||||
// Fonction de validation des informations de paiement (fichier de test, sécurisation dans un prochain stade)
|
||||
function validatePaymentInfo($cardNumber, $expDate, $cvv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de sauvegarde du relevé de paiement
|
||||
function saveBillingInfo($user, $cardType, $cardNumber, $expDate, $cvv) {
|
||||
// Connexion à la base de données pour sauvegarde du relevé de paiement
|
||||
$conn = getDbConnection();
|
||||
$query = "INSERT INTO billing_info (user_id, card_type, card_number, exp_date, cvv) VALUES ($user->id, '$cardType', '$cardNumber', '$expDate', '$cvv')";
|
||||
pg_query($conn, $query);
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return [];
|
||||
}
|
||||
|
||||
// Fonction de récupération des relevés de paiement de l'utilisateur
|
||||
function getBillingInfo($user) {
|
||||
// Connexion à la base de données pour récupération des relevés de paiement de l'utilisateur
|
||||
$conn = getDbConnection();
|
||||
$query = "SELECT * FROM billing_info WHERE user_id = $user->id";
|
||||
$result = pg_query($conn, $query);
|
||||
$billingInfo = [];
|
||||
while ($row = pg_fetch_assoc($result)) {
|
||||
$billingInfo[] = $row;
|
||||
}
|
||||
pg_free_result($result);
|
||||
pg_close($conn);
|
||||
return $billingInfo;
|
||||
}
|
||||
|
||||
// Fonction de validation des informations de facturation (fichier de test, sécurisation dans un prochain stade)
|
||||
function validateBillingInfo($companyName, $address, $zipcode) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Fonction de sauvegarde des informations
|
||||
@@ -1,2 +0,0 @@
|
||||
<?php
|
||||
WEVCODE est fier de vous présenter le générateur de code souverain WEVAL. Ce code PHP est un système API REST complet, fonctionnel et prêt pour la production, intégrant l'authentification, la gestion des utilisateurs, la facturation, la gestion d'API et un panneau
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user