294 lines
15 KiB
HTML
Executable File
294 lines
15 KiB
HTML
Executable File
<html>
|
|
|
|
<head>
|
|
<title>FLO webApp Server</title>
|
|
<script id="onLoadStartUp">
|
|
function onLoadStartUp() {
|
|
const apps = ['TEST_MODE']
|
|
webAppServer.setServeAppList(apps)
|
|
var consoleClear = setInterval(console.clear, 60 * 60000) // clear console every 1 hr
|
|
webAppServer.initWebSocket()
|
|
.then(result => console.log(result))
|
|
.catch(error => console.error(error))
|
|
}
|
|
</script>
|
|
</head>
|
|
|
|
</html>
|
|
|
|
<body onload="onLoadStartUp()">
|
|
<script id="compactIDB">
|
|
/* Compact IndexedDB operations */
|
|
|
|
window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
|
window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
|
|
window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
|
|
|
|
if (!window.indexedDB)
|
|
window.alert("Your browser doesn't support a stable version of IndexedDB.")
|
|
|
|
const compactIDB = {
|
|
|
|
setDefaultDB: function (dbName) {
|
|
this.dbName = dbName;
|
|
},
|
|
|
|
initDB: function (dbName, objectStores = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
this.dbName = this.dbName || dbName;
|
|
var idb = indexedDB.open(dbName);
|
|
idb.onerror = (event) => {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onupgradeneeded = (event) => {
|
|
var db = event.target.result;
|
|
for (obs in objectStores) {
|
|
var objectStore = db.createObjectStore(obs, objectStores[obs].options ||
|
|
{});
|
|
if (objectStores[obs].indexes && typeof objectStores[obs].indexes ===
|
|
'object')
|
|
for (i in objectStores[obs].indexes)
|
|
objectStore.createIndex(i, i, objectStores[obs].indexes[i] ||
|
|
{});
|
|
}
|
|
}
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
if (JSON.stringify(Object.values(db.objectStoreNames).sort()) === JSON
|
|
.stringify(Object.keys(
|
|
objectStores).sort()))
|
|
resolve("Initiated IndexedDB");
|
|
else
|
|
reject("IndexedDB already exist with different ObjectStores!");
|
|
db.close();
|
|
}
|
|
});
|
|
},
|
|
|
|
openDB: function (dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
var idb = indexedDB.open(dbName);
|
|
idb.onerror = (event) => reject("Error in opening IndexedDB!");
|
|
idb.onsuccess = (event) => resolve(event.target.result);
|
|
});
|
|
},
|
|
|
|
deleteDB: function (dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
var deleteReq = indexedDB.deleteDatabase(dbName);;
|
|
deleteReq.onerror = (event) => reject("Error deleting database!");
|
|
deleteReq.onsuccess = (event) => resolve("Database deleted successfully");
|
|
});
|
|
},
|
|
|
|
writeData: function (obsName, data, key = false, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
|
let writeReq = (key ? obs.put(data, key) : obs.put(data));
|
|
writeReq.onsuccess = (evt) => resolve(`Write data Successful`);
|
|
writeReq.onerror = (evt) => reject(
|
|
`Write data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
},
|
|
|
|
addData: function (obsName, data, key = false, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
|
let addReq = (key ? obs.add(data, key) : obs.add(data));
|
|
addReq.onsuccess = (evt) => resolve(`Add data successful`);
|
|
addReq.onerror = (evt) => reject(
|
|
`Add data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
},
|
|
|
|
removeData: function (obsName, key, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
|
let delReq = obs.delete(key);
|
|
delReq.onsuccess = (evt) => resolve(`Removed Data ${key}`);
|
|
delReq.onerror = (evt) => reject(
|
|
`Remove data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
},
|
|
|
|
readData: function (obsName, key, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
|
let getReq = obs.get(key);
|
|
getReq.onsuccess = (evt) => resolve(evt.target.result);
|
|
getReq.onerror = (evt) => reject(
|
|
`Read data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
},
|
|
|
|
readAllData: function (obsName, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
|
var tmpResult = {}
|
|
let curReq = obs.openCursor();
|
|
curReq.onsuccess = (evt) => {
|
|
var cursor = evt.target.result;
|
|
if (cursor) {
|
|
tmpResult[cursor.primaryKey] = cursor.value;
|
|
cursor.continue();
|
|
} else
|
|
resolve(tmpResult);
|
|
}
|
|
curReq.onerror = (evt) => reject(
|
|
`Read-All data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
},
|
|
|
|
searchData: function (obsName, patternEval, dbName = this.dbName) {
|
|
return new Promise((resolve, reject) => {
|
|
this.openDB(dbName).then(db => {
|
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
|
var filteredResult = {}
|
|
let curReq = obs.openCursor();
|
|
curReq.onsuccess = (evt) => {
|
|
var cursor = evt.target.result;
|
|
if (cursor) {
|
|
if (patternEval(cursor.primaryKey, cursor.value))
|
|
filteredResult[cursor.primaryKey] = cursor.value;
|
|
cursor.continue();
|
|
} else
|
|
resolve(filteredResult);
|
|
}
|
|
curReq.onerror = (evt) => reject(
|
|
`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
|
);
|
|
db.close();
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
}
|
|
</script>
|
|
<script id="webAppServer">
|
|
const webAppServer = {
|
|
|
|
util: {
|
|
|
|
objectDataFetch(object, path) {
|
|
var pos = object;
|
|
path.forEach(p => pos = pos[p])
|
|
return pos
|
|
},
|
|
|
|
getNextGeneralData: function (generalData, filterStr, vectorClock) {
|
|
var filteredResult = []
|
|
for (var i = 0; i < generalData[filterStr].length; i++)
|
|
if (generalData[filter][i].vectorClock > vectorClock)
|
|
filteredResult.push(generalData[filter][i])
|
|
return filteredResult
|
|
},
|
|
|
|
getFilterString: function(application, type, comment = undefined){
|
|
var filterStr = JSON.stringify({application: application, type: type, comment: comment})
|
|
return filterStr
|
|
}
|
|
|
|
},
|
|
|
|
serveAppList: [],
|
|
|
|
setServeAppList: function(appList = []){
|
|
this.serveAppList = appList
|
|
},
|
|
|
|
initWebSocket: function () {
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
console.log("Attempting to connect to websocket server")
|
|
this.webSocket = new WebSocket("ws://" + location.host + "/ws");
|
|
this.webSocket.onopen = (evt) => {
|
|
console.log("Connected to websocket server")
|
|
this.webSocket.send("$" + location.hash.substr(1));
|
|
};
|
|
this.webSocket.onclose = (evt) => {
|
|
console.log("Disconnected from websocket server");
|
|
this.initWebSocket()
|
|
.then(result => console.log(result))
|
|
.catch(error => console.error(error))
|
|
}
|
|
this.webSocket.onmessage = (evt) => {
|
|
if (evt.data[0] == '$') {
|
|
if (evt.data == '$Access Granted!')
|
|
resolve("Access Granted!");
|
|
else if (evt.data == '$Access Denied!')
|
|
reject("Access Denied!");
|
|
else
|
|
console.log(evt.data.substr(1))
|
|
}
|
|
else if (evt.data[0] == '?') {
|
|
var request = evt.data.substr(1).split(" ");
|
|
var requestor = request[0]
|
|
request = JSON.parse(request[1])
|
|
try{
|
|
if (!this.serveAppList.includes(request[0]))
|
|
throw Error("This application is not served by the webApp")
|
|
|
|
if(request[1] == "appObjects"){
|
|
compactIDB.readData(request[1], request[2], request[0]).then(result => {
|
|
var response = [true, this.util.objectDataFetch(result, request.slice(2))]
|
|
this.webSocket.send(`${requestor} ${JSON.stringify(response)}`)
|
|
})
|
|
}
|
|
else if (request[1] == "generalData"){
|
|
var filterStr = this.util.getFilterString(request[0], request[2])
|
|
compactIDB.readData(request[1], filterStr, request[0]).then(result => {
|
|
var response = [true, this.util.getNextGeneralData(result, filterStr, request[3])]
|
|
this.webSocket.send(`${requestor} ${JSON.stringify(response)}`)
|
|
})
|
|
}
|
|
else if(request[1] == "subAdmins"){
|
|
compactIDB.readAllData(request[1], request[0]).then(result => {
|
|
var response = [true, Object.keys(result)]
|
|
this.webSocket.send(`${requestor} ${JSON.stringify(response)}`)
|
|
})
|
|
}
|
|
else
|
|
throw Error('Invalid Request! Only subAdmins, appObjects and generalData can be requested')
|
|
}catch(error){
|
|
response = [false, error.message]
|
|
this.webSocket.send(`${requestor} ${JSON.stringify(response)}`)
|
|
}
|
|
} else {
|
|
var data = JSON.parse(evt.data)
|
|
if (this.serveAppList.includes(data.application))
|
|
floSupernode.sendData(JSON.stringify(data), data.receiverID)
|
|
.then(result => resolve(result))
|
|
.catch(error => reject(error))
|
|
}
|
|
};
|
|
this.webSocket.onerror = (evt) => {
|
|
reject("Error! Unable to connect websocket server");
|
|
};
|
|
} catch (error) {
|
|
reject(error)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
</script>
|
|
</body>
|