const LoadVars = function () {
};
// ✅ Constructeur
LoadVars.prototype.constructor = function (methodeUseT = "GET", adressePhp = "") {
this.methodeUseT = methodeUseT;
this.adressePhp = adressePhp;
this.cache = new Map(); // Cache optimisé
this.queue = []; // File d’attente des requêtes
this.active = false; // Indique si une requête est en cours
};
// ✅ Requête GET avec cache
LoadVars.prototype.getRequest = function (url, useCache = true) {
if (useCache && this.cache.has(url)) {
console.log(`[LoadVars] Cache utilisé pour ${url}`);
return Promise.resolve(this.cache.get(url));
}
return fetch(url)
.then(response => {
if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
return response.text();
})
.then(data => {
this.cache.set(url, data); // Stocke dans le cache
return data;
})
.catch(error => {
console.error(`[LoadVars] Erreur GET sur ${url} :`, error);
throw error;
});
};
// ✅ Requête GET en JSON avec cache
LoadVars.prototype.getJSON = function (url, useCache = true) {
if (useCache && this.cache.has(url)) {
console.log(`[LoadVars] Cache utilisé pour ${url}`);
return Promise.resolve(this.cache.get(url));
}
return fetch(url)
.then(response => {
if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
return response.json();
})
.then(data => {
this.cache.set(url, data);
return data;
})
.catch(error => {
console.error(`[LoadVars] Erreur JSON sur ${url} :`, error);
throw error;
});
};
// ✅ Requête POST
LoadVars.prototype.postRequest = function (url, data) {
return fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(data),
})
.then(response => {
if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
return response.json();
})
.then(data => {
console.log(`[LoadVars] POST réussi sur ${url}`);
return data;
})
.catch(error => {
console.error(`[LoadVars] Erreur POST sur ${url} :`, error);
throw error;
});
};
// ✅ Ajout d’une requête en file d’attente
LoadVars.prototype.requestData = function (url, target, callback, isJSON = false) {
console.log(`[Dispatcher] Nouvelle requête : ${url} pour ${target._name}`);
this.queue.push({ url, target, callback, isJSON });
if (!this.active) {
this.processNextRequest();
}
};
// ✅ Traite la prochaine requête
LoadVars.prototype.processNextRequest = function () {
if (this.queue.length === 0) {
this.active = false;
return;
}
this.active = true;
const { url, target, callback, isJSON } = this.queue.shift();
const fetchMethod = isJSON ? this.getJSON(url) : this.getRequest(url); // ⚠️ Doit utiliser getJSON() si isJSON = true
fetchMethod
.then(data => {
if (callback) callback(data);
target.dataReceived = data;
this.processNextRequest();
})
.catch(error => {
console.error(`[LoadVars] Erreur dans la file d'attente pour ${url} :`, error);
this.processNextRequest();
});
};
LoadVars.prototype.uploadFile = function (url, file, target, callback) {
if (!url || typeof url !== "string") {
console.error("[LoadVars] URL invalide :", url);
return;
}
if (!file) {
console.error("[LoadVars] Aucun fichier sélectionné !");
return;
}
// ✅ Vérification de la taille du fichier (max 5 Mo)
const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5 Mo
if (file.size > MAX_FILE_SIZE) {
console.error("[LoadVars] Fichier trop volumineux :", file.size, "octets");
return;
}
// ✅ Vérification du type MIME du fichier
const ALLOWED_TYPES = ["image/jpeg", "image/png", "image/gif"];
if (!ALLOWED_TYPES.includes(file.type)) {
console.error("[LoadVars] Type de fichier non autorisé :", file.type);
return;
}
let formData = new FormData();
formData.append("image", file);
//console.log("[LoadVars] Tentative d'envoi du fichier :", file.name, "Taille :", file.size, "Type :", file.type);
//console.log("[LoadVars] Vérification du FormData :", formData.get("image")); // Devrait afficher un fichier
fetch(url, {
method: "POST",
body: formData,
})
.then(response => response.text())
.then(text => {
console.log("[LoadVars] Réponse brute de PHP :", text);// ✅ Voir la réponse brute avant de parser en JSON
try {
let data = JSON.parse(text); // ✅ Convertir en JSON
if (data.success) {
console.log("[LoadVars] Image uploadée avec succès :", data);
// ✅ Stocker TOUTES les données reçues dans `target`
target.dataReceived = data;
// ✅ Si un callback est défini, l'appeler avec toutes les données
if (callback) callback(data);
} else {
console.error("[LoadVars] Erreur d'upload côté serveur :", data.error);
}
} catch (error) {
console.error("[LoadVars] Erreur de parsing JSON :", error, "Réponse reçue :", text);
}
})
.catch(error => console.error("[LoadVars] Erreur réseau ou fichier PHP manquant :", error));
};
LoadVars.prototype.sendAndLoad = function(url, target) {
// Construction de l'objet à envoyer en POST
let dataToSend = {
identifiant: this.identifiant,
list: this.list,
json: this.json
};
fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(dataToSend)
})
.then(response => {
if (!response.ok) throw new Error("HTTP Error: " + response.status);
return response.text();
})
.then(text => {
console.log("[LoadVars] Réponse brute de PHP :", text);
// Analyse de la chaîne de réponse en créant un objet de paramètres
let params = {};
// Supprimer le caractère initial '&' s'il existe
if (text.charAt(0) === '&') {
text = text.substr(1);
}
// Diviser la chaîne par '&' pour récupérer chaque paramètre
let pairs = text.split('&');
pairs.forEach(pair => {
if (pair) {
// Décoder la paire pour transformer "%3D" en "="
let decoded = decodeURIComponent(pair);
let [key, value] = decoded.split('=');
if (key && value !== undefined) {
params[key] = value;
}
}
});
// Stocker l'objet complet dans target.dataReceived
target.dataReceived = params;
// Copier chaque propriété dans le movie clip pour un accès direct
for (let key in params) {
target[key] = params[key];
}
})
.catch(error => {
console.error("[LoadVars] Erreur dans sendAndLoad sur", url, ":", error);
});
};
// `onFrame` surveille la file d’attente
/* LoadVars.prototype.onFrame = function () {
if (this.queue.length === 0) {
this.active = false;
return;
}
let { url, target, callback, isJSON } = this.queue[0];
let fetchMethod = isJSON ? this.getJSON(url) : this.getRequest(url);
fetchMethod.then((data) => {
target.dataReceived = data; // Stocke la réponse dans le MovieClip
if (callback) callback(data);
this.queue.shift();
});
}; */
Pas besoin de lancer la vérification de la file d’attente à chaque frame, supprimer (ou ne pas réactiver ) onFrame. Ainsi, seule la méthode processNextRequest sera utilisée pour dépiler et traiter les requêtes. Cela garantit que chaque requête est traitée une seule fois, dès qu’elle est en tête de la file, sans risque d’exécutions multiples.
dans le fichier principal :
//test serveur
_root.createMovieClip("dispatcher", LoadVars, true);
_root.dispatcher.control = 0;
_rootMENU.createMovieClip("clip1", DOM, true);
_root.dispatcher.requestData(_global.urlSiteL + "php/dataHandler.php?type=text", _rootMENU.clip1, function(data) {
console.log("Texte reçu :", data);
}, false); // false car c'est du texte brut
_rootMENU.clip1.test = function(txt){
//this.drawRectCorner(130*ENV.CoefTaille,80*ENV.CoefTaille, 480*ENV.CoefTaille, 160*ENV.CoefTaille, true, 'rgba(0, 0, 0, 0.6)',0, 1,"rgba(0,0,0,1)",20*ENV.CoefTaille);
this.addTexte("nomARTICLEG",40* ENV.CoefTaille,130*ENV.CoefTaille,700*ENV.CoefTaille, txt, "Jura",12*ENV.CoefTaille, '#000000', 18,true);
if (this["nomARTICLEG"] && this.oldtG !== txt) {
const nouvellesOptions = {
backgroundColor: "rgba( 60, 60, 60,0.6)", // couleur de fond du texte
};
this.configureTexte(this["nomARTICLEG"], nouvellesOptions);
this.oldtG = txt;
this["nomARTICLEG"].innerHTML = txt.MultiReplace("\n","<br>");
}
}
_rootMENU.clip1.onFrame = function () {
if (this.dataReceived) {
console.log("Données du fichier :", this.dataReceived);
this.set = true;
this.txt = "Données du fichier :\n"+ this.dataReceived.toString();
this.dataReceived = null; // Réinitialiser après utilisation
}
if(this.set){
this.test(this.txt);
}
};
//fichier json (lire)
_root.createMovieClip("clip2", Vide, true);
_root.dispatcher.requestData(_global.urlSiteL + "php/dataHandler.php?type=json", _root.clip2, function(data) {
console.log("JSON reçu :", data);
},true);
_root.clip2.onFrame = function () {
if (this.dataReceived) {
let data = "\nType de dataReceived par clip2 :"+ typeof this.dataReceived;
data+= "\nDonnées JSON reçues :"+ this.dataReceived;
data+= "\nMessage :"+ this.dataReceived.message;
data+= ("\nUtilisateur :"+ this.dataReceived.utilisateur);
data+= ("\nScore :"+ this.dataReceived.score);
_rootMENU.clip1.txt+=data;
this.dataReceived = null; // Réinitialiser après utilisation
this.onFrame = function(){};
}
};
//-------------------- image (envoyer et lire) --------------------
//test dom créer le formulaire d'envoi
let enter = _root.createMovieClip("dom", DOM, true);
_root.createMovieClip("clip3", Vide, true);
//(nom, x, y, width, height, submitCallback, zIndex, backgroundColor = "white", textColor = "#533219")
let txt = "<div><h3>envoyer une image à partir de votre disque dur</h3></div>";
enter.addTexte("info",30* ENV.CoefTaille, 0*ENV.CoefTaille,900*ENV.CoefTaille, txt, "Cookie", 14*ENV.CoefTaille, "#000000", 1750,true);
// ✅ Fonction appelée après sélection d’un fichier
_root.submitCallback = function(file) {
if (!file) {
console.error("[LoadVars] Aucun fichier sélectionné !");
return;
}
console.log("[LoadVars] Envoi du fichier :", file.name, "Taille :", file.size, "Type :", file.type);
// Ajouter un champ d'upload avec un callback
_root.dispatcher.uploadFile(
_global.urlSiteL + "php/uploadImage.php",
file,
_root.clip3, // Le MovieClip qui recevra le chemin du fichier
function(filePath) {
console.log("Image envoyée, chemin :", filePath);
}
);
};
//champ de saisie
const Options = {
backgroundColor: "#a5957c",
textColor: "#ffffff",
padding: "10px",
borderRadius: "5px",
boxShadow: "0px 4px 6px rgba(0, 0, 0, 0.1)",
display: "flex",
alignItems: "center",
justifyContent: "space-between"
};
//(nom, x, y, width, height, submitCallback, zIndex, backgroundColor = "white", textColor = "#533219", optionForm = {})
_root.dom.addFileInput(
"form1",
30 * ENV.CoefTaille, 60 * ENV.CoefTaille, // Position
350 * ENV.CoefTaille, 30 * ENV.CoefTaille, // Taille
_root.submitCallback, // Fonction appelée quand un fichier est sélectionné
1000,
"#a5957c",
"#533219",
Options
);
_root.clip3.largeur = 0;
_root.clip3.onFrame = function () {
if (this.dataReceived) {
console.log("Données reçues dans clip3 :", this.dataReceived);
this.compt++;
// Récupérer les infos
let imageData = this.dataReceived.image;
let thumbnailData = this.dataReceived.thumbnail;
console.log("Image originale :", imageData.filePath, "Taille :", imageData.width, "x", imageData.height);
console.log("Miniature :", thumbnailData.filePath, "Taille :", thumbnailData.width, "x", thumbnailData.height);
let path = thumbnailData.filePath.slice(1);
let f;
let largeur = thumbnailData.width;
let hauteur = thumbnailData.height;
f = this.createMovieClipImage("image"+this.compt,path,largeur, hauteur,false, 1, "center", 0, false);
this["image"+this.compt]._x = 500+this.largeur;
this["image"+this.compt]._y = 50;
this.largeur += largeur+5;
let data = ("\nDonnées reçues dans clip3 :"+ JSON.stringify(this.dataReceived));
data += ("\nImage originale :"+ imageData.filePath+ "Taille :"+ imageData.width+ "x"+ imageData.height);
data+= ("\nMiniature :"+ thumbnailData.filePath+ "Taille :"+ thumbnailData.width+ "x"+ thumbnailData.height);
_rootMENU.clip1.txt+=data;
this.dataReceived = null; // Réinitialiser après utilisation
}
};
//sendAndLoad
_root.createMovieClip("clip4", DOM, true);
_root.clip4.onFrame = function () {
if (this.traitement === "ok") {
console.log("Données du fichier :", this.dataReceived);
console.log(this.user);
console.log(this.from);
console.log(this.recu);
console.log(this.nombre);
_rootMENU.clip1.txt +="\nMessage reçu de <strong>"+ this.recu+"</strong> via php/loadVarPost.php :" + "\n"+this.result + "\nLa requete est faite à partir de "+this.from ;
this.traitement = undefined;
}
};
let c = _root.createMovieClip("envoi", LoadVars, true, ["POST"]);
c.identifiant = "flashcom";
c.list = "_root.envoi";
c.json = {
"utilisateur": "John",
"resultat": 1500
};
//Bouton pour le sendAndLoad
let b =_root.createMovieClip("bouton",Vide,true);
b.createMovieClipImage("bt","./image/bt.png",150 * ENV.CoefTaille,20 * ENV.CoefTaille,false, 1, "center", 0, false);
b._y = 190 * ENV.CoefTaille;
b._x = 20 * ENV.CoefTaille;
b._width = 150 * ENV.CoefTaille;
b._height = 20 * ENV.CoefTaille;
_root.bouton.setBouton();
_root.bouton.onPress = function(){
_root.envoi.sendAndLoad(_global.urlSiteL + "php/loadVarPost.php", _root.clip4);
}
dans cet exemple, "php/dataHandler.php" est le fichier php qui traite les fichiers data.txt et data.json qui sont déjà présents sur le serveur
<?php
header("Access-Control-Allow-Origin: *"); // Autorise l'accès depuis n'importe où
header("Content-Type: application/json"); // Par défaut, réponse en JSON
$type = $_GET['type'] ?? ''; // Récupère le paramètre 'type', ou vide si absent
if ($type === "text") {
header("Content-Type: text/plain"); // Changer en texte brut
echo file_get_contents("../data.txt");
} elseif ($type === "json") {
header("Content-Type: application/json"); // JSON
echo file_get_contents("../data.json");
} else {
echo json_encode(["error" => "Type non valide. Utilisez ?type=text ou ?type=json"]);
}
?>
dans cet exemple, "php/uploadImage.php" est le fichier php qui traite les envois d'images et qui est défini comme la cible du clip qui envoie les images
<?php
// Paramètres de sécurité
$maxFileSize = 1 * 1024 * 1024; // 1 Mo
$allowedMimeTypes = ['image/jpeg', 'image/png', 'image/gif'];
// Dossiers d'upload
$uploadDir = realpath("../image") . DIRECTORY_SEPARATOR;
$smallDir = $uploadDir . "small" . DIRECTORY_SEPARATOR;
$response = ["status" => "debug", "messages" => []];
// Créer les dossiers si nécessaire
if (!is_dir($uploadDir)) {
if (mkdir($uploadDir, 0755, true)) {
$response["messages"][] = "✅ Dossier 'image/' créé avec succès.";
} else {
$response["messages"][] = "⚠️ Échec de la création du dossier 'image/' !";
echo json_encode($response);
exit;
}
}
if (!is_dir($smallDir)) {
if (mkdir($smallDir, 0755, true)) {
$response["messages"][] = "✅ Dossier 'small/' créé avec succès.";
} else {
$response["messages"][] = "⚠️ Échec de la création du dossier 'small/' !";
echo json_encode($response);
exit;
}
}
// Vérifier si un fichier a été reçu
if (!isset($_FILES["image"])) {
$response["success"] = false;
$response["error"] = "Aucun fichier reçu.";
echo json_encode($response);
exit;
}
// Vérifier la taille du fichier
if ($_FILES["image"]["size"] > $maxFileSize) {
$response["success"] = false;
$response["error"] = "Fichier trop volumineux. Taille maximum autorisée : 1 Mo.";
echo json_encode($response);
exit;
}
// Vérifier l'absence d'erreur d'upload
if ($_FILES["image"]["error"] !== UPLOAD_ERR_OK) {
$response["success"] = false;
$response["error"] = "Erreur d'upload : " . $_FILES["image"]["error"];
echo json_encode($response);
exit;
}
// Vérifier le type MIME à partir du contenu du fichier
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mimeType = finfo_file($finfo, $_FILES["image"]["tmp_name"]);
finfo_close($finfo);
if (!in_array($mimeType, $allowedMimeTypes)) {
$response["success"] = false;
$response["error"] = "Type de fichier non autorisé.";
echo json_encode($response);
exit;
}
// Générer un nom de fichier unique et sûr
$extension = "";
switch ($mimeType) {
case 'image/jpeg':
$extension = ".jpg";
break;
case 'image/png':
$extension = ".png";
break;
case 'image/gif':
$extension = ".gif";
break;
}
$fileName = uniqid("img_", true) . $extension;
$filePath = $uploadDir . $fileName;
$smallPath = $smallDir . $fileName;
// Déplacer le fichier uploadé dans le dossier cible
if (move_uploaded_file($_FILES["image"]["tmp_name"], $filePath)) {
// Récupérer les dimensions de l'image
$imgInfo = getimagesize($filePath);
if ($imgInfo === false) {
$response["success"] = false;
$response["error"] = "Fichier image corrompu ou invalide.";
echo json_encode($response);
exit;
}
list($originalWidth, $originalHeight) = $imgInfo;
// Optionnel : vous pouvez insérer ici une étape de « réparation » de l'image,
// si vous souhaitez par exemple gérer des fichiers corrompus.
// Dans cet exemple, nous ne faisons pas de copie/reparation automatique.
// Création de la miniature
if (createThumbnail($filePath, $smallPath, 200)) {
$thumbInfo = getimagesize($smallPath);
$thumbWidth = $thumbInfo[0];
$thumbHeight = $thumbInfo[1];
$response["success"] = true;
$response["image"] = [
"filePath" => $filePath,
"width" => $originalWidth,
"height" => $originalHeight
];
$response["thumbnail"] = [
"filePath" => $smallPath,
"width" => $thumbWidth,
"height" => $thumbHeight
];
} else {
$response["success"] = false;
$response["error"] = "Erreur lors de la création de la miniature.";
}
} else {
$response["success"] = false;
$response["error"] = "Erreur lors du déplacement du fichier.";
}
echo json_encode($response);
exit();
/**
* Crée une miniature de l'image source.
*
* @param string $sourcePath Chemin vers l'image source.
* @param string $destPath Chemin où enregistrer la miniature.
* @param int $thumbWidth Largeur désirée pour la miniature.
* @return bool Renvoie true en cas de succès, false sinon.
*/
function createThumbnail($sourcePath, $destPath, $thumbWidth) {
$info = getimagesize($sourcePath);
if ($info === false) {
return false;
}
list($width, $height, $type) = $info;
$mime = $info['mime'];
// Créer une image à partir du fichier source selon son type
switch ($mime) {
case 'image/jpeg':
$image = imagecreatefromjpeg($sourcePath);
break;
case 'image/png':
$image = imagecreatefrompng($sourcePath);
break;
case 'image/gif':
$image = imagecreatefromgif($sourcePath);
break;
default:
return false;
}
// Calculer la hauteur de la miniature en conservant les proportions
$thumbHeight = (int)(($thumbWidth / $width) * $height);
$thumbnail = imagecreatetruecolor($thumbWidth, $thumbHeight);
// Optionnel : pour les PNG et GIF, conserver la transparence
if ($mime === 'image/png' || $mime === 'image/gif') {
imagecolortransparent($thumbnail, imagecolorallocatealpha($thumbnail, 0, 0, 0, 127));
imagealphablending($thumbnail, false);
imagesavealpha($thumbnail, true);
}
// Redimensionner l'image
imagecopyresampled(
$thumbnail, $image,
0, 0, 0, 0,
$thumbWidth, $thumbHeight,
$width, $height
);
// Sauvegarder la miniature selon son type
switch ($mime) {
case 'image/jpeg':
imagejpeg($thumbnail, $destPath, 90);
break;
case 'image/png':
imagepng($thumbnail, $destPath);
break;
case 'image/gif':
imagegif($thumbnail, $destPath);
break;
}
imagedestroy($image);
imagedestroy($thumbnail);
return true;
}
?>
dans cet exemple, "php/loadVarPost.php" est le fichier php qui traite les aller retour serveur via sendAndLoad
