628 lines
24 KiB
JavaScript
628 lines
24 KiB
JavaScript
var profiles = []
|
|
var selfID;
|
|
var selfWebsocket,followingWebSockets = [];
|
|
var privKey;
|
|
var following;
|
|
|
|
function userDataStartUp(){
|
|
console.log("StartUp");
|
|
|
|
/*document.getElementById("sendMsgInput").addEventListener("keyup",function(event){
|
|
if(event.keyCode === 13){
|
|
event.preventDefault();
|
|
sendMsg();
|
|
}
|
|
});*/
|
|
|
|
getDatafromAPI().then(function (result) {
|
|
console.log(result);
|
|
getProfilesfromIDB().then(function (result){
|
|
profiles = arrayToObject(result);
|
|
console.log(profiles);
|
|
sessionStorage.profiles = JSON.stringify(profiles);
|
|
getSuperNodeListfromIDB().then(function(result){
|
|
console.log(result)
|
|
superNodeList = result;
|
|
kBucketObj.launchKBucket().then(function(result){
|
|
console.log(result)
|
|
getuserID().then(function(result){
|
|
console.log(result);
|
|
selfID = result;
|
|
if(superNodeList.includes(selfID))
|
|
modSuperNode = true;
|
|
sessionStorage.privKey = JSON.stringify(encrypt.createShamirsSecretShares(privKey,10,10));
|
|
sessionStorage.selfID = selfID;
|
|
alert(`${selfID}\nWelcome ${profiles[selfID].name}`)
|
|
initselfWebSocket();
|
|
listProfiles();
|
|
getFollowinglistFromIDB().then(function(result){
|
|
following = result;
|
|
if(!following.includes(selfID))
|
|
following.push(selfID);
|
|
console.log(following);
|
|
displayTweetsFromIDB().then(function(result){
|
|
connectToAllFollowing();
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
})
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
})
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
});
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
|
|
}
|
|
|
|
function storedata(data){
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
console.log("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction('profiles', "readwrite").objectStore('profiles');
|
|
objectRequest = obs.put(data);
|
|
objectRequest.onerror = function(event) {
|
|
reject(Error('Error occured: Unable to store data'));
|
|
};
|
|
|
|
objectRequest.onsuccess = function(event) {
|
|
resolve('Data saved OK');
|
|
db.close();
|
|
};
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function getDatafromAPI(){
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var addr = adminID;
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onupgradeneeded = function(event) {
|
|
var db = event.target.result;
|
|
var objectStore0 = event.target.result.createObjectStore("superNodes");
|
|
var objectStore1 = db.createObjectStore("profiles",{ keyPath: 'floID' });
|
|
objectStore1.createIndex('onionAddr', 'onionAddr', { unique: false });
|
|
objectStore1.createIndex('name', 'name', { unique: false });
|
|
objectStore1.createIndex('pubKey', 'pubKey', { unique: false });
|
|
var objectStore2 = db.createObjectStore("lastTx");
|
|
var objectStore3 = db.createObjectStore("tweets",{ keyPath: 'tweetID' });
|
|
objectStore3.createIndex('tid', 'tid', { unique: false });
|
|
objectStore3.createIndex('floID', 'floID', { unique: false });
|
|
objectStore3.createIndex('time', 'time', { unique: false });
|
|
objectStore3.createIndex('data', 'data', { unique: false });
|
|
var objectStore4 = db.createObjectStore("lastTweet");
|
|
var objectStore5 = db.createObjectStore("followers");
|
|
var objectStore6 = db.createObjectStore("following");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
//window["wait"] = addrList.length;
|
|
var lastTx = db.transaction('lastTx', "readwrite").objectStore('lastTx');
|
|
//addrList.forEach(function(addr){
|
|
console.log(addr);
|
|
new Promise(function(res,rej){
|
|
var lastTxReq = lastTx.get(addr);
|
|
lastTxReq.onsuccess = function(event){
|
|
var lasttx = event.target.result;
|
|
if(lasttx === undefined){
|
|
lasttx = 0;
|
|
}
|
|
res(lasttx);
|
|
}
|
|
}).then(function(lasttx){
|
|
var response = ajax("GET",`api/addrs/${addr}/txs`);
|
|
var nRequired = JSON.parse(response).totalItems - lasttx;
|
|
console.log(nRequired);
|
|
while(true && nRequired){
|
|
var response = ajax("GET",`api/addrs/${addr}/txs?from=0&to=${nRequired}`);
|
|
response = JSON.parse(response);
|
|
if (nRequired + lasttx != response.totalItems ){
|
|
nRequired = response.totalItems - lasttx;
|
|
continue;
|
|
}
|
|
response.items.reverse().forEach(function(tx){
|
|
try {
|
|
if (tx.vin[0].addr == addr){
|
|
var data = JSON.parse(tx.floData).FLO_Tweet_SuperNode;
|
|
if(data !== undefined){
|
|
storeSuperNodeData(data).then(function (response) {
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
}
|
|
}else{
|
|
var data = JSON.parse(tx.floData).FLO_Tweet;
|
|
if(data !== undefined){
|
|
if(encrypt.getFLOIDfromPubkeyHex(data.pubKey)!=tx.vin[0].addr)
|
|
throw("PublicKey doesnot match with floID")
|
|
data = {floID : tx.vin[0].addr, onionAddr : data.onionAddr, name : data.name, pubKey:data.pubKey};
|
|
storedata(data).then(function (response) {
|
|
}).catch(function (error) {
|
|
console.log(error.message);
|
|
});
|
|
}
|
|
}
|
|
} catch (e) {
|
|
//console.log(e)
|
|
}
|
|
});
|
|
|
|
var obs = db.transaction('lastTx', "readwrite").objectStore('lastTx');
|
|
obs.put(response.totalItems,addr);
|
|
break;
|
|
}
|
|
db.close();
|
|
resolve('retrived data from API');
|
|
});
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function storeSuperNodeData(data){
|
|
return new Promise(
|
|
function(resolve, reject) {
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction('superNodes', "readwrite").objectStore('superNodes');
|
|
if(data.addNodes)
|
|
for(var i=0; i<data.addNodes.length; i++)
|
|
obs.add(true,data.addNodes[i])
|
|
if(data.removeNodes)
|
|
for(var i=0; i<data.removeNodes.length; i++)
|
|
obs.delete(data.removeNodes[i])
|
|
db.close();
|
|
resolve('Updated superNodes list in IDB');
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function getSuperNodeListfromIDB(){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("superNodes", "readwrite").objectStore("superNodes");
|
|
var getReq = obs.getAllKeys();
|
|
getReq.onsuccess = function(event){
|
|
resolve(event.target.result);
|
|
}
|
|
getReq.onerror = function(event){
|
|
reject('Unable to read superNode list!')
|
|
}
|
|
db.close();
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function getuserID(){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
privKey = (sessionStorage.privKey !== undefined ? encrypt.retrieveShamirSecret(JSON.parse(sessionStorage.privKey)):prompt("Enter FLO Private Key : "));
|
|
var key = new Bitcoin.ECKey(privKey);
|
|
while(key.priv == null){
|
|
privKey = prompt("Invalid FLO Private Key! Retry : ")
|
|
key = Bitcoin.ECKey(privKey);
|
|
}
|
|
key.setCompressed(true);
|
|
var userID = key.getBitcoinAddress();
|
|
if (profiles[userID] === undefined)
|
|
var reg = confirm(`${userID} is not registers to FLO Tweet!\nRegister FLO ID to this onion?`);
|
|
else if (profiles[userID].onionAddr == window.location.host)
|
|
resolve(userID)
|
|
else
|
|
var reg = confirm(`${userID} is registered to another onion!\nChange to this onion?`);
|
|
|
|
if(reg){
|
|
var name = prompt("Enter your name :");
|
|
var pubKey = key.getPubKeyHex();
|
|
if(registerID(userID,window.location.host,privKey,pubKey,name)){
|
|
profiles[userID] = {onionAddr : window.location.host, name : name, pubKey : pubKey};
|
|
resolve(userID);
|
|
}
|
|
}
|
|
reject(`Unable to bind ${userID} to this onionAddress!\nTry again later!`);
|
|
}
|
|
);
|
|
}
|
|
|
|
function getProfilesfromIDB(){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("profiles", "readwrite").objectStore("profiles");
|
|
var getReq = obs.getAll();
|
|
getReq.onsuccess = function(event){
|
|
resolve(event.target.result);
|
|
}
|
|
getReq.onerror = function(event){
|
|
reject('Unable to read profiles!')
|
|
}
|
|
db.close();
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function initselfWebSocket(){
|
|
selfWebsocket = new WebSocket("ws://"+location.host+"/ws");
|
|
selfWebsocket.onopen = function(evt){
|
|
console.log("Connecting");
|
|
var pass = (sessionStorage.serverPass !== undefined ? encrypt.retrieveShamirSecret(JSON.parse(sessionStorage.serverPass)): prompt("Enter server password :"));
|
|
selfWebsocket.send("$"+pass);
|
|
sessionStorage.serverPass = JSON.stringify(encrypt.createShamirsSecretShares(pass,5,5));
|
|
};
|
|
selfWebsocket.onclose = function(evt){
|
|
console.log("DISCONNECTED");
|
|
};
|
|
selfWebsocket.onmessage = function(evt){
|
|
console.log(evt.data);
|
|
if(evt.data == "$Access Denied!"){
|
|
var pass = prompt("Access Denied! reEnter server password :");
|
|
selfWebsocket.send("$"+pass);
|
|
sessionStorage.serverPass = JSON.stringify(encrypt.createShamirsSecretShares(pass,5,5));
|
|
}else if(evt.data == "$Access Granted!")
|
|
alert("Access Granted!")
|
|
else{
|
|
try{
|
|
data = JSON.parse(evt.data);
|
|
if(data.follow && encrypt.verify(selfID, data.sign, profiles[data.floID].pubKey)){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("followers", "readwrite").objectStore("followers");
|
|
obs.add(data.sign,data.floID);
|
|
db.close();
|
|
};
|
|
selfWebsocket.send(`F${data.floID}`);
|
|
}else if(data.unfollow && encrypt.verify(selfID, data.sign, profiles[data.floID].pubKey)){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("followers", "readwrite").objectStore("followers");
|
|
obs.delete(data.floID);
|
|
db.close();
|
|
};
|
|
selfWebsocket.send(`U${data.floID}`);
|
|
}else if(data.fromSuperNode && following.includes(data.floID)){
|
|
var tid = data.tid;
|
|
data = JSON.parse(data.data);
|
|
if(encrypt.verify(data.tweet,data.sign,profiles[data.floID].pubKey)){
|
|
storeTweet({floID:data.floID,time:data.time,data:data.tweet},tid);
|
|
createTweetElement(data.floID,data.time,data.tweet);
|
|
}
|
|
}else if(modSuperNode){
|
|
if(data.reqNewTweets){
|
|
kBucketObj.determineClosestSupernode(data.floID).then(result=>{
|
|
if(result[0].floID == selfID)
|
|
SuperNode_sendTweetsFromIDB(data.floID,data.tid,data.requestor);
|
|
}).catch(e => {
|
|
console.log(e.message);
|
|
});
|
|
}else if(data.newSuperNodeTweet){
|
|
kBucketObj.determineClosestSupernode(data.floID).then(result=>{
|
|
if(result[0].floID == selfID)
|
|
storeSuperNodeTweet(data.data,data.tid);
|
|
}).catch(e => {
|
|
console.log(e.message);
|
|
});
|
|
}
|
|
}
|
|
}catch(error){
|
|
console.log(error.message);
|
|
}
|
|
}
|
|
};
|
|
selfWebsocket.onerror = function(evt){
|
|
console.log(evt);
|
|
};
|
|
}
|
|
|
|
function postTweet(){
|
|
var tweetBox = document.getElementById("tweetBox");
|
|
var tweet = tweetBox.value;
|
|
tweetBox.value = "";
|
|
var time = (new Date).getTime();
|
|
var sign = encrypt.sign(tweet,privKey);
|
|
var data = JSON.stringify({floID:selfID,time:time,tweet:tweet,sign:sign});
|
|
console.log(data);
|
|
selfWebsocket.send(data);
|
|
getLastTweetCount(selfID).then(function(result){
|
|
sendTweetToSuperNode(data,result+1);
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
});
|
|
}
|
|
|
|
function storeTweet(data,tid){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
console.log("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("tweets", "readwrite").objectStore("tweets");
|
|
data.tweetID = `${data.time}_${data.floID}`;
|
|
data.tid = tid;
|
|
obs.add(data);
|
|
var obsL = db.transaction("lastTweet", "readwrite").objectStore("lastTweet");
|
|
obsL.put(tid,data.floID);
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
function sendTweetToSuperNode(data,tid){
|
|
kBucketObj.determineClosestSupernode(selfID).then(result=>{
|
|
var superNodeWS = new WebSocket("ws://"+profiles[result[0].floID].onionAddr+"/ws");
|
|
superNodeWS.onopen = function(ev){
|
|
console.log(`Connected to self SuperNode!`);
|
|
data = JSON.stringify({newSuperNodeTweet:true,floID:selfID,tid:tid,data:data})
|
|
console.log(data)
|
|
superNodeWS.send(data);
|
|
};
|
|
superNodeWS.onerror = function(ev) {console.log(`self SuperNode is offline!`);};
|
|
superNodeWS.onclose = function(ev) {console.log(`Disconnected from self SuperNode!`);};
|
|
}).catch(e => {
|
|
console.log(e.message);
|
|
});
|
|
}
|
|
|
|
function getFollowinglistFromIDB(){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("following", "readwrite").objectStore("following");
|
|
var getReq = obs.getAllKeys();
|
|
getReq.onsuccess = function(event){
|
|
resolve(event.target.result);
|
|
}
|
|
getReq.onerror = function(event){
|
|
reject('Unable to read following list!')
|
|
}
|
|
db.close();
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function displayTweetsFromIDB(){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("tweets", "readwrite").objectStore("tweets");
|
|
var curReq = obs.openCursor();
|
|
curReq.onsuccess = function(event) {
|
|
var cursor = event.target.result;
|
|
if(cursor) {
|
|
//console.log(cursor.value)
|
|
if(cursor.value.floID == selfID || following.includes(cursor.value.floID))
|
|
createTweetElement(cursor.value.floID,cursor.value.time,cursor.value.data);
|
|
cursor.continue();
|
|
}else{
|
|
resolve("Displayed Tweets from IDB!");
|
|
}
|
|
}
|
|
curReq.onerror = function(event){
|
|
reject("Error in Reading tweets from IDB!");
|
|
}
|
|
db.close();
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function createTweetElement(floID,time,tweet){
|
|
var tweetDisplay = document.getElementById("tweetsContainer");
|
|
var element = document.createElement("div");
|
|
element.setAttribute("class", "media");
|
|
element.innerHTML = `
|
|
<div class="media-body">
|
|
<h4 class="media-heading">${profiles[floID].name} <small>@${floID}</small></h4>
|
|
<p>${tweet}</p>
|
|
<ul class="nav nav-pills nav-pills-custom">
|
|
<li><a href="#"><span class="glyphicon glyphicon-share-alt"></span></a></li>
|
|
<li><a href="#"><span class="glyphicon glyphicon-retweet"></span></a></li>
|
|
<li><a href="#"><span class="glyphicon glyphicon-star"></span></a></li>
|
|
<li><a href="#"><span class="glyphicon glyphicon-option-horizontal"></span></a></li>
|
|
<li><span class="timestamp pull-right">${getTime(time)}</span></li>
|
|
</ul>
|
|
</div>`;
|
|
tweetDisplay.insertBefore(element, tweetDisplay.firstChild);
|
|
}
|
|
|
|
function connectToAllFollowing(){
|
|
console.log("Connecting to All following servers...")
|
|
following.forEach(floid => {
|
|
console.log(floid)
|
|
followingWebSockets[floid] = new WebSocket("ws://"+profiles[floid].onionAddr+"/ws");
|
|
|
|
followingWebSockets[floid].onopen = function(ev){
|
|
console.log(`Connected to ${floid} Server!`);
|
|
getLastTweetCount(floid).then(function(result){
|
|
followingWebSockets[floid].send(`>${result}`);
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
});
|
|
};
|
|
followingWebSockets[floid].onerror = function(ev) {
|
|
console.log(`${floid} Server is offline!`);
|
|
//Ping SuperNode for any new tweets
|
|
pingSuperNodeforNewTweets(floid);
|
|
|
|
};
|
|
followingWebSockets[floid].onclose = function(ev) {
|
|
console.log(`Disconnected from ${floid} Server!`);
|
|
};
|
|
followingWebSockets[floid].onmessage = function(evt){
|
|
console.log(evt.data);
|
|
try{
|
|
var data = JSON.parse(evt.data);
|
|
var id = data.id;
|
|
data = data.data;
|
|
if( floid!=data.floID || !encrypt.verify(data.tweet,data.sign,profiles[floid].pubKey))
|
|
return
|
|
storeTweet({floID:data.floID,time:data.time,data:data.tweet},id);
|
|
createTweetElement(data.floID,data.time,data.tweet);
|
|
}catch(error){
|
|
console.log(error.message);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
function getLastTweetCount(floid){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var lastTweet = db.transaction('lastTweet', "readwrite").objectStore('lastTweet');
|
|
var lastTweetReq = lastTweet.get(floid);
|
|
lastTweetReq.onsuccess = function(event){
|
|
var result = event.target.result;
|
|
if(result === undefined)
|
|
result = 0;
|
|
resolve(result);
|
|
}
|
|
db.close();
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
function pingSuperNodeforNewTweets(floID){
|
|
kBucketObj.determineClosestSupernode(floID).then(result=>{
|
|
var superNodeWS = new WebSocket("ws://"+profiles[result[0].floID].onionAddr+"/ws");
|
|
superNodeWS.onopen = function(ev){
|
|
console.log(`Connected to ${floID}'s SuperNode!`);
|
|
getLastTweetCount(floID).then(function(result){
|
|
var data = JSON.stringify({reqNewTweets:true,floID:floID,tid:result,requestor:selfID})
|
|
superNodeWS.send(data);
|
|
}).catch(function(error){
|
|
console.log(error.message);
|
|
});
|
|
};
|
|
superNodeWS.onerror = function(ev) {console.log(`${floid}'s SuperNode is offline!`);};
|
|
superNodeWS.onclose = function(ev) {console.log(`Disconnected from ${floid}'s SuperNode!`);};
|
|
}).catch(e => {
|
|
console.log(e.message);
|
|
});
|
|
}
|
|
|
|
function storeSuperNodeTweet(data,tid){
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = function(event) {
|
|
console.log("Error in opening IndexedDB!");
|
|
};
|
|
idb.onupgradeneeded = function(event){
|
|
var objectStore = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore.createIndex('floID', 'floID', { unique: false });
|
|
objectStore.createIndex('tid', 'tid', { unique: false });
|
|
objectStore.createIndex('data', 'data', { unique: false });
|
|
}
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
|
|
var parsedData = JSON.parse(data);
|
|
var tweetID = ''+parsedData.floID+'_'+parsedData.time;
|
|
obs.add({tweetID:tweetID,floID:parsedData.floID,tid:tid,data:data});
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
function SuperNode_sendTweetsFromIDB(floID,tid,requestor){
|
|
return new Promise(
|
|
function(resolve,reject){
|
|
var requestorWS = new WebSocket("ws://"+profiles[requestor].onionAddr+"/ws");
|
|
|
|
requestorWS.onopen = function(ev){
|
|
console.log(`sending ${floID} tweets to ${requestor} Server!`);
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = function(event) {
|
|
reject("Error in opening IndexedDB!");
|
|
};
|
|
idb.onupgradeneeded = function(event){
|
|
var objectStore = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore.createIndex('floID', 'floID', { unique: false });
|
|
objectStore.createIndex('tid', 'tid', { unique: false });
|
|
objectStore.createIndex('data', 'data', { unique: false });
|
|
}
|
|
idb.onsuccess = function(event) {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
|
|
var curReq = obs.openCursor();
|
|
curReq.onsuccess = function(event) {
|
|
var cursor = event.target.result;
|
|
if(cursor) {
|
|
if(cursor.value.floID == floID && cursor.value.tid > tid){
|
|
data = JSON.stringify({fromSuperNode:true, floID:cursor.value.floID,tid:cursor.value.tid,data:cursor.value.data})
|
|
requestorWS.send(data);
|
|
}
|
|
cursor.continue();
|
|
}else{
|
|
resolve("Displayed Tweets from IDB!");
|
|
}
|
|
}
|
|
curReq.onerror = function(event){
|
|
reject("Error in Reading tweets from IDB!");
|
|
}
|
|
db.close();
|
|
};
|
|
};
|
|
requestorWS.onerror = function(ev) {
|
|
console.log(`${requestor} Server is offline!`);
|
|
};
|
|
requestorWS.onclose = function(ev) {
|
|
console.log(`Disconnected from ${requestor} Server!`);
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|