1.0.2 Updating to Flocloud v2.1.0a
This commit is contained in:
Vivek Teega
parent
5badbc8979
commit
5e646f1f13
369
index.html
369
index.html
@ -7560,17 +7560,18 @@
|
||||
}
|
||||
}
|
||||
</script>
|
||||
<script id="floBlockchainAPI" version="2.0.1c">
|
||||
<script id="floBlockchainAPI" version="2.1.1a">
|
||||
/* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
|
||||
const floBlockchainAPI = {
|
||||
|
||||
util: {
|
||||
serverList: floGlobals.apiURL[floGlobals.blockchain].slice(0),
|
||||
curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length),
|
||||
fetch_retry: function(apicall) {
|
||||
curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length - 1),
|
||||
fetch_retry: function(apicall, rm_flosight) {
|
||||
return new Promise((resolve, reject) => {
|
||||
this.serverList.splice(this.curPos, 1);
|
||||
this.curPos = floCrypto.randInt(0, this.serverList.length - 1)
|
||||
let i = this.serverList.indexOf(rm_flosight)
|
||||
if (i != -1) this.serverList.splice(i, 1);
|
||||
this.curPos = floCrypto.randInt(0, this.serverList.length - 1);
|
||||
this.fetch_api(apicall)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
@ -7579,30 +7580,35 @@
|
||||
fetch_api: function(apicall) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (this.serverList.length === 0)
|
||||
reject("No floSight server working")
|
||||
reject("No floSight server working");
|
||||
else {
|
||||
fetch(this.serverList[this.curPos] + apicall).then(response => {
|
||||
let flosight = this.serverList[this.curPos];
|
||||
fetch(flosight + apicall).then(response => {
|
||||
if (response.ok)
|
||||
response.json().then(data => resolve(data));
|
||||
else {
|
||||
this.fetch_retry(apicall)
|
||||
this.fetch_retry(apicall, flosight)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
}
|
||||
}).catch(error => {
|
||||
this.fetch_retry(apicall)
|
||||
this.fetch_retry(apicall, flosight)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
})
|
||||
}
|
||||
})
|
||||
},
|
||||
|
||||
current: function() {
|
||||
return this.serverList[this.curPos];
|
||||
}
|
||||
},
|
||||
|
||||
//Promised function to get data from API
|
||||
promisedAPI: function(apicall) {
|
||||
return new Promise((resolve, reject) => {
|
||||
console.log(apicall)
|
||||
//console.log(apicall);
|
||||
this.util.fetch_api(apicall)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
@ -7619,57 +7625,75 @@
|
||||
},
|
||||
|
||||
//Write Data into blockchain
|
||||
writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID) {
|
||||
writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (typeof data != "string")
|
||||
data = JSON.stringify(data);
|
||||
this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data)
|
||||
this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
.catch(error => reject(error));
|
||||
});
|
||||
},
|
||||
|
||||
//Send Tx to blockchain
|
||||
sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '') {
|
||||
sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floCrypto.validateASCII(floData))
|
||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||
if (!floCrypto.validateAddr(senderAddr))
|
||||
reject(`Invalid address : ${senderAddr}`);
|
||||
else if (!floCrypto.validateAddr(senderAddr))
|
||||
return reject(`Invalid address : ${senderAddr}`);
|
||||
else if (!floCrypto.validateAddr(receiverAddr))
|
||||
reject(`Invalid address : ${receiverAddr}`);
|
||||
if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
|
||||
reject("Invalid Private key!");
|
||||
return reject(`Invalid address : ${receiverAddr}`);
|
||||
else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
|
||||
return reject("Invalid Private key!");
|
||||
else if (typeof sendAmt !== 'number' || sendAmt <= 0)
|
||||
reject(`Invalid sendAmt : ${sendAmt}`);
|
||||
else {
|
||||
var trx = bitjs.transaction();
|
||||
var utxoAmt = 0.0;
|
||||
var fee = floGlobals.fee;
|
||||
this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
|
||||
for (var i = utxos.length - 1;
|
||||
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
|
||||
if (utxos[i].confirmations) {
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
|
||||
.scriptPubKey)
|
||||
utxoAmt += utxos[i].amount;
|
||||
} else break;
|
||||
}
|
||||
if (utxoAmt < sendAmt + fee)
|
||||
reject("Insufficient balance!");
|
||||
else {
|
||||
trx.addoutput(receiverAddr, sendAmt);
|
||||
var change = utxoAmt - sendAmt - fee;
|
||||
if (change > 0)
|
||||
trx.addoutput(senderAddr, change);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
var signedTxHash = trx.sign(privKey, 1);
|
||||
this.broadcastTx(signedTxHash)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
}
|
||||
return reject(`Invalid sendAmt : ${sendAmt}`);
|
||||
|
||||
//get unconfirmed tx list
|
||||
this.promisedAPI(`api/addr/${senderAddr}`).then(result => {
|
||||
this.readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
|
||||
let unconfirmedSpent = {};
|
||||
for (let tx of result.items)
|
||||
if (tx.confirmations == 0)
|
||||
for (let vin of tx.vin)
|
||||
if (vin.addr === senderAddr) {
|
||||
if (Array.isArray(unconfirmedSpent[vin.txid]))
|
||||
unconfirmedSpent[vin.txid].push(vin.vout);
|
||||
else
|
||||
unconfirmedSpent[vin.txid] = [vin.vout];
|
||||
}
|
||||
//get utxos list
|
||||
this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
|
||||
//form/construct the transaction data
|
||||
var trx = bitjs.transaction();
|
||||
var utxoAmt = 0.0;
|
||||
var fee = floGlobals.fee;
|
||||
for (var i = utxos.length - 1;
|
||||
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
|
||||
//use only utxos with confirmations (strict_utxo mode)
|
||||
if (utxos[i].confirmations || !strict_utxo) {
|
||||
if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
|
||||
continue; //A transaction has already used this utxo, but is unconfirmed.
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
utxoAmt += utxos[i].amount;
|
||||
};
|
||||
}
|
||||
if (utxoAmt < sendAmt + fee)
|
||||
reject("Insufficient FLO balance!");
|
||||
else {
|
||||
trx.addoutput(receiverAddr, sendAmt);
|
||||
var change = utxoAmt - sendAmt - fee;
|
||||
if (change > 0)
|
||||
trx.addoutput(senderAddr, change);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
var signedTxHash = trx.sign(privKey, 1);
|
||||
this.broadcastTx(signedTxHash)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
});
|
||||
},
|
||||
|
||||
@ -7679,21 +7703,18 @@
|
||||
if (!floCrypto.validateAddr(floID))
|
||||
return reject(`Invalid floID`);
|
||||
if (!floCrypto.verifyPrivKey(privKey, floID))
|
||||
return reject("Invalid Private Key")
|
||||
return reject("Invalid Private Key");
|
||||
if (!floCrypto.validateASCII(floData))
|
||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||
|
||||
var trx = bitjs.transaction();
|
||||
var utxoAmt = 0.0;
|
||||
var fee = floGlobals.fee;
|
||||
this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
|
||||
for (var i = utxos.length - 1; i >= 0; i--) {
|
||||
for (var i = utxos.length - 1; i >= 0; i--)
|
||||
if (utxos[i].confirmations) {
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
|
||||
.scriptPubKey)
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
utxoAmt += utxos[i].amount;
|
||||
}
|
||||
}
|
||||
trx.addoutput(floID, utxoAmt - fee);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
var signedTxHash = trx.sign(privKey, 1);
|
||||
@ -7714,15 +7735,15 @@
|
||||
writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!Array.isArray(senderPrivKeys))
|
||||
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array")
|
||||
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
|
||||
if (!preserveRatio) {
|
||||
let tmp = {};
|
||||
let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
|
||||
senderPrivKeys.forEach(key => tmp[key] = amount);
|
||||
senderPrivKeys = tmp
|
||||
senderPrivKeys = tmp;
|
||||
}
|
||||
if (!Array.isArray(receivers))
|
||||
return reject("Invalid receivers: Receivers must be Array")
|
||||
return reject("Invalid receivers: Receivers must be Array");
|
||||
else {
|
||||
let tmp = {};
|
||||
let amount = floGlobals.sendAmt;
|
||||
@ -7785,9 +7806,8 @@
|
||||
if (!key)
|
||||
invalids.InvalidSenderPrivKeys.push(key);
|
||||
else {
|
||||
if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[
|
||||
key] <= 0)
|
||||
invalids.InvalidSenderAmountFor.push(key)
|
||||
if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
|
||||
invalids.InvalidSenderAmountFor.push(key);
|
||||
else
|
||||
inputVal += senderPrivKeys[key];
|
||||
let floID = floCrypto.getFloID(key);
|
||||
@ -7805,9 +7825,9 @@
|
||||
//Validate the receiver IDs and receive amount
|
||||
for (let floID in receivers) {
|
||||
if (!floCrypto.validateAddr(floID))
|
||||
invalids.InvalidReceiverIDs.push(floID)
|
||||
invalids.InvalidReceiverIDs.push(floID);
|
||||
if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
|
||||
invalids.InvalidReceiveAmountFor.push(floID)
|
||||
invalids.InvalidReceiveAmountFor.push(floID);
|
||||
else
|
||||
outputVal += receivers[floID];
|
||||
}
|
||||
@ -7819,15 +7839,14 @@
|
||||
return reject(invalids);
|
||||
//Reject if given inputVal and outputVal are not equal
|
||||
if (!preserveRatio && inputVal != outputVal)
|
||||
return reject(
|
||||
`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`)
|
||||
return reject(`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`);
|
||||
} catch (error) {
|
||||
return reject(error)
|
||||
}
|
||||
//Get balance of senders
|
||||
let promises = []
|
||||
let promises = [];
|
||||
for (let floID in senders)
|
||||
promises.push(this.getBalance(floID))
|
||||
promises.push(this.getBalance(floID));
|
||||
Promise.all(promises).then(results => {
|
||||
let totalBalance = 0,
|
||||
totalFee = floGlobals.fee,
|
||||
@ -7839,10 +7858,9 @@
|
||||
let insufficient = [];
|
||||
for (let floID in senders) {
|
||||
balance[floID] = parseFloat(results.shift());
|
||||
if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <=
|
||||
totalFee) || (!preserveRatio && balance[floID] < senders[floID]
|
||||
.coins + dividedFee))
|
||||
insufficient.push(floID)
|
||||
if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <= totalFee) ||
|
||||
(!preserveRatio && balance[floID] < senders[floID].coins + dividedFee))
|
||||
insufficient.push(floID);
|
||||
totalBalance += balance[floID];
|
||||
}
|
||||
if (insufficient.length)
|
||||
@ -7854,11 +7872,11 @@
|
||||
for (floID in receivers)
|
||||
totalSendAmt += receivers[floID];
|
||||
if (totalBalance < totalSendAmt)
|
||||
return reject("Insufficient total Balance")
|
||||
return reject("Insufficient total Balance");
|
||||
//Get the UTXOs of the senders
|
||||
let promises = []
|
||||
let promises = [];
|
||||
for (floID in senders)
|
||||
promises.push(this.promisedAPI(`api/addr/${floID}/utxo`))
|
||||
promises.push(this.promisedAPI(`api/addr/${floID}/utxo`));
|
||||
Promise.all(promises).then(results => {
|
||||
let wifSeq = [];
|
||||
var trx = bitjs.transaction();
|
||||
@ -7875,8 +7893,7 @@
|
||||
for (let i = utxos.length - 1;
|
||||
(i >= 0) && (utxoAmt < sendAmt); i--) {
|
||||
if (utxos[i].confirmations) {
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
|
||||
.scriptPubKey)
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
wifSeq.push(wif);
|
||||
utxoAmt += utxos[i].amount;
|
||||
}
|
||||
@ -7906,7 +7923,7 @@
|
||||
return new Promise((resolve, reject) => {
|
||||
var request = new XMLHttpRequest();
|
||||
var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
|
||||
console.log(url)
|
||||
console.log(url);
|
||||
if (signedTxHash.length < 1)
|
||||
reject("Empty Signature");
|
||||
else {
|
||||
@ -7962,28 +7979,26 @@
|
||||
receivedOnly: filters only received data
|
||||
pattern : filters data that with JSON pattern
|
||||
filter : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
|
||||
txid : (boolean) resolve txid or not
|
||||
tx : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
|
||||
sender : flo-id(s) of sender
|
||||
receiver : flo-id(s) of receiver
|
||||
*/
|
||||
readData: function(addr, options = {}) {
|
||||
options.limit = options.limit || 0
|
||||
options.ignoreOld = options.ignoreOld || 0
|
||||
options.limit = options.limit || 0;
|
||||
options.ignoreOld = options.ignoreOld || 0;
|
||||
if (typeof options.sender === "string") options.sender = [options.sender];
|
||||
if (typeof options.receiver === "string") options.receiver = [options.receiver];
|
||||
return new Promise((resolve, reject) => {
|
||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
||||
var newItems = response.totalItems - options.ignoreOld;
|
||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(
|
||||
response => {
|
||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
|
||||
if (options.limit <= 0)
|
||||
options.limit = response.items.length;
|
||||
var filteredData = [];
|
||||
for (i = 0; i < (response.totalItems - options.ignoreOld) &&
|
||||
filteredData.length < options.limit; i++) {
|
||||
for (let i = 0; i < (response.totalItems - options.ignoreOld) && filteredData.length < options.limit; i++) {
|
||||
if (options.pattern) {
|
||||
try {
|
||||
let jsonContent = JSON.parse(response.items[i].floData)
|
||||
let jsonContent = JSON.parse(response.items[i].floData);
|
||||
if (!Object.keys(jsonContent).includes(options.pattern))
|
||||
continue;
|
||||
} catch (error) {
|
||||
@ -8028,7 +8043,16 @@
|
||||
}
|
||||
if (options.filter && !options.filter(response.items[i].floData))
|
||||
continue;
|
||||
filteredData.push(options.txid ? [response.items[i].txid, response.items[i].floData] : response.items[i].floData);
|
||||
|
||||
if (options.tx) {
|
||||
let d = {}
|
||||
d.txid = response.items[i].txid;
|
||||
d.time = response.items[i].time;
|
||||
d.blockheight = response.items[i].blockheight;
|
||||
d.data = response.items[i].floData;
|
||||
filteredData.push(d);
|
||||
} else
|
||||
filteredData.push(response.items[i].floData);
|
||||
}
|
||||
resolve({
|
||||
totalTxs: response.totalItems,
|
||||
@ -8297,7 +8321,7 @@
|
||||
}
|
||||
}
|
||||
</script>
|
||||
<script id="floCloudAPI" version="2.0.2e">
|
||||
<script id="floCloudAPI" version="2.1.0a">
|
||||
/* FLO Cloud operations to send/request application data*/
|
||||
const floCloudAPI = {
|
||||
|
||||
@ -8442,23 +8466,16 @@
|
||||
},
|
||||
|
||||
inactive: new Set(),
|
||||
connect(snID) {
|
||||
|
||||
ws_connect(snID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
return reject(`${snID} is not a supernode`)
|
||||
let inactive = this.inactive
|
||||
if (inactive.has(snID))
|
||||
return reject(`${snID} is not active`)
|
||||
var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/ws");
|
||||
wsConn.onmessage = (evt) => {
|
||||
if (evt.data == '$+')
|
||||
resolve(wsConn)
|
||||
else if (evt.data == '$-') {
|
||||
wsConn.close();
|
||||
inactive.add(snID)
|
||||
reject(`${snID} is not active`)
|
||||
}
|
||||
}
|
||||
var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/");
|
||||
wsConn.onopen = evt => resolve(wsConn);
|
||||
wsConn.onerror = evt => {
|
||||
inactive.add(snID)
|
||||
reject(`${snID} is unavailable`)
|
||||
@ -8466,51 +8483,88 @@
|
||||
})
|
||||
},
|
||||
|
||||
connectActive(snID, reverse = false) {
|
||||
ws_activeConnect(snID, reverse = false) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (this.inactive.size === this.kBucket.SNCO.length)
|
||||
return reject('Cloud offline')
|
||||
return reject('Cloud offline');
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
snID = this.kBucket.closestNode(snID);
|
||||
this.connect(snID)
|
||||
this.ws_connect(snID)
|
||||
.then(node => resolve(node))
|
||||
.catch(error => {
|
||||
if (reverse)
|
||||
var nxtNode = this.kBucket.prevNode(snID);
|
||||
else
|
||||
var nxtNode = this.kBucket.nextNode(snID);
|
||||
this.connectActive(nxtNode, reverse)
|
||||
this.ws_activeConnect(nxtNode, reverse)
|
||||
.then(node => resolve(node))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
})
|
||||
},
|
||||
|
||||
singleRequest: function(floID, data) {
|
||||
fetch_API: function(snID, data) {
|
||||
return new Promise((resolve, reject) => {
|
||||
this.connectActive(floID).then(node => {
|
||||
let randID = floCrypto.randString(5);
|
||||
node.send(`${floID}|${randID}:${JSON.stringify(data)}`);
|
||||
node.onmessage = (evt) => {
|
||||
if (evt.data.startsWith(randID, 1)) {
|
||||
try {
|
||||
let data = JSON.parse(evt.data.substring(42))
|
||||
resolve(data)
|
||||
} catch (error) {
|
||||
reject(evt.data.substring(42))
|
||||
} finally {
|
||||
node.close()
|
||||
}
|
||||
}
|
||||
}
|
||||
}).catch(error => reject(error));
|
||||
});
|
||||
if (this.inactive.has(snID))
|
||||
return reject(`${snID} is not active`);
|
||||
let fetcher, sn_url = "https://" + floGlobals.supernodes[snID].uri;
|
||||
if (typeof data === "string")
|
||||
fetcher = fetch(sn_url + "?" + data);
|
||||
else if (typeof data === "object" && data.method === "POST")
|
||||
fetcher = fetch(sn_url, data);
|
||||
fetcher.then(response => {
|
||||
if (response.ok)
|
||||
resolve(response);
|
||||
else
|
||||
reject(response);
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
liveRequest: function(floID, datareq, callback) {
|
||||
let request = {
|
||||
...datareq.request
|
||||
};
|
||||
fetch_ActiveAPI: function(snID, data, reverse = false) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (this.inactive.size === this.kBucket.SNCO.length)
|
||||
return reject('Cloud offline');
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
snID = this.kBucket.closestNode(snID);
|
||||
this.fetch_API(snID, data)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => {
|
||||
this.inactive.add(snID)
|
||||
if (reverse)
|
||||
var nxtNode = this.kBucket.prevNode(snID);
|
||||
else
|
||||
var nxtNode = this.kBucket.nextNode(snID);
|
||||
this.fetch_ActiveAPI(nxtNode, data, reverse)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
})
|
||||
})
|
||||
},
|
||||
|
||||
singleRequest: function(floID, data_obj, method = "POST") {
|
||||
return new Promise((resolve, reject) => {
|
||||
let data;
|
||||
if (method === "POST")
|
||||
data = {
|
||||
method: "POST",
|
||||
body: JSON.stringify(data_obj)
|
||||
};
|
||||
else
|
||||
data = new URLSearchParams(JSON.parse(JSON.stringify(data_obj))).toString();
|
||||
this.fetch_ActiveAPI(floID, data).then(response => {
|
||||
response.json()
|
||||
.then(result => resolve(this.objectifier(result)))
|
||||
.catch(error => {
|
||||
response.text()
|
||||
.then(result => reject(result)) //Error Message from Node
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
liveRequest: function(floID, request, callback) {
|
||||
const checkFilter = (v, d, r) =>
|
||||
(!r.atVectorClock || r.atVectorClock == v) &&
|
||||
(r.atVectorClock || !r.lowerVectorClock || r.lowerVectorClock <= v) &&
|
||||
@ -8521,25 +8575,20 @@
|
||||
(!r.type || r.type == d.type) &&
|
||||
(!r.senderIDs || r.senderIDs.includes(d.senderID));
|
||||
return new Promise((resolve, reject) => {
|
||||
this.connectActive(floID).then(node => {
|
||||
this.ws_activeConnect(floID).then(node => {
|
||||
let randID = floCrypto.randString(5);
|
||||
node.send(`${floID}|${randID}:${JSON.stringify(datareq)}`);
|
||||
node.send(JSON.stringify(request));
|
||||
node.onmessage = (evt) => {
|
||||
if (evt.data.startsWith(randID, 1))
|
||||
var i = 42
|
||||
else if (evt.data.startsWith(floID, 1))
|
||||
var i = 36
|
||||
else return;
|
||||
let d = e = null;
|
||||
try {
|
||||
let data = JSON.parse(evt.data.substring(i))
|
||||
let filter = {}
|
||||
let data = this.objectifier(JSON.parse(evt.data)),
|
||||
filter = {};
|
||||
for (let v in data)
|
||||
if (checkFilter(v, data[v], request))
|
||||
filter[v] = data[v]
|
||||
d = filter
|
||||
filter[v] = data[v];
|
||||
d = filter;
|
||||
} catch (error) {
|
||||
e = evt.data.substring(i)
|
||||
e = evt.data
|
||||
} finally {
|
||||
callback(d, e)
|
||||
}
|
||||
@ -8585,9 +8634,8 @@
|
||||
floGlobals.appObjects[dataSet[vc].type] = dataSet[vc].message.reset;
|
||||
break;
|
||||
case "UPDATE":
|
||||
if (dataSet[vc].message.update)
|
||||
floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals
|
||||
.appObjects[dataSet[vc].type], message.diff)
|
||||
if (dataSet[vc].message.diff)
|
||||
floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals.appObjects[dataSet[vc].type], dataSet[vc].message.diff)
|
||||
}
|
||||
floGlobals.lastVC[dataSet[vc].type] = vc;
|
||||
updatedObjects.add(dataSet[vc].type)
|
||||
@ -8614,6 +8662,15 @@
|
||||
} catch (error) {
|
||||
console.error(error)
|
||||
}
|
||||
},
|
||||
|
||||
objectifier: function(data) {
|
||||
if (!Array.isArray(data))
|
||||
data = [data];
|
||||
return Object.fromEntries(data.map(d => {
|
||||
d.message = this.decodeMessage(d.message);
|
||||
return [d.vectorClock, d];
|
||||
}));
|
||||
}
|
||||
},
|
||||
|
||||
@ -8634,12 +8691,8 @@
|
||||
.map(d => data[d]).join("|")
|
||||
data.sign = floCrypto.signData(hashcontent, myPrivKey)
|
||||
this.util.singleRequest(data.receiverID, data)
|
||||
.then(result => {
|
||||
data.message = message
|
||||
resolve({
|
||||
[result.vectorClock]: data
|
||||
})
|
||||
}).catch(error => reject(error))
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
@ -8657,30 +8710,24 @@
|
||||
atVectorClock: options.atVectorClock || undefined,
|
||||
mostRecent: options.mostRecent || undefined,
|
||||
}
|
||||
var datareq = {
|
||||
time: Date.now(),
|
||||
request
|
||||
}
|
||||
|
||||
if (options.callback instanceof Function) {
|
||||
let callback = (d, e) => {
|
||||
for (let v in d)
|
||||
d[v].message = this.util.decodeMessage(d[v].message)
|
||||
options.callback(d, e)
|
||||
}
|
||||
this.util.liveRequest(request.receiverID, datareq, callback)
|
||||
this.util.liveRequest(request.receiverID, request, options.callback)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
} else {
|
||||
this.util.singleRequest(request.receiverID, datareq).then(data => {
|
||||
for (let v in data)
|
||||
data[v].message = this.util.decodeMessage(data[v].message)
|
||||
resolve(data)
|
||||
}).catch(error => reject(error))
|
||||
if (options.method === "POST")
|
||||
request = {
|
||||
time: Date.now(),
|
||||
request
|
||||
};
|
||||
this.util.singleRequest(request.receiverID, request, options.method || "GET")
|
||||
.then(data => resolve(data)).catch(error => reject(error))
|
||||
}
|
||||
})
|
||||
},
|
||||
|
||||
//delete data from supernode cloud (received only)
|
||||
//(NEEDS UPDATE) delete data from supernode cloud (received only)
|
||||
deleteApplicationData: function(vectorClocks, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var delreq = {
|
||||
@ -8706,7 +8753,7 @@
|
||||
})
|
||||
},
|
||||
|
||||
//edit comment of data in supernode cloud (mutable comments only)
|
||||
//(NEEDS UPDATE) edit comment of data in supernode cloud (mutable comments only)
|
||||
editApplicationData: function(vectorClock, newComment, oldData, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let p0
|
||||
@ -8868,7 +8915,7 @@
|
||||
if (!conn)
|
||||
return reject('Request not found')
|
||||
conn.onclose = evt => {
|
||||
delete this.util.liveRequest[requestID]
|
||||
delete this.util.liveRequest[requestID];
|
||||
resolve('Request connection closed')
|
||||
}
|
||||
conn.close()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user