|
|
|
|
@ -0,0 +1,766 @@
|
|
|
|
|
define([
|
|
|
|
|
'/common/userObject.js',
|
|
|
|
|
'/common/migrate-user-object.js',
|
|
|
|
|
'/common/common-hash.js',
|
|
|
|
|
'/common/common-util.js',
|
|
|
|
|
'/common/common-constants.js',
|
|
|
|
|
'/common/common-feedback.js',
|
|
|
|
|
'/common/common-realtime.js',
|
|
|
|
|
'/common/outer/network-config.js',
|
|
|
|
|
|
|
|
|
|
'/bower_components/chainpad-crypto/crypto.js?v=0.1.5',
|
|
|
|
|
'/bower_components/chainpad/chainpad.dist.js',
|
|
|
|
|
'/bower_components/chainpad-listmap/chainpad-listmap.js',
|
|
|
|
|
], function (UserObject, Migrate, Hash, Util, Constants, Feedback, Realtime, NetConfig,
|
|
|
|
|
Crypto, ChainPad, Listmap) {
|
|
|
|
|
var Store = {};
|
|
|
|
|
|
|
|
|
|
var postMessage = function (cmd, data, cb) {};
|
|
|
|
|
var tryParsing = function (x) {
|
|
|
|
|
try { return JSON.parse(x); }
|
|
|
|
|
catch (e) {
|
|
|
|
|
console.error(e);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var storeHash;
|
|
|
|
|
|
|
|
|
|
var store = {};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var onSync = function (cb) {
|
|
|
|
|
Realtime.whenRealtimeSyncs(store.realtime, cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Store.get = function (key, cb) {
|
|
|
|
|
cb({result: Util.find(store.proxy, key)});
|
|
|
|
|
};
|
|
|
|
|
Store.set = function (data, cb) {
|
|
|
|
|
var path = data.key.slice();
|
|
|
|
|
var key = path.pop();
|
|
|
|
|
var obj = Util.find(store.proxy, path);
|
|
|
|
|
if (!obj || typeof(obj) !== "object") { return void cb({error: 'INVALID_PATH'}); }
|
|
|
|
|
obj[key] = data.value;
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.hasSigningKeys = function () {
|
|
|
|
|
if (!store.proxy) { return; }
|
|
|
|
|
return typeof(store.proxy.edPrivate) === 'string' &&
|
|
|
|
|
typeof(store.proxy.edPublic) === 'string';
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.hasCurveKeys = function () {
|
|
|
|
|
if (!store.proxy) { return; }
|
|
|
|
|
return typeof(store.proxy.curvePrivate) === 'string' &&
|
|
|
|
|
typeof(store.proxy.curvePublic) === 'string';
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var getUserChannelList = function () {
|
|
|
|
|
// start with your userHash...
|
|
|
|
|
var userHash = storeHash;
|
|
|
|
|
if (!userHash) { return null; }
|
|
|
|
|
|
|
|
|
|
var userParsedHash = Hash.parseTypeHash('drive', userHash);
|
|
|
|
|
var userChannel = userParsedHash && userParsedHash.channel;
|
|
|
|
|
if (!userChannel) { return null; }
|
|
|
|
|
|
|
|
|
|
var list = store.userObject.getFiles([store.userObject.FILES_DATA]).map(function (id) {
|
|
|
|
|
return Hash.hrefToHexChannelId(store.userObject.getFileData(id).href);
|
|
|
|
|
})
|
|
|
|
|
.filter(function (x) { return x; });
|
|
|
|
|
|
|
|
|
|
// Get the avatar
|
|
|
|
|
var profile = store.proxy.profile;
|
|
|
|
|
if (profile) {
|
|
|
|
|
var profileChan = profile.edit ? Hash.hrefToHexChannelId('/profile/#' + profile.edit) : null;
|
|
|
|
|
if (profileChan) { list.push(profileChan); }
|
|
|
|
|
var avatarChan = profile.avatar ? Hash.hrefToHexChannelId(profile.avatar) : null;
|
|
|
|
|
if (avatarChan) { list.push(avatarChan); }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO
|
|
|
|
|
/*if (store.proxy.friends) {
|
|
|
|
|
var fList = Messaging.getFriendChannelsList(common);
|
|
|
|
|
list = list.concat(fList);
|
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
|
list.push(Util.base64ToHex(userChannel));
|
|
|
|
|
list.sort();
|
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var getCanonicalChannelList = function () {
|
|
|
|
|
return Util.deduplicateString(getUserChannelList()).sort();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
/////////////////////// RPC //////////////////////////////////////
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
Store.arePinsSynced = function (cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
var list = getCanonicalChannelList();
|
|
|
|
|
var local = Hash.hashChannelList(list);
|
|
|
|
|
store.rpc.getServerHash(function (e, hash) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
cb({synced: hash === local});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.resetPins = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
var list = getCanonicalChannelList();
|
|
|
|
|
store.rpc.reset(list, function (e, hash) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
cb({hash: hash});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.pinPads = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
if (typeof(cb) !== 'function') {
|
|
|
|
|
console.error('expected a callback');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
store.rpc.pin(data.pads, function (e, hash) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
cb({hash: hash});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.unpinPads = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
store.rpc.unpin(data.pads, function (e, hash) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
cb({hash: hash});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var account = {};
|
|
|
|
|
|
|
|
|
|
Store.getPinnedUsage = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
store.rpc.getFileListSize(function (err, bytes) {
|
|
|
|
|
if (typeof(bytes) === 'number') {
|
|
|
|
|
account.usage = bytes;
|
|
|
|
|
}
|
|
|
|
|
cb({bytes: bytes});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Update for all users from accounts and return current user limits
|
|
|
|
|
Store.updatePinLimit = function (cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
store.rpc.updatePinLimits(function (e, limit, plan, note) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
account.limit = limit;
|
|
|
|
|
account.plan = plan;
|
|
|
|
|
account.note = note;
|
|
|
|
|
cb(account);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
// Get current user limits
|
|
|
|
|
Store.getPinLimit = function (cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
var ALWAYS_REVALIDATE = true;
|
|
|
|
|
if (ALWAYS_REVALIDATE || typeof(account.limit) !== 'number' ||
|
|
|
|
|
typeof(account.plan) !== 'string' ||
|
|
|
|
|
typeof(account.note) !== 'string') {
|
|
|
|
|
return void store.rpc.getLimit(function (e, limit, plan, note) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
account.limit = limit;
|
|
|
|
|
account.plan = plan;
|
|
|
|
|
account.note = note;
|
|
|
|
|
cb(account);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
cb(account);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.clearOwnedChannel = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
rpc.clearOwnedChannel(data.channel, cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.uploadComplete = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
rpc.uploadComplete(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.uploadStatus = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
rpc.uploadStatus(data.size, cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.uploadCancel = function (data, cb) {
|
|
|
|
|
if (!store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
|
|
|
|
|
rpc.uploadCancel(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.initRpc = function (data, cb) {
|
|
|
|
|
require(['/common/pinpad.js', function (Pinpad) {
|
|
|
|
|
Pinpad.create(store.network, store.proxy, function (e, call) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
|
|
|
|
|
store.rpc = call;
|
|
|
|
|
|
|
|
|
|
common.getPinLimit(function (e, limit, plan, note) {
|
|
|
|
|
if (e) { return void console.error(e); }
|
|
|
|
|
common.account.limit = limit;
|
|
|
|
|
localStorage.plan = common.account.plan = plan;
|
|
|
|
|
common.account.note = note;
|
|
|
|
|
cb();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
common.arePinsSynced(function (err, yes) {
|
|
|
|
|
if (!yes) {
|
|
|
|
|
common.resetPins(function (err) {
|
|
|
|
|
if (err) { return console.error(err); }
|
|
|
|
|
console.log('RESET DONE');
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
////////////////// ANON RPC //////////////////////////////////////
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
Store.anonRpcMsg = function (data, cb) {
|
|
|
|
|
if (!store.anon_rpc) { return void cb({error: 'ANON_RPC_NOT_READY'}); }
|
|
|
|
|
store.anon_rpc.send(data.msg, data.data, cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.getFileSize = function (data, cb) {
|
|
|
|
|
if (!store.anon_rpc) { return void cb({error: 'ANON_RPC_NOT_READY'}); }
|
|
|
|
|
|
|
|
|
|
var channelId = Hash.hrefToHexChannelId(data.href);
|
|
|
|
|
store.anon_rpc.send("GET_FILE_SIZE", channelId, function (e, response) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
if (response && response.length && typeof(response[0]) === 'number') {
|
|
|
|
|
return void cb({size: response[0]});
|
|
|
|
|
} else {
|
|
|
|
|
cb({error: 'INVALID_RESPONSE'});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.getMultipleFileSize = function (data, cb) {
|
|
|
|
|
if (!store.anon_rpc) { return void cb({error: 'ANON_RPC_NOT_READY'}); }
|
|
|
|
|
if (!Array.isArray(data.files)) {
|
|
|
|
|
return void cb({error: 'INVALID_FILE_LIST'});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
store.anon_rpc.send('GET_MULTIPLE_FILE_SIZE', data.files, function (e, res) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
if (res && res.length && typeof(res[0]) === 'object') {
|
|
|
|
|
cb({size: res[0]});
|
|
|
|
|
} else {
|
|
|
|
|
cb({error: 'UNEXPECTED_RESPONSE'});
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.initAnonRpc = function (data, cb) {
|
|
|
|
|
require([
|
|
|
|
|
'/common/rpc.js',
|
|
|
|
|
], function (Rpc) {
|
|
|
|
|
Rpc.createAnonymous(store.network, function (e, call) {
|
|
|
|
|
if (e) { return void cb({error: e}); }
|
|
|
|
|
store.anon_rpc = call;
|
|
|
|
|
cb();
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
/////////////////////// Store ////////////////////////////////////
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
// Get the metadata for sframe-common-outer
|
|
|
|
|
Store.getMetadata = function (data, cb) {
|
|
|
|
|
var metadata = {
|
|
|
|
|
// "user" is shared with everybody via the userlist
|
|
|
|
|
user: {
|
|
|
|
|
name: store.proxy[Constants.displayNameKey],
|
|
|
|
|
uid: store.proxy.uid,
|
|
|
|
|
avatar: Util.find(store.proxy, ['profile', 'avatar']),
|
|
|
|
|
profile: Util.find(store.proxy, ['profile', 'view']),
|
|
|
|
|
curvePublic: store.proxy.curvePublic,
|
|
|
|
|
netfluxId: store.network.webChannels[0].myID
|
|
|
|
|
},
|
|
|
|
|
// "priv" is not shared with other users but is needed by the apps
|
|
|
|
|
priv: {
|
|
|
|
|
edPublic: store.proxy.edPublic,
|
|
|
|
|
friends: store.proxy.friends,
|
|
|
|
|
settings: store.proxy.settings,
|
|
|
|
|
thumbnails: !((store.proxy.settings || {}).general || {}).disableThumbnails
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
cb(JSON.parse(JSON.stringify(metadata)));
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Reset the drive part of the userObject (from settings)
|
|
|
|
|
Store.resetDrive = function (data, cb) {
|
|
|
|
|
store.proxy.drive = store.fo.getStructure();
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* add a "What is CryptPad?" pad in the drive
|
|
|
|
|
* data
|
|
|
|
|
* - driveReadme
|
|
|
|
|
* - driveReadmeTitle
|
|
|
|
|
*/
|
|
|
|
|
Store.createReadme = function (data, cb) {
|
|
|
|
|
require(['/common/cryptget.js'], function (Crypt) {
|
|
|
|
|
var hash = Hash.createRandomHash();
|
|
|
|
|
Crypt.put(hash, data.driveReadme, function (e) {
|
|
|
|
|
if (e) {
|
|
|
|
|
return void cb({ error: "Error while creating the default pad:"+ e});
|
|
|
|
|
}
|
|
|
|
|
var href = '/pad/#' + hash;
|
|
|
|
|
var fileData = {
|
|
|
|
|
href: href,
|
|
|
|
|
title: data.driveReadmeTitle,
|
|
|
|
|
atime: +new Date(),
|
|
|
|
|
ctime: +new Date()
|
|
|
|
|
};
|
|
|
|
|
store.userObject.pushData(fileData, function (e, id) {
|
|
|
|
|
if (e) {
|
|
|
|
|
return void cb({ error: "Error while creating the default pad:"+ e});
|
|
|
|
|
}
|
|
|
|
|
store.userObject.add(id);
|
|
|
|
|
onSync(cb);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Merge the anonymous drive into the user drive at registration
|
|
|
|
|
* data
|
|
|
|
|
* - anonHash
|
|
|
|
|
*/
|
|
|
|
|
Store.migrateAnonDrive = function (data, cb) {
|
|
|
|
|
require(['/common/mergeDrive.js'], function (Merge) {
|
|
|
|
|
var hash = data.anonHash;
|
|
|
|
|
Merge.anonDriveIntoUser(store, hash, cb);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var getAttributeObject = function (attr) {
|
|
|
|
|
if (typeof attr === "string") {
|
|
|
|
|
console.error('DEPRECATED: use setAttribute with an array, not a string');
|
|
|
|
|
return {
|
|
|
|
|
obj: storeObj.settings,
|
|
|
|
|
key: attr
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
if (!Array.isArray(attr)) { throw new Error("Attribute must be string or array"); }
|
|
|
|
|
if (attr.length === 0) { throw new Error("Attribute can't be empty"); }
|
|
|
|
|
var obj = storeObj.settings;
|
|
|
|
|
attr.forEach(function (el, i) {
|
|
|
|
|
if (i === attr.length-1) { return; }
|
|
|
|
|
if (!obj[el]) {
|
|
|
|
|
obj[el] = {};
|
|
|
|
|
}
|
|
|
|
|
else if (typeof obj[el] !== "object") { throw new Error("Wrong attribute"); }
|
|
|
|
|
obj = obj[el];
|
|
|
|
|
});
|
|
|
|
|
return {
|
|
|
|
|
obj: obj,
|
|
|
|
|
key: attr[attr.length-1]
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Set the display name (username) in the proxy
|
|
|
|
|
Store.setDisplayName = function (value, cb) {
|
|
|
|
|
store.proxy[Constants.displayNameKey] = value;
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Settings & pad attributes
|
|
|
|
|
* data
|
|
|
|
|
* - href (String)
|
|
|
|
|
* - attr (Array)
|
|
|
|
|
* - value (String)
|
|
|
|
|
*/
|
|
|
|
|
Store.setPadAttribute = function (data, cb) {
|
|
|
|
|
store.userObject.setPadAttribute(data.href, date.attr, data.value, function () {
|
|
|
|
|
onSync(cb);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
Store.getPadAttribute = function (data, cb) {
|
|
|
|
|
filesOp.getPadAttribute(data.href, data.attr, function (err, val) {
|
|
|
|
|
if (err) { return void cb({error: err}); }
|
|
|
|
|
cb(val);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
Store.setAttribute = function (data, cb) {
|
|
|
|
|
try {
|
|
|
|
|
var object = getAttributeObject(data.attr);
|
|
|
|
|
object.obj[object.key] = data.value;
|
|
|
|
|
} catch (e) { return void cb({error: e}); }
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
Store.getAttribute = function (data, cb) {
|
|
|
|
|
var object;
|
|
|
|
|
try {
|
|
|
|
|
object = getAttributeObject(data.attr);
|
|
|
|
|
} catch (e) { return void cb({error: e}); }
|
|
|
|
|
cb(object.obj[object.key]);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Tags
|
|
|
|
|
Store.listAllTags = function (data, cb) {
|
|
|
|
|
var all = [];
|
|
|
|
|
var files = Util.find(store.proxy, ['drive', 'filesData']);
|
|
|
|
|
|
|
|
|
|
if (typeof(files) !== 'object') { return cb({error: 'invalid_drive'}); }
|
|
|
|
|
Object.keys(files).forEach(function (k) {
|
|
|
|
|
var file = files[k];
|
|
|
|
|
if (!Array.isArray(file.tags)) { return; }
|
|
|
|
|
file.tags.forEach(function (tag) {
|
|
|
|
|
if (all.indexOf(tag) === -1) { all.push(tag); }
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
cb(all);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var makePad = common.makePad = function (href, title) {
|
|
|
|
|
var now = +new Date();
|
|
|
|
|
return {
|
|
|
|
|
href: href,
|
|
|
|
|
atime: now,
|
|
|
|
|
ctime: now,
|
|
|
|
|
title: title || Hash.getDefaultName(Hash.parsePadUrl(href)),
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.addPad = function (data, cb) {
|
|
|
|
|
if (!data.href) { return void cb({error:'NO_HREF'}); }
|
|
|
|
|
var pad = makePad(data.href, data.title);
|
|
|
|
|
store.userObject.pushData(pad, function (e, id) {
|
|
|
|
|
if (e) { return void cb({error: "Error while adding a template:"+ e}); }
|
|
|
|
|
store.userObject.add(id, ['template']);
|
|
|
|
|
onSync(cb);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Templates
|
|
|
|
|
Store.getTemplates = function (data, cb) {
|
|
|
|
|
var templateFiles = filesOp.getFiles(['template']);
|
|
|
|
|
var res = [];
|
|
|
|
|
templateFiles.forEach(function (f) {
|
|
|
|
|
var data = filesOp.getFileData(f);
|
|
|
|
|
res.push(JSON.parse(JSON.stringify(data)));
|
|
|
|
|
});
|
|
|
|
|
return res;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Pads
|
|
|
|
|
Store.moveToTrash = function (data, cb) {
|
|
|
|
|
var href = Hash.getRelativeHref(data.href);
|
|
|
|
|
store.userObject.forget(href);
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
Store.setPadTitle = function (data, cb) {
|
|
|
|
|
var title = data.title;
|
|
|
|
|
var href = data.href;
|
|
|
|
|
var p = Hash.parsePadUrl(href);
|
|
|
|
|
var h = p.hashData;
|
|
|
|
|
|
|
|
|
|
var allPads = Util.find(store.proxy, ['drive', 'filesData']) || {};
|
|
|
|
|
var isStronger;
|
|
|
|
|
|
|
|
|
|
// If we don't find the new channel in our existing pads, we'll have to add the pads
|
|
|
|
|
// to filesData
|
|
|
|
|
var contains;
|
|
|
|
|
|
|
|
|
|
// Update all pads that use the same channel but with a weaker hash
|
|
|
|
|
// Edit > Edit (present) > View > View (present)
|
|
|
|
|
for (var id in allPads) {
|
|
|
|
|
var pad = recent[id];
|
|
|
|
|
if (!pad.href) { continue; }
|
|
|
|
|
|
|
|
|
|
var p2 = Hash.parsePadUrl(pad.href);
|
|
|
|
|
var h2 = p2.hashData;
|
|
|
|
|
|
|
|
|
|
// Different types, proceed to the next one
|
|
|
|
|
// No hash data: corrupted pad?
|
|
|
|
|
if (p.type !== p2.type || !h2) { continue; }
|
|
|
|
|
|
|
|
|
|
var shouldUpdate = p.hash.replace(/\/$/, '') === p2.hash.replace(/\/$/, '');
|
|
|
|
|
|
|
|
|
|
// If the hash is different but represents the same channel, check if weaker or stronger
|
|
|
|
|
if (!shouldUpdate &&
|
|
|
|
|
h.version === 1 && h2.version === 1 &&
|
|
|
|
|
h.channel === h2.channel) {
|
|
|
|
|
// We had view & now we have edit, update
|
|
|
|
|
if (h2.mode === 'view' && h.mode === 'edit') { shouldUpdate = true; }
|
|
|
|
|
// Same mode and we had present URL, update
|
|
|
|
|
else if (h.mode === h2.mode && h2.present) { shouldUpdate = true; }
|
|
|
|
|
// If we're here it means we have a weaker URL:
|
|
|
|
|
// update the date but keep the existing hash
|
|
|
|
|
else {
|
|
|
|
|
pad.atime = +new Date();
|
|
|
|
|
contains = true;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (shouldUpdate) {
|
|
|
|
|
contains = true;
|
|
|
|
|
pad.atime = +new Date();
|
|
|
|
|
pad.title = title;
|
|
|
|
|
|
|
|
|
|
// If the href is different, it means we have a stronger one
|
|
|
|
|
if (href !== pad.href) { isStronger = true; }
|
|
|
|
|
pad.href = href;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isStronger) {
|
|
|
|
|
// If we have a stronger url, remove the possible weaker from the trash.
|
|
|
|
|
// If all of the weaker ones were in the trash, add the stronger to ROOT
|
|
|
|
|
store.userObject.restoreHref(obj.n);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Add the pad if it does not exist in our drive
|
|
|
|
|
if (!contains) {
|
|
|
|
|
Store.addPad({
|
|
|
|
|
href: href,
|
|
|
|
|
title: title
|
|
|
|
|
}, cb);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
onSync(cb);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Filepicker app
|
|
|
|
|
Store.getSecureFilesList = function (query, cb) {
|
|
|
|
|
var list = {};
|
|
|
|
|
var hashes = [];
|
|
|
|
|
var types = query.types;
|
|
|
|
|
var where = query.where;
|
|
|
|
|
var filter = query.filter || {};
|
|
|
|
|
var isFiltered = function (type, data) {
|
|
|
|
|
var filtered;
|
|
|
|
|
var fType = filter.fileType || [];
|
|
|
|
|
if (type === 'file' && fType.length) {
|
|
|
|
|
if (!data.fileType) { return true; }
|
|
|
|
|
filtered = !fType.some(function (t) {
|
|
|
|
|
return data.fileType.indexOf(t) === 0;
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
return filtered;
|
|
|
|
|
};
|
|
|
|
|
store.userObject.getFiles(where).forEach(function (id) {
|
|
|
|
|
var data = store.userObject.getFileData(id);
|
|
|
|
|
var parsed = Hash.parsePadUrl(data.href);
|
|
|
|
|
if ((!types || types.length === 0 || types.indexOf(parsed.type) !== -1) &&
|
|
|
|
|
hashes.indexOf(parsed.hash) === -1 &&
|
|
|
|
|
!isFiltered(parsed.type, data)) {
|
|
|
|
|
hashes.push(parsed.hash);
|
|
|
|
|
list[id] = data;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
cb(list);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Get hashes for the share button
|
|
|
|
|
common.getStrongerHash = function (data, cb) {
|
|
|
|
|
var allPads = Util.find(store.proxy, ['drive', 'filesData']) || {};
|
|
|
|
|
|
|
|
|
|
// If we have a stronger version in drive, add it and add a redirect button
|
|
|
|
|
var stronger = Hash.findStronger(data.href, allPads);
|
|
|
|
|
if (stronger) {
|
|
|
|
|
var parsed2 = Hash.parsePadUrl(stronger);
|
|
|
|
|
return void cb(parsed2.hash);
|
|
|
|
|
}
|
|
|
|
|
cb();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var onReady = function (returned, cb) {
|
|
|
|
|
var proxy = store.proxy;
|
|
|
|
|
var userObject = store.userObject = UserObject.init(proxy.drive, {
|
|
|
|
|
pinPads: function (pads, cb) { Store.pinPads({pads: pads}, cb); },
|
|
|
|
|
loggedIn: store.loggedIn
|
|
|
|
|
});
|
|
|
|
|
var todo = function () {
|
|
|
|
|
fo.fixFiles();
|
|
|
|
|
|
|
|
|
|
Migrate(proxy, Cryptpad);
|
|
|
|
|
|
|
|
|
|
var requestLogin = function () {
|
|
|
|
|
postMessage("REQUEST_LOGIN");
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (store.loggedIn) {
|
|
|
|
|
/* This isn't truly secure, since anyone who can read the user's object can
|
|
|
|
|
set their local loginToken to match that in the object. However, it exposes
|
|
|
|
|
a UI that will work most of the time. */
|
|
|
|
|
|
|
|
|
|
// every user object should have a persistent, random number
|
|
|
|
|
if (typeof(proxy.loginToken) !== 'number') {
|
|
|
|
|
proxy[Constants.tokenKey] = Math.floor(Math.random()*Number.MAX_SAFE_INTEGER);
|
|
|
|
|
}
|
|
|
|
|
returned[Constants.tokenKey] = proxy[Constants.tokenKey];
|
|
|
|
|
|
|
|
|
|
if (store.data.localToken && store.data.localToken !== proxy[tokenKey]) {
|
|
|
|
|
// the local number doesn't match that in
|
|
|
|
|
// the user object, request that they reauthenticate.
|
|
|
|
|
return void requestLogin();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!proxy.settings || !proxy.settings.general ||
|
|
|
|
|
typeof(proxy.settings.general.allowUserFeedback) !== 'boolean') {
|
|
|
|
|
proxy.settings = proxy.settings || {};
|
|
|
|
|
proxy.settings.general = proxy.settings.general || {};
|
|
|
|
|
proxy.settings.general.allowUserFeedback = true;
|
|
|
|
|
}
|
|
|
|
|
returned.feedback = proxy.settings.general.allowUserFeedback;
|
|
|
|
|
|
|
|
|
|
if (typeof(cb) === 'function') { cb(returned); }
|
|
|
|
|
|
|
|
|
|
if (typeof(proxy.uid) !== 'string' || proxy.uid.length !== 32) {
|
|
|
|
|
// even anonymous users should have a persistent, unique-ish id
|
|
|
|
|
console.log('generating a persistent identifier');
|
|
|
|
|
proxy.uid = Hash.createChannelId();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// if the user is logged in, but does not have signing keys...
|
|
|
|
|
if (store.loggedIn && (!Store.hasSigningKeys() ||
|
|
|
|
|
!Store.hasCurveKeys())) {
|
|
|
|
|
return void requestLogin();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
proxy.on('change', [Constants.displayNameKey], function (o, n) {
|
|
|
|
|
if (typeof(n) !== "string") { return; }
|
|
|
|
|
postMessage("UPDATE_METADATA");
|
|
|
|
|
});
|
|
|
|
|
proxy.on('change', ['profile'], function () {
|
|
|
|
|
// Trigger userlist update when the avatar has changed
|
|
|
|
|
postMessage("UPDATE_METADATA");
|
|
|
|
|
});
|
|
|
|
|
proxy.on('change', ['friends'], function () {
|
|
|
|
|
// Trigger userlist update when the friendlist has changed
|
|
|
|
|
postMessage("UPDATE_METADATA");
|
|
|
|
|
});
|
|
|
|
|
proxy.on('change', [Constants.tokenKey], function () {
|
|
|
|
|
postMessage("UPDATE_TOKEN", { data: proxy[Constants.tokenKey] });
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
userObject.migrate(todo);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var connect = function (data, cb) {
|
|
|
|
|
var hash = data.userHash || data.anonHash || Hash.createRandomHash();
|
|
|
|
|
storeHash = hash;
|
|
|
|
|
if (!hash) {
|
|
|
|
|
throw new Error('[Store.init] Unable to find or create a drive hash. Aborting...');
|
|
|
|
|
}
|
|
|
|
|
var secret = Hash.getSecrets('drive', hash);
|
|
|
|
|
var listmapConfig = {
|
|
|
|
|
data: {},
|
|
|
|
|
websocketURL: NetConfig.getWebsocketURL(),
|
|
|
|
|
channel: secret.channel,
|
|
|
|
|
readOnly: false,
|
|
|
|
|
validateKey: secret.keys.validateKey || undefined,
|
|
|
|
|
crypto: Crypto.createEncryptor(secret.keys),
|
|
|
|
|
userName: 'fs',
|
|
|
|
|
logLevel: 1,
|
|
|
|
|
ChainPad: ChainPad,
|
|
|
|
|
classic: true,
|
|
|
|
|
};
|
|
|
|
|
var rt = Listmap.create(listmapConfig);
|
|
|
|
|
store.proxy = rt.proxy,
|
|
|
|
|
store.realtime = rt.realtime;
|
|
|
|
|
store.network = rt.network;
|
|
|
|
|
store.loggedIn = typeof(data.userHash) !== "undefined";
|
|
|
|
|
|
|
|
|
|
var returned = {};
|
|
|
|
|
rt.proxy.on('create', function (info) {
|
|
|
|
|
exp.info = info;
|
|
|
|
|
if (!data.userHash) {
|
|
|
|
|
returned.anonHash = Hash.getEditHashFromKeys(info.channel, secret.keys);
|
|
|
|
|
}
|
|
|
|
|
}).on('ready', function () {
|
|
|
|
|
if (store.userObject) { return; } // the store is already ready, it is a reconnection
|
|
|
|
|
if (!rt.proxy.drive || typeof(rt.proxy.drive) !== 'object') { rt.proxy.drive = {}; }
|
|
|
|
|
var drive = rt.proxy.drive;
|
|
|
|
|
// Creating a new anon drive: import anon pads from localStorage
|
|
|
|
|
if ((!drive[Constants.oldStorageKey] || !Array.isArray(drive[Constants.oldStorageKey]))
|
|
|
|
|
&& !drive['filesData']) {
|
|
|
|
|
drive[Constants.oldStorageKey] = [];
|
|
|
|
|
}
|
|
|
|
|
// Drive already exist: return the existing drive, don't load data from legacy store
|
|
|
|
|
onReady(returned, cb);
|
|
|
|
|
})
|
|
|
|
|
.on('change', ['drive', 'migrate'], function () {
|
|
|
|
|
var path = arguments[2];
|
|
|
|
|
var value = arguments[1];
|
|
|
|
|
if (path[0] === 'drive' && path[1] === "migrate" && value === 1) {
|
|
|
|
|
rt.network.disconnect();
|
|
|
|
|
rt.realtime.abort();
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Data:
|
|
|
|
|
* - userHash or anonHash
|
|
|
|
|
* Todo in cb
|
|
|
|
|
* - LocalStore.setFSHash if needed
|
|
|
|
|
* - sessionStorage.User_Hash
|
|
|
|
|
* - stuff with tokenKey
|
|
|
|
|
* Event to outer
|
|
|
|
|
* - requestLogin
|
|
|
|
|
*/
|
|
|
|
|
var initialized = false;
|
|
|
|
|
Store.init = function (data, callback) {
|
|
|
|
|
if (initialized) {
|
|
|
|
|
return void callback({
|
|
|
|
|
error: 'ALREADY_INIT'
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
initialized = true;
|
|
|
|
|
postMessage = function (cmd, data, cb) {
|
|
|
|
|
setTimeout(function () {
|
|
|
|
|
data.query(cmd, data, cb); // TODO temporary, will be rzplaced by webworker channel
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
connect(data, function (ret) {
|
|
|
|
|
if (Object.keys(store.proxy).length === 1) {
|
|
|
|
|
Feedback.send("FIRST_APP_USE", true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
callback(ret);
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Store.disconnect = function () {
|
|
|
|
|
if (!store.network) { return; }
|
|
|
|
|
store.network.disconnect();
|
|
|
|
|
};
|
|
|
|
|
return Store;
|
|
|
|
|
});
|
yflory
7 years ago