@rom13/genius
Version:
<img src="https://zupimages.net/up/22/22/w3tu.png" width="400" />
805 lines (731 loc) • 23.4 kB
JavaScript
//TODO ----------------------------------------------
//TODO ------- Genius v1.0 -----
const os = require("os");
const { default: axios } = require("axios");
const fs = require("fs");
let data;
const fetchloguer = () => {
console.log(data);
};
//todo ------------------------------- Express ------------------------
let port;
let originSocket;
const helmet = require("helmet");
const express = require("express");
const allowCrossDomain = function (req, res, next) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "*");
next();
};
const compression = require("compression");
const app = express();
app.use(allowCrossDomain);
app.use(express.static("public"));
// Encodage et config json
app.use(
express.urlencoded({
extended: true,
})
);
app.use(helmet());
app.use(express.json());
app.use(
compression({
level: 9,
})
);
const http = require("http");
const server = http.createServer(app);
//TODO ----------------------------------------------
let chrono;
exports.Genius = class {
version = "1.1";
//TODO ------------------------------------------------- Date --------------------------
date() {
let date = new Date().toLocaleDateString();
return date;
}
//TODO ------------------------------------------------- Heures --------------------------
heure(complet) {
let heurecomplete;
if (!complet) {
let date = new Date();
let heure = date.getHours();
let minute = date.getMinutes();
if (heure.toString().length === 1) {
let heure2 = heure.toString();
if (heure2 === "0") {
heure2 = "00";
heure = heure2;
} else if (heure2 != "0") {
heure2 = "0" + heure2;
heure = heure2;
}
heurecomplete = `${heure2}:${minute}`;
}
if (minute.toString().length === 1) {
let minute2 = minute.toString();
minute2 = "0" + minute2;
minute = minute2;
heurecomplete = `${heure}:${minute}`;
}
heurecomplete = `${heure}:${minute}`;
return heurecomplete;
} else if (complet === "complet") {
let date = new Date();
let heure = date.getHours();
let minute = date.getMinutes();
let seconde = date.getSeconds();
if (heure.toString().length === 1) {
let heure2 = heure.toString();
if (heure2 === "0") {
heure2 = "00";
heure = heure2;
} else if (heure2 != "0") {
heure2 = "0" + heure2;
heure = heure2;
}
heurecomplete = `${heure2}:${minute}`;
}
if (minute.toString().length === 1) {
let minute2 = minute.toString();
minute2 = "0" + minute2;
minute = minute2;
heurecomplete = `${heure}:${minute}:${seconde}`;
}
if (seconde.toString().length === 1) {
let seconde2 = seconde.toString();
seconde2 = "0" + seconde2;
seconde = seconde2;
heurecomplete = `${heure}:${minute}:${seconde}`;
} else {
heurecomplete = `${heure}:${minute}:${seconde}`;
}
return heurecomplete;
}
}
//TODO ------------------------------------------------- Nb aleatoire --------------------------
nbaleatoire(maximum) {
let nb = Math.floor(Math.random() * maximum + 1);
return nb;
}
nbaleatoireminmax(minimum, maximum) {
return Math.floor(Math.random() * (maximum + 1 - minimum) + minimum);
}
//TODO ------------------------------------------------- Gmail --------------------------
gmail(mailcompte, motdepassedapplication, destinataire, sujet, contenudumail) {
let rapport;
var nodemailer = require("nodemailer");
var transporter = nodemailer.createTransport({
service: "gmail",
auth: {
user: mailcompte,
pass: motdepassedapplication,
},
});
var mailOptions = {
from: "GeniusJs",
to: destinataire,
subject: sujet,
html: `<img style="width:200px" src="cid:img"/><h1>${contenudumail}<h1/>`,
attachments: [
/* { // utf-8 string as an attachment
filename: 'text1.txt',
content: 'hello world!'
}, { // use URL as an attachment
filename: 'license.jpg',
path: 'https://zupimages.net/up/21/38/hcjc.png'
}, */ {
filename: "image.png",
path: "https://zupimages.net/up/22/22/w3tu.png",
cid: "img", //same cid value as in the html img src
},
],
};
transporter.sendMail(mailOptions, function (error, info) {
if (error) {
rapport = "erreur, votre mail n'a pas été envoyé, vérifiez les informations rentrés..";
console.log(rapport);
} else {
rapport = `email envoyé avec succès à ${destinataire}, contenu du mail : ${contenudumail}`;
console.log(rapport);
}
});
}
//TODO ------------------------------------------------- Interval --------------------------
// todo---- SECONDES
intervallesecondes(secondes, fonction) {
let fonction2 = fonction;
setInterval(() => {
fonction2();
}, secondes * 1000);
}
// todo---- MINUTES
intervalleminutes(minutes, fonction) {
let fonction2 = fonction;
setInterval(() => {
fonction2();
}, minutes * 60000);
}
//TODO ------------------------------------------------- Timeout --------------------------
// todo---- SECONDES
timeursecondes(secondes, fonction) {
let fonction2 = fonction;
setTimeout(() => {
fonction2();
}, secondes * 1000);
}
// todo---- SECONDES
timeurminutes(minutes, fonction) {
let fonction2 = fonction;
setTimeout(() => {
fonction2();
}, minutes * 60000);
}
//TODO ------------------------------------------------- Chrono --------------------------
chronolog(debut) {
let nb = debut;
if (nb === undefined) {
nb = 1;
}
chrono = setInterval(() => {
console.log(nb);
nb++;
}, 1000);
}
chronologstop() {
clearInterval(chrono);
}
//TODO ------------------------------------------------- Purifier String --------------------------
purifierstring(string) {
let virus = [
"<",
">",
"<script/>",
"*",
"'",
"''",
'"',
'""',
"%",
"§",
"^",
"#",
"{",
"}",
"{}",
"$",
":",
"/",
"@",
"&",
"(",
")",
"+",
"|",
"''",
";",
"=",
"\\",
",",
"-",
"||",
"=",
"~",
"`",
"<>",
"><",
"_",
"[",
"]",
"°",
"¨",
"`",
"£",
"µ",
"¤",
];
if (typeof string != "string") {
let stringclean;
console.log("le pamamètre n'est pas un string, il ne peut donc pas être purifié! genius.purifierstring(STRING)");
stringclean = "erreur";
return stringclean;
} else {
let stringclean = Array.from(string);
stringclean.forEach((element) => {
for (let i = 0; i < virus.length; i++) {
if (element === virus[i]) {
let index = stringclean.indexOf(element);
stringclean[index] = "";
}
}
});
let stringfinal = stringclean.join("");
return stringfinal;
}
}
//TODO ------------------------------------------------- Fetch --------------------------
async fetchlog(url, fonction) {
await axios
.get(url)
.then(async function (response) {
data = await response.data;
fetchloguer();
if (fonction) {
fonction();
} // handle success
})
.catch(function (error) {
// handle error
console.log("Il y a eu une erreur dans le fetchlog : " + error);
return;
})
.then(function () {
return data;
});
}
//TODO ------------------------------------------------- get (fetch) --------------------------
async get(url) {
return axios
.get(url)
.then((response) => {
return response.data;
})
.catch((error) => {
console.log("Il y eu une erreur =>" + error);
});
}
//TODO ------------------------------------------------- post (fetch) --------------------------
async post(url, data) {
return new Promise((resolve, reject) => {
axios
.post(url, data)
.then((response) => {
resolve(response.data);
})
.catch((error) => {
console.log("Il y a eu une erreur =>" + error);
reject(error);
});
});
}
//TODO ------------------------------------------------- Lire fichier txt --------------------------
logtxt(fichier, copie, nomdelacopie) {
fs.readFile(__dirname + `/${fichier}.txt`, (err, data) => {
let datafichier = data.toString();
if (err) {
console.log("le fichier n'a pas été lu : " + err);
return;
}
console.log(`contenu du fichier => ${fichier}.txt = ` + datafichier);
if (copie === true) {
if (nomdelacopie) {
fs.writeFile(`${nomdelacopie}.txt`, data, function name(params) {
console.log(`copie du fichier ${fichier}.txt => ${nomdelacopie}.txt`);
/* callback will go here */
});
} else {
fs.writeFile(`copie.txt`, data, function name(params) {
console.log("copie du fichier sous le nom : copie.txt");
/* callback will go here */
});
}
}
return datafichier;
});
}
//TODO ------------------------------------------------- Créer fichier txt --------------------------
creertxt(nom, contenu) {
fs.writeFile(`${nom}.txt`, contenu, { flag: "a+" }, (err) => {
if (err) {
console.error("Il y a eu un soucis avec la création du fichier => :" + err);
return;
}
console.log(`Le fichier ${nom}.txt à été créé avec le contenu suivant => ${contenu}`);
});
}
//TODO ------------------------------------------------- Couleur aléatoire Css --------------------------
csscolor() {
let r = function () {
return Math.floor(Math.random() * 256);
};
return "rgb(" + r() + "," + r() + "," + r() + ")";
}
//TODO ------------------------------------------------- Matos --------------------------
matos(parametre) {
let processeur = os.cpus()[0].model;
let platforme = os.platform();
let architecture = os.arch();
let systeme = () => {
if (os.type() === "Windows_NT") {
return "Windows";
} else if (os.type() === "Darwin") {
return "Mac";
} else if (os.type() === "Linux") {
return "Linux";
} else {
return "Système non reconnu";
}
};
let ram = () => {
let bytes = os.totalmem();
function formatBytes(bytes) {
var marker = 1024; // Change to 1000 if required
var decimal = 3; // Change as required
var kiloBytes = marker; // One Kilobyte is 1024 bytes
var megaBytes = marker * marker; // One MB is 1024 KB
var gigaBytes = marker * marker * marker; // One GB is 1024 MB
var teraBytes = marker * marker * marker * marker; // One TB is 1024 GB
// return bytes if less than a KB
if (bytes < kiloBytes) return bytes + " Bytes";
// return KB if less than a MB
else if (bytes < megaBytes) return (bytes / kiloBytes).toFixed(decimal) + " KB";
// return MB if less than a GB
else if (bytes < gigaBytes) return (bytes / megaBytes).toFixed(decimal) + " MB";
// return GB if less than a TB
else return (bytes / gigaBytes).toFixed(decimal) + " GB";
}
return formatBytes(bytes);
};
if (parametre === "log") {
console.log(`Platforme : ${platforme}`);
console.log(`Architecture : ${architecture}`);
console.log(`Processeur : ${processeur}`);
console.log(`Système : ${systeme()}`);
console.log(`Ram : ${ram()}`);
return;
} else if (parametre === "systeme") {
return systeme();
} else if (parametre === "ram") {
return ram();
} else if (parametre === "processeur") {
return processeur;
} else if (parametre === "plateforme") {
return platforme;
} else if (parametre === "architecture") {
return architecture;
}
}
//TODO ------------------------------------------------- recupnb --------------------------
recupnb(string, transformer) {
let tab = [];
let number = "";
for (let i = 0; i < string.length; i++) {
if (string[i].match(/^[0-9]+$/)) {
tab.push(string[i]);
}
}
tab.forEach((element) => {
number = number + element;
});
if (transformer === "transformer") {
let number2;
number2 = parseInt(number);
return number2;
}
return number;
}
//TODO ------------------------------------------------- moyenne --------------------------
moyenne(nb1, nb2, nb3, nb4, nb5, nb6, nb7, nb8, nb9, nb10) {
let tabnb = [];
tabnb.push(nb1, nb2);
if (nb3) {
tabnb.push(nb3);
}
if (nb4) {
tabnb.push(nb4);
}
if (nb5) {
tabnb.push(nb5);
}
if (nb6) {
tabnb.push(nb5);
}
if (nb7) {
tabnb.push(nb5);
}
if (nb8) {
tabnb.push(nb5);
}
if (nb9) {
tabnb.push(nb5);
}
if (nb10) {
tabnb.push(nb5);
}
let somme = 0;
let quantity = tabnb.length;
for (let nb of tabnb) {
somme += parseFloat(nb);
}
let resultat = somme / quantity;
return Math.round(resultat * 100) / 100;
}
//TODO ------------------------------------------------- big moyenne --------------------------
bigmoyenne(tableau) {
let somme = 0;
let quantity = tableau.length;
for (let nb of tableau) {
somme += parseFloat(nb);
}
let resultat = somme / quantity;
return Math.round(resultat * 100) / 100;
}
//TODO ------------------------------------------------- SMIC --------------------------
salaireSMIC(heures, option, log) {
let salairenet = heures * 8.6 * (52 / 12);
salairenet = Math.round(salairenet * 1) / 1;
let salairebrut = heures * 10.85 * (52 / 12);
salairebrut = Math.round(salairebrut * 1) / 1;
if (option === "net" && !log) {
return salairenet;
} else if (option === "brut" && !log) {
return salairebrut;
}
if (log === "log" && option === "net") {
console.log(`Pour ${heures} heures, le salaire sera de ${salairenet} euros (Net)`);
return salairenet;
}
if (log === "log" && option === "brut") {
console.log(`Pour ${heures} heures, le salaire sera de ${salairebrut} euros (Brut)`);
return salairebrut;
}
}
//TODO ------------------------------------------------- recupsommeObjet --------------------------
recupsommeObjet(objet, option) {
let tab = [];
let somme = 0;
if (option === "string") {
for (const [key, value] of Object.entries(objet)) {
tab.push(value);
}
return tab.join(" ");
} else if (option === "number") {
for (const [key, value] of Object.entries(objet)) {
if (typeof value === "number") {
tab.push(value);
}
}
tab.forEach((element) => {
somme += element;
});
return somme;
}
}
//TODO ------------------------------------------------- compareTAB --------------------------
compareTAB(tab1, tab2, option) {
let resultat;
if (JSON.stringify(tab1) === JSON.stringify(tab2)) {
if (option === "log") {
console.log("Vrai, les tableaux sont identiques");
}
return (resultat = true);
} else {
if (option === "log") {
console.log("Faux, les tableaux ne sont pas identiques");
}
return (resultat = false);
}
}
//TODO ------------------------------------------------- objetAdd --------------------------
objetAdd(nompropriete, value, objetamodifier) {
Reflect.set(objetamodifier, nompropriete, value);
}
//TODO ------------------------------------------------- fusionObjet --------------------------
fusionObjet(objet1, objet2, objet3, objet4, objet5, objet6, objet7, objet8, objet9, objet10) {
let objetfinal;
if (objet3 && !objet4 && !objet5 && !objet6 && !objet7 && !objet8 && !objet9 && !objet10) {
console.log("objet3");
objetfinal = {
...objet1,
...objet2,
...objet3,
};
} else if (objet3 && objet4 && !objet5 && !objet6 && !objet7 && !objet8 && !objet9 && !objet10) {
console.log("objet4");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
};
} else if (objet3 && objet4 && objet5 && !objet6 && !objet7 && !objet8 && !objet9 && !objet10) {
console.log("objet5");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
};
} else if (objet3 && objet4 && objet5 && objet6 && !objet7 && !objet8 && !objet9 && !objet10) {
console.log("objet6");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
...objet6,
};
} else if (objet3 && objet4 && objet5 && objet6 && objet7 && !objet8 && !objet9 && !objet10) {
console.log("objet7");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
...objet6,
...objet7,
};
} else if (objet3 && objet4 && objet5 && objet6 && objet7 && objet8 && !objet9 && !objet10) {
console.log("objet8");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
...objet6,
...objet7,
...objet8,
};
} else if (objet3 && objet4 && objet5 && objet6 && objet7 && objet8 && objet9 && !objet10) {
console.log("objet9");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
...objet6,
...objet7,
...objet8,
...objet9,
};
} else if (objet3 && objet4 && objet5 && objet6 && objet7 && objet8 && objet9 && objet10) {
console.log("objet10");
objetfinal = {
...objet1,
...objet2,
...objet3,
...objet4,
...objet5,
...objet6,
...objet7,
...objet8,
...objet9,
...objet10,
};
} else {
objetfinal = {
...objet1,
...objet2,
};
}
return objetfinal;
}
//TODO ------------------------------------------------- pourcent --------------------------
pourcent(valeurmax, indice, option) {
let valeur = valeurmax;
let indicevaleur = indice;
let pourcentage;
let pourcentagestring;
if (option) {
if (option === "string") {
pourcentagestring = parseInt((indicevaleur / valeur) * 100) + "%";
return pourcentagestring;
} else if (option === "log") {
pourcentage = parseInt((indicevaleur / valeur) * 100);
console.log(`${indicevaleur} représente ${pourcentage}% de ${valeurmax}(100%)`);
}
}
pourcentage = parseInt((indicevaleur / valeur) * 100);
return pourcentage;
}
//TODO ------------------------------------------------- ristournePourcent --------------------------
ristournePourcent(prix, ristourne, log) {
let reduction = (prix * ristourne) / 100;
let prixreduit = prix - reduction;
prixreduit = parseFloat(prixreduit.toFixed(2));
if (log) {
console.log(`La ristourne à réduit le prix initial de ${prix} à ${prixreduit} !`);
}
return prixreduit;
}
//TODO ----------------------------------------------------------- trierNUm ----------------------
trierNum(tab, option, log) {
let tabtrie = tab.sort((a, b) => a - b);
if (option === "croissant") {
if (log) {
console.log(tabtrie);
}
return tabtrie;
}
if (option === "décroissant") {
if (log) {
console.log(tabtrie.reverse());
}
return tabtrie.reverse();
}
if (option != "croissant" || option != "décroissant") {
console.log('Vous devez choisir une option ("croissant" ou "décroissant")');
}
}
//TODO ----------------------------------------------------------- sansDoublon ----------------------
sansDoublon(tab, log) {
let tabsansdoublon = [...new Set(tab)];
if (log) {
console.log(tabsansdoublon);
}
return tabsansdoublon;
}
//TODO ----------------------------------------------------------- serveur ----------------------
serveur(port, fonction) {
let self = this;
let pointeur = server.listen(process.env.PORT || port, function initialisation() {
console.log(`Genius Serveur ouvert sur le port ${port} le ${self.date()} à ${self.heure()}`);
console.log(`Pour les fichiers statiques, un dossier "public" est déclaré par défaut`);
console.log(`"/" renvoi à "public/index.html s'il existe`);
if (fonction) {
fonction();
}
});
return pointeur;
}
//TODO ----------------------------------------------------------- serveurSTOP ----------------------
serveurSTOP(fonction) {
if (fonction) {
fonction();
}
console.log("Genius Serveur Arrêté");
server.close();
}
//TODO ----------------------------------------------------------- serveurRequeteGET ----------------------
serveurRequeteGET(adresse, middleware) {
app.get(adresse, middleware, (req, res) => {
return;
});
}
//TODO ----------------------------------------------------------- serveurRequetePOST ----------------------
serveurRequetePOST(adresse, middleware) {
app.post(adresse, middleware, (req, res) => {
return;
});
}
//TODO ----------------------------------------------------------- serveurStatique ----------------------
serveurStatique(chemin) {
app.use(express.static(chemin));
}
serveurApp() {
return app;
}
//TODO ----------------------------------------------------------- serveurStatique ----------------------
hash(pass, clef) {
const crypto = require("crypto");
const hash = crypto.createHmac("sha256", pass).update(clef).digest("hex");
return hash;
}
//todo FIN DE LA CLASSE
};