660 lines
22 KiB
JavaScript
Executable File
660 lines
22 KiB
JavaScript
Executable File
// pour "configurer" le lecteur nfc
|
|
// ouvrir le fichier: sudo nano /usr/lib/pcsc/drivers/ifd-ccid.bundle/Contents/Info.plist (pour pi)
|
|
// localiser la ligne <key>ifdDriverOptions</key>,
|
|
// la ligne suivante vaux <string>0x0000</string>,
|
|
// modifier la <string>0x0001</string>,
|
|
// sauvegarder le fichier et redémarer pcscd(sudo service pcscd restart)
|
|
// même action pour le fichier sudo nano /usr/lib/pcsc/drivers/ifd-acsccid.bundle/Contents/Info.plist (pour desktop)
|
|
|
|
let script, ip, memSudoMdp = '', etatUrl = 0
|
|
let TAB = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '!', '#', '$', '%', '&', '?','0','1','2','3','4','5','6','7','8','9'];
|
|
let max_TAB = TAB.length - 1
|
|
let donneesFichierConfiguration = {}
|
|
// type de lecteur nfc
|
|
const typeLecteurNfc = 'vma405'
|
|
// dev = 1 = mode développement
|
|
let dev = 1
|
|
|
|
// nfc
|
|
const vma405Emitter = require('./vma405.js')
|
|
|
|
const os = require('os')
|
|
const hostname= os.hostname()
|
|
|
|
const { spawn, exec } = require('child_process')
|
|
const IP = require('ip')
|
|
const path = require('path')
|
|
const fs = require('fs')
|
|
// serveur http
|
|
const http = require('http')
|
|
// const ADR = '192.168.1.32'
|
|
const ADR = '127.0.0.1'
|
|
const PORT = 3000
|
|
const TOKEN = '$a;b2yuM5454@4!cd'
|
|
// retour = null = aucune demande de lecture de carte nfc
|
|
let retour = null
|
|
let client_globale = null
|
|
let fichier = '', contentType = ''
|
|
|
|
/**
|
|
* retourne l'ip
|
|
* @param {string|'public'|'private'} typeReseau
|
|
* @param {String|'ipv4'|'ipv6'} famille
|
|
* @returns {string}
|
|
*/
|
|
function obtenirIp(typeReseau, famille){
|
|
ip = IP.address(typeReseau, famille)
|
|
let retour = "erreur"
|
|
if (ip !== "127.0.0.1" && ip !== "0.0.0.0") {
|
|
retour = ip
|
|
}
|
|
return retour
|
|
}
|
|
|
|
// --- nfc ---
|
|
vma405Emitter.on('tagId', (tagId) => {
|
|
if (retour !== null){
|
|
retour['tagId'] = tagId.toUpperCase()
|
|
client_globale.emit('envoieTagId',retour)
|
|
console.log('--> demande carte, envoi tag id = ' + tagId.toUpperCase())
|
|
retour = null
|
|
} else {
|
|
// console.log('-> Aucune demande, carte :' + card.uid.toString().toUpperCase())
|
|
console.log('-> Aucune demande, carte :' + tagId.toUpperCase())
|
|
if (client_globale !== null) {
|
|
client_globale.emit('infosTagId', tagId.toUpperCase())
|
|
}
|
|
}
|
|
})
|
|
|
|
vma405Emitter.on('msgVma405', (msg) => {
|
|
console.log('msgVma405 =', msg)
|
|
})
|
|
|
|
|
|
|
|
// --- commandes système ---
|
|
/** @function
|
|
* Obtenir ip extérieur (wan/box)
|
|
*/
|
|
function obtenirIpWan() {
|
|
const prog = spawn('curl', ['ifconfig.me'])
|
|
prog.stdout.on('data', (data) => {
|
|
prog.resultatRequete = data.toString()
|
|
})
|
|
|
|
prog.on('close', (code) => {
|
|
if (code === 0 ){
|
|
// ok: ip = prog.resultatRequete
|
|
} else {
|
|
// erreur
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Obtenir des données de configuration d'un fichier (.chromium_env)
|
|
* @param {Array} rechercher - liste des varaibles à rechercher ddans le fichier
|
|
* @param {String} fichier - nom du fichier à lire
|
|
* @returns {{msg, erreur: number}|{valeurs: {}, erreur: number}}
|
|
*/
|
|
function obtenirConfigurationDunFichier(rechercher,fichier) {
|
|
try {
|
|
const fic = fs.readFileSync(fichier, {encoding:'utf8', flag:'r'}).split('\n')
|
|
let obj = {}
|
|
for (let index = 0; index < fic.length; index++) {
|
|
let ligne = fic[index].toString()
|
|
if (ligne.length > 0 && ligne[0] !== '#' && ligne.indexOf('=') !== -1) {
|
|
let tab = ligne.split('=')
|
|
for ( let im in rechercher) {
|
|
mot = rechercher[im]
|
|
if (mot === (tab[0].trim())) {
|
|
obj[tab[0].trim()] = tab[1].trim()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return {erreur: 0, valeurs: obj}
|
|
} catch (error) {
|
|
return {erreur:1 , msg: error}
|
|
}
|
|
}
|
|
|
|
function afficherInfoServeur(donnees){
|
|
// console.log('-> fonction afficherInfoServeur !')
|
|
// console.log('donnees = ', donnees)
|
|
if (donnees.erreur === 0) {
|
|
let bruteUrl = donnees.valeurs.url
|
|
let posDeuxSlashs = bruteUrl.indexOf('//') + 2
|
|
let posFinDomaine = bruteUrl.indexOf('/wv/login_hardware')
|
|
let domaine = bruteUrl.substring(posDeuxSlashs,posFinDomaine)
|
|
let onclique = ''
|
|
if (donnees.valeurs.front_type === "FPI") {
|
|
onclique = `onclick="clavierVirtuel.obtPosition('serveur');clavierVirtuel.afficher('serveur', 'alpahMin')"`
|
|
}
|
|
let fronts = ['FPI', 'FOR']
|
|
let options = ''
|
|
for (let i = 0; i < fronts.length; i++) {
|
|
let sel = ''
|
|
console.log(`${ i} -> ${ fronts[i] } -- ${ donnees.valeurs.front_type }`)
|
|
if (fronts[i] === donnees.valeurs.front_type) {
|
|
sel = 'selected'
|
|
}
|
|
options += `<option value="${ fronts[i]}" ${ sel }>${ fronts[i]}</option>`
|
|
}
|
|
return `
|
|
<div id="info-serveur" class="BF-ligne-deb l100p item-info" data-url-serveur="${ bruteUrl }" data-serveur="${ domaine }">Serveur: ${ domaine }</div>
|
|
|
|
<div class="BF-ligne-deb l100p">
|
|
<div id="bt-tester-serveur" class="bt bt-250px fond-ok curseur-action">
|
|
<div class="md4px">Tester Serveur</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="BF-ligne-deb item-info l100p">
|
|
<div id="bt-modifier-serveur" class="bt bt-250px fond-alerte curseur-action">
|
|
<div class="md4px">Modifier Serveur</div>
|
|
<div id="etat-modifier-serveur" class="mod-serveur-ok"></div>
|
|
</div>
|
|
</div>
|
|
|
|
<div id="modifier-serveur" class="contenu-form eff p4px fond-header l100p">
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="serveur" class="serveur-label">Serveur</label>
|
|
<input type="text" id="serveur" class="input-pour-pi" name="serveur" value="${ domaine }" ${ onclique } required>
|
|
</div>
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="nom-appareil" class="mod-wifi-label">APPAREIL</label>
|
|
<input type="text" id="nom-appareil" class="input-pour-pi" name="nom-appareil" value="${ os.hostname() }" disabled>
|
|
</div>
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="passe" class="mod-wifi-label">GENERER MOT DE PASSE</label>
|
|
<input type="checkbox" id="passe" name="passe" >
|
|
</div>
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="type-front" class="mod-wifi-label">FRONT</label>
|
|
<select id="type-front" class="input-pour-pi">${ options }</select>
|
|
</div>
|
|
<div class="BF-ligne">
|
|
<div id="bt-valider-modifier-serveur" class="bt bt-valider fond-ok coulBlanc curseur-action">Valider</div>
|
|
</div>
|
|
</div>
|
|
`
|
|
} else {
|
|
return `
|
|
<div class="BF-ligne-deb item-info l100p">Erreur</div>
|
|
<div class="item-info">donnees.msg</div>
|
|
`
|
|
}
|
|
}
|
|
|
|
/** @function
|
|
* Teste l'url avec curl
|
|
* @param {Sring} url - url à tester
|
|
* @param {Number} nbMaxStderr - nombre maxi d'évènement Stderr avant de sortir de la fonction
|
|
*/
|
|
function testUrl(url, nbMaxStderr) {
|
|
console.log(`-> fonction testUrl, url = ->${ url }<-`)
|
|
const prog = spawn('curl', ['-I', url])
|
|
prog.nbMaxStderr = nbMaxStderr
|
|
prog.nbStderr = 0
|
|
prog.resultatRequete = "404"
|
|
etatUrl = 0
|
|
prog.stdout.on('data', (data) => {
|
|
let premiereLigne = data.toString().split('\n')[0]
|
|
prog.resultatRequete = premiereLigne.split(' ')[1]
|
|
})
|
|
|
|
prog.stderr.on('data', (data) => {
|
|
prog.nbStderr ++
|
|
if(prog.nbStderr === prog.nbMaxStderr) {
|
|
prog.kill()
|
|
}
|
|
})
|
|
|
|
prog.on('close', (code) => {
|
|
// header 307 = redirection temporaire
|
|
// header 308 = redirection permanente
|
|
console.log('réponse test serveur = ', prog.resultatRequete)
|
|
if(prog.resultatRequete === '200' || prog.resultatRequete === '307' || prog.resultatRequete === '308') {
|
|
etatUrl = 1
|
|
}
|
|
client_globale.emit('etatUrlServeur', prog.resultatRequete)
|
|
})
|
|
}
|
|
|
|
|
|
function modifierConfigurationWifi(data) {
|
|
console.log('-> fonction modifierConfigurationWifi !')
|
|
console.log('data = ', data)
|
|
let template = `country=FR
|
|
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
|
|
update_config=1
|
|
network={
|
|
ssid="${ data.essid }"
|
|
psk="${ data.passePhrase }"
|
|
scan_ssid=1
|
|
}
|
|
`
|
|
try {
|
|
fs.writeFileSync("/etc/wpa_supplicant/wpa_supplicant.conf", template, {flag: "w"})
|
|
client_globale.emit('modificationWifi', {
|
|
erreur: 0,
|
|
msg: `
|
|
<div class="l100p h100p BF-col">
|
|
<h1>Modification wifi effectuée,</h1>
|
|
<h1>réseau = ${ data.essid }</h1>
|
|
<h1>Redémmarer l'appareil ! </h1>
|
|
</div>
|
|
`
|
|
})
|
|
} catch (erreur) {
|
|
client_globale.emit('modificationWifi', {
|
|
erreur: 1,
|
|
msg: `
|
|
<h1>Erreur configuration wifi</h1>
|
|
<h2>${ erreur }</h2>
|
|
`
|
|
})
|
|
}
|
|
}
|
|
|
|
function afficherInfosWifi() {
|
|
// console.log('-> fonction afficherInfosWifi !')
|
|
const prog = spawn('iwconfig', [])
|
|
prog.stdout.on('data', (data) => {
|
|
let lignes = data.toString().split('\n')
|
|
for (let i = 0; i < lignes.length; i++) {
|
|
let ligne = lignes[i]
|
|
if (ligne.indexOf('ESSID') !== -1) {
|
|
let tmpData = ligne.split(':')
|
|
let etatWifi = 'on'
|
|
let essid = ''
|
|
if (tmpData[1].includes('off')){
|
|
etatWifi = 'off'
|
|
} else {
|
|
essid = tmpData[1].trim().replace(/"/g, '')
|
|
}
|
|
let tmpData2 = ligne.split(' ')
|
|
prog.resultat = {interface: tmpData2[0], etat: etatWifi, essid: essid}
|
|
break
|
|
}
|
|
}
|
|
})
|
|
|
|
prog.on('close', (code) => {
|
|
if (code === 0) {
|
|
// wifi actif
|
|
// if (prog.resultat.etat === 'on' && donneesFichierConfiguration.erreur === 0) {
|
|
// uniquement sur pi
|
|
if (donneesFichierConfiguration.valeurs.front_type === "FPI") {
|
|
let onclique = ''
|
|
// if (donneesFichierConfiguration.valeurs.front_type === "FPI") {
|
|
oncliqueEssid = `onclick="clavierVirtuel.obtPosition('essid');clavierVirtuel.afficher('essid', 'alpahMin')"`
|
|
oncliquePasse = `onclick="clavierVirtuel.obtPosition('pp');clavierVirtuel.afficher('pp', 'alpahMin')"`
|
|
// }
|
|
|
|
let fragHtml = `
|
|
<div id="info-essid" class="BF-ligne-deb item-info l100p">Ssid: ${ prog.resultat.essid }</div>
|
|
<div class="BF-ligne-deb item-info l100p">
|
|
<div id="bt-modifier-wifi" class="bt bt-250px fond-alerte curseur-action">
|
|
<div class="md4px">Modifier Wifi</div>
|
|
<div id="etat-modifier-wifi" class="mod-wifi-ok"></div>
|
|
</div>
|
|
</div>
|
|
<div id="modifier-wifi" class="contenu-form eff p4px fond-header l100p">
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="essid" class="mod-wifi-label">RESEAU:</label>
|
|
<input type="text" id="essid" class="input-pour-pi" name="essid" ${ oncliqueEssid } required>
|
|
</div>
|
|
<div class="BF-ligne-deb mb8px">
|
|
<label for="pp" class="mod-wifi-label">MOT DE PASSE:</label>
|
|
<input type="password" id="pp" class="input-pour-pi" name="pp" ${ oncliquePasse } required>
|
|
</div>
|
|
<div class="BF-ligne">
|
|
<div id="bt-valider-modifier-wifi" class="bt bt-valider fond-ok coulBlanc curseur-action">Valider</div>
|
|
</div>
|
|
</div>
|
|
`
|
|
client_globale.emit('retourInfosWifi', fragHtml)
|
|
}
|
|
// }
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Lancer chromium
|
|
* @param {Number|1|2} - etape
|
|
*/
|
|
function lancerChromium(etape, dataFichier) {
|
|
console.log('-> fonction lancerChromium !')
|
|
|
|
let optionsChromium = [], msgErreur = ''
|
|
console.log('dataFichier = ', dataFichier)
|
|
if (dataFichier.erreur === 0) {
|
|
data = dataFichier.valeurs
|
|
} else {
|
|
msgErreur = dataFichier.msg
|
|
}
|
|
|
|
if (msgErreur === '') {
|
|
if (etape === 1) {
|
|
// dev
|
|
if (dev === 1) {
|
|
optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--remote-debugging-port=9222', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', 'http://127.0.0.1:3000']
|
|
} else {
|
|
// prod
|
|
optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', 'http://127.0.0.1:3000']
|
|
}
|
|
} else {
|
|
// dev
|
|
console.log('-> etape 2, url = ', data.url)
|
|
if (dev === 1) {
|
|
optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--remote-debugging-port=9222', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', data.url]
|
|
} else {
|
|
// prod
|
|
optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', data.url]
|
|
}
|
|
|
|
}
|
|
|
|
// mode kiosk uniquement pi
|
|
if (data.front_type === "FPI") {
|
|
optionsChromium.push('--kiosk')
|
|
}
|
|
|
|
if (msgErreur === '') {
|
|
const userAgent = `{"hostname":"${data.hostname}", "token": "${data.token}", "password":"${data.password}","modeNfc":"${data.mode_nfc}","front":"${data.front_type}","ip":"${obtenirIp('public', 'ipv4')}"}`
|
|
console.log('userAgent = ', userAgent)
|
|
|
|
optionsChromium.push(`--user-agent=${userAgent}`)
|
|
console.log('optionsChromium = ', optionsChromium)
|
|
|
|
// Lance chromium
|
|
const demChromium = spawn('chromium-browser', optionsChromium)
|
|
|
|
demChromium.stdout.on('data', (data) => {
|
|
console.log(`demChromium - stdout: ${data}`)
|
|
});
|
|
|
|
demChromium.stderr.on('data', (data) => {
|
|
console.error(`demChromium - stderr: ${data}`)
|
|
})
|
|
|
|
demChromium.on('close', (code) => {
|
|
console.log(`demChromium - child process exited with code ${code}`)
|
|
if (code === 0) {
|
|
console.log('--> Chromium démarrer !')
|
|
}
|
|
})
|
|
}
|
|
} else {
|
|
console.log('Erreur: ', msgErreur)
|
|
}
|
|
}
|
|
|
|
function lancerApplication(){
|
|
console.log('-> fonction lancerApplication !')
|
|
const dataConf = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
|
|
if (dataConf.erreur === 0) {
|
|
let prog
|
|
if (dataConf.valeurs.front_type === "FPI") {
|
|
prog = spawn('pkill', ['chromium'])
|
|
} else {
|
|
prog = spawn('pkill', ['chrome'])
|
|
}
|
|
|
|
prog.stdout.on('data', (data) => {
|
|
console.log('stdout: ', data.toString())
|
|
})
|
|
|
|
prog.stderr.on('data', (data) => {
|
|
console.log('stderr: ', data.toString())
|
|
})
|
|
|
|
prog.on('close', (code) => {
|
|
if (code === 0) {
|
|
console.log('--> Chromium arrêter !')
|
|
const dataFichier = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
|
|
lancerChromium(2, dataFichier)
|
|
}
|
|
})
|
|
} else {
|
|
console.log('Erreur: ', dataConf.msg)
|
|
}
|
|
}
|
|
|
|
function afficherFrontType() {
|
|
console.log('-> fonction afficherFrontType !')
|
|
console.log('donneesFichierConfiguration = ', donneesFichierConfiguration)
|
|
if (donneesFichierConfiguration.erreur === 0) {
|
|
return donneesFichierConfiguration.valeurs.front_type
|
|
} else {
|
|
return 'inconnu'
|
|
}
|
|
}
|
|
function rnd(min, max) {
|
|
return Math.round(Math.random() * ((max+1) - min) + min,0);
|
|
}
|
|
|
|
function generer_mot_de_passe(longueur) {
|
|
let mot = '';
|
|
let lettre = TAB[rnd(0,max_TAB)];
|
|
for(let i=0;i<(longueur);i++){
|
|
|
|
while (mot.indexOf(lettre)!=-1) {
|
|
lettre = TAB[rnd(0,59)];
|
|
}
|
|
mot += lettre;
|
|
}
|
|
return mot
|
|
}
|
|
|
|
function modifierConfigurationServeur(data) {
|
|
// console.log('-> fonction modifierConfigurationServeur !')
|
|
let proto = 'https'
|
|
// Développement serveur = "#serveur.com#", donne un protocol http et serveur = "serveur.com"
|
|
let serveur = data.serveurDomaine.toString()
|
|
// console.log('0 = ',serveur[0], ' -- dernier = ',serveur[(serveur.length-1)])
|
|
if (serveur[0] === '#' && serveur[(serveur.length-1)] === '#') {
|
|
proto = 'http'
|
|
serveur = data.serveurDomaine.toString().substring(1,(serveur.length-1))
|
|
}
|
|
|
|
donnees = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
|
|
if (donnees.erreur === 0) {
|
|
let motDePasse = generer_mot_de_passe(16)
|
|
if (data.genererMotDePasse === false) {
|
|
motDePasse = donnees.valeurs.password
|
|
}
|
|
|
|
let template = `#utilisateur
|
|
hostname = ${data.user}
|
|
|
|
#front
|
|
front_type = ${data.typeFront}
|
|
|
|
#url du serveur
|
|
#url = http://django-local.org:8001/wv/login_hardware
|
|
url = ${proto}://${serveur}/wv/login_hardware
|
|
|
|
#mode_nfc = NFCMO
|
|
mode_nfc = ${ donnees.valeurs.mode_nfc }
|
|
|
|
password = ${ motDePasse }
|
|
token = ${ donnees.valeurs.token }
|
|
`
|
|
try {
|
|
fs.writeFileSync(".chromium_env", template)
|
|
client_globale.emit('modificationServeur', {erreur: 0, serveurDomaine: serveur})
|
|
testUrl(serveur, 14)
|
|
redemarrerChromium()
|
|
} catch (error) {
|
|
client_globale.emit('modificationServeur', {erreur: 1})
|
|
}
|
|
} else {
|
|
client_globale.emit('modificationServeur', {erreur: 1})
|
|
}
|
|
}
|
|
|
|
// --- serveur http ---
|
|
let typeMime = {
|
|
"aac":"audio/aac","abw":"application/x-abiword","arc":"application/octet-stream","avi":"video/x-msvideo","azw":"application/vnd.amazon.ebook",
|
|
"bin":"application/octet-stream","bz":"application/x-bzip","bz2":"application/x-bzip2","csh":"application/x-csh","css":"text/css","csv":"text/csv",
|
|
"doc":"application/msword","docx":"application/vnd.openxmlformats-officedocument.wordprocessingml.document","eot":"application/vnd.ms-fontobject",
|
|
"epub":"application/epub+zip","gif":"image/gif","htm":"text/html","html":"text/html","ico":"image/x-icon","ics":"text/calendar","jar":"application/java-archive",
|
|
"jpeg":"image/jpeg","jpeg":"image/jpeg","js":"application/javascript","json":"application/json","mid":"audio/midi","midi":"audio/midi","mpeg":"video/mpeg",
|
|
"mpkg":"application/vnd.apple.installer+xml","odp":"application/vnd.oasis.opendocument.presentation","ods":"application/vnd.oasis.opendocument.spreadsheet",
|
|
"odt":"application/vnd.oasis.opendocument.text","oga":"audio/ogg","ogv":"video/ogg","ogx":"application/ogg","otf":"font/otf","png":"image/png","pdf":"application/pdf",
|
|
"ppt":"application/vnd.ms-powerpoint","pptx":"application/vnd.openxmlformats-officedocument.presentationml.presentation","rar":"application/x-rar-compressed",
|
|
"rtf":"application/rtf","sh":"application/x-sh","svg":"image/svg+xml","swf":"application/x-shockwave-flash","tar":"application/x-tar","tif":"image/tiff",
|
|
"tiff":"image/tiff","ts":"application/typescript","ttf":"font/ttf","vsd":"application/vnd.visio","wav":"audio/x-wav","weba":"audio/webm","webm":"video/webm",
|
|
"webp":"image/webp","woff":"font/woff","woff2":"font/woff2","xhtml":"application/xhtml+xml","xls":"application/vnd.ms-excel",
|
|
"xlsx":"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet","xml":"application/xml","xul":"application/vnd.mozilla.xul+xml","zip":"application/zip",
|
|
"3gp":"video/3gpp audio/3gpp","3g2":"video/3gpp2 audio/3gpp2",
|
|
"7z":"application/x-7z-compressed"
|
|
}
|
|
|
|
let www = process.cwd() + '/www/'
|
|
console.log('www = ', www)
|
|
|
|
function retour404(res){
|
|
res.writeHead(404, {'Content-Type': 'text/html'});
|
|
res.write('Page inconnue !');
|
|
res.end();
|
|
}
|
|
|
|
function renderHtml(contenu, ctx) {
|
|
// let contenuTp1, contenuTp2, contenuTp3, contenuTp4
|
|
contenu = contenu.toString()
|
|
let rendu = contenu.toString().replace(/{{\s*[\w\.]+\s*}}/g, function(match, token) {
|
|
let clef = match.replace(/ /g,'').replace('{{','').replace('}}','')
|
|
console.log('-> match = ', match, ' -- clef = ', clef)
|
|
return ctx[clef]
|
|
})
|
|
contenu = {}
|
|
return rendu
|
|
}
|
|
|
|
// lire la conf. dans le fichier .chromium_env
|
|
donneesFichierConfiguration = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
|
|
|
|
const serveur = http.createServer(function(req, res){
|
|
let url = req.url;
|
|
|
|
// routes
|
|
let ctx = {}
|
|
if(url=='/') {
|
|
url = 'index.html'
|
|
ctx = {
|
|
fontType: afficherFrontType(),
|
|
nomAppareil: os.hostname(),
|
|
afficherInfoServeur: afficherInfoServeur(donneesFichierConfiguration),
|
|
urlServeur: donneesFichierConfiguration.url,
|
|
ip: obtenirIp('public','ipv4'),
|
|
typeLecteurNfc: typeLecteurNfc,
|
|
typeserveurNfc: 'nodejs'
|
|
}
|
|
}
|
|
|
|
if(url=='/favicon.ico') url = 'img/favicon2.ico'
|
|
|
|
fichier = www + url.substring(0,url.length);
|
|
|
|
//assets
|
|
let posDerPoint = url.lastIndexOf('.')
|
|
let extention = ''
|
|
if(posDerPoint != -1){
|
|
extention = url.substring(posDerPoint+1,url.length);
|
|
if(extention.toLowerCase() == 'css') contentType = 'text/css';
|
|
contentType = typeMime[extention.toLowerCase()];
|
|
}
|
|
|
|
try {
|
|
let contenuFichier = fs.readFileSync(fichier)
|
|
|
|
// rendre du html
|
|
if (extention === 'html') {
|
|
contenuFichier = renderHtml(contenuFichier, ctx)
|
|
}
|
|
|
|
res.writeHead(200, {"Content-Type": contentType})
|
|
res.write(contenuFichier)
|
|
res.end();
|
|
console.log('-> url = '+url+' -- fichier :'+fichier+' -- contentType = '+contentType+' -> chargé !');
|
|
} catch (err) {
|
|
console.log('-> url = ' + url + ' -- Erreur: ' + err)
|
|
retour404(res);
|
|
}
|
|
|
|
})
|
|
|
|
// --- socket.io ---
|
|
const options = {
|
|
// allowEIO3: true,
|
|
cors: {
|
|
origin: "*",
|
|
methods: ["PUT", "GET", "POST"]
|
|
}
|
|
}
|
|
const IO = require('socket.io')(serveur,options)
|
|
// middleware
|
|
|
|
IO.use(function(socket, next){
|
|
let token = socket.handshake.query.token
|
|
// console.log('token reçu = '+token+' -- TOKEN = '+TOKEN)
|
|
if (token === TOKEN){
|
|
return next()
|
|
} else {
|
|
next(new Error("ERREUR d'autentification !"))
|
|
}
|
|
})
|
|
|
|
IO.on('connection', client => {
|
|
client_globale = client;
|
|
client_globale.on('demandeTagId', (data) => {
|
|
retour = data;
|
|
console.log('-> demandeTagIdg = '+JSON.stringify(retour))
|
|
})
|
|
|
|
client_globale.on('AnnuleDemandeTagId', () => {
|
|
retour = null
|
|
})
|
|
|
|
client_globale.on('disconnect', () => {
|
|
console.log('Client déconnecté !!')
|
|
})
|
|
|
|
client_globale.on('validerModifierWifi', (data) => {
|
|
modifierConfigurationWifi(data)
|
|
})
|
|
|
|
client_globale.on('validerModifierServeur', (data) => {
|
|
modifierConfigurationServeur(data)
|
|
})
|
|
|
|
|
|
client_globale.on('testerUrlServeur', (urlATester) => {
|
|
console.log('-> test url serveur = ',urlATester)
|
|
testUrl(urlATester, 12)
|
|
})
|
|
|
|
client_globale.on('donnerInfosWifi', () => {
|
|
afficherInfosWifi()
|
|
})
|
|
|
|
client_globale.on('lancerApplication', () => {
|
|
lancerApplication()
|
|
})
|
|
|
|
})
|
|
|
|
// lancement serveur http
|
|
serveur.listen(PORT, ADR, () => {
|
|
console.log(`le serveur écoute http://localhost:${PORT}`)
|
|
})
|
|
|
|
const dataConf = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
|
|
lancerChromium(1,dataConf)
|