Stackedit/public/res/synchronizer.js

369 lines
13 KiB
JavaScript
Raw Normal View History

2013-05-26 22:59:03 +00:00
define([
"jquery",
2013-05-27 19:45:33 +00:00
"underscore",
2013-05-26 22:59:03 +00:00
"utils",
2013-11-05 23:03:38 +00:00
"storage",
2013-07-30 08:46:36 +00:00
"eventMgr",
2013-06-10 21:22:32 +00:00
"fileSystem",
"fileMgr",
2013-06-22 23:48:57 +00:00
"classes/Provider",
2013-06-10 21:22:32 +00:00
"providers/dropboxProvider",
2013-12-16 00:31:40 +00:00
"providers/gdriveProvider",
2013-12-23 22:40:13 +00:00
"providers/gdrivesecProvider",
"providers/gdriveterProvider"
2013-11-05 23:03:38 +00:00
], function($, _, utils, storage, eventMgr, fileSystem, fileMgr, Provider) {
2013-04-01 16:46:48 +00:00
2013-05-29 19:55:23 +00:00
var synchronizer = {};
2013-04-01 16:46:48 +00:00
2013-05-29 19:55:23 +00:00
// Create a map with providerId: providerModule
var providerMap = _.chain(arguments).map(function(argument) {
2013-06-22 23:48:57 +00:00
return argument instanceof Provider && [
2013-05-29 19:55:23 +00:00
argument.providerId,
argument
];
}).compact().object().value();
2013-04-01 16:46:48 +00:00
2013-11-05 23:03:38 +00:00
// Retrieve sync locations from storage
2013-05-29 19:55:23 +00:00
_.each(fileSystem, function(fileDesc) {
2013-06-03 22:19:52 +00:00
_.each(utils.retrieveIndexArray(fileDesc.fileIndex + ".sync"), function(syncIndex) {
try {
2013-11-05 23:03:38 +00:00
var syncAttributes = JSON.parse(storage[syncIndex]);
2013-06-03 22:19:52 +00:00
// Store syncIndex
syncAttributes.syncIndex = syncIndex;
// Replace provider ID by provider module in attributes
var provider = providerMap[syncAttributes.provider];
if(!provider) {
throw new Error("Invalid provider ID: " + syncAttributes.provider);
}
syncAttributes.provider = provider;
2013-06-03 22:19:52 +00:00
fileDesc.syncLocations[syncIndex] = syncAttributes;
}
catch(e) {
2013-11-05 23:03:38 +00:00
// storage can be corrupted
2013-07-30 08:46:36 +00:00
eventMgr.onError(e);
2013-06-03 22:19:52 +00:00
// Remove sync location
utils.removeIndexFromArray(fileDesc.fileIndex + ".sync", syncIndex);
2013-11-05 23:03:38 +00:00
storage.removeItem(syncIndex);
2013-06-03 22:19:52 +00:00
}
2013-05-29 19:55:23 +00:00
});
});
2013-07-21 14:38:53 +00:00
// Returns true if at least one file has synchronized location
2013-07-30 08:46:36 +00:00
synchronizer.hasSync = function(provider) {
return _.some(fileSystem, function(fileDesc) {
return _.some(fileDesc.syncLocations, function(syncAttributes) {
return provider === undefined || syncAttributes.provider === provider;
});
2013-07-21 14:38:53 +00:00
});
};
2013-04-01 16:46:48 +00:00
2013-07-20 01:08:17 +00:00
/***************************************************************************
* Standard synchronization
**************************************************************************/
2013-05-29 19:55:23 +00:00
// Recursive function to upload a single file on multiple locations
var uploadSyncAttributesList = [];
2013-11-05 23:03:38 +00:00
var uploadContent;
var uploadContentCRC;
var uploadTitle;
var uploadTitleCRC;
2013-05-29 19:55:23 +00:00
function locationUp(callback) {
2013-04-01 16:46:48 +00:00
2013-05-29 19:55:23 +00:00
// No more synchronized location for this document
if(uploadSyncAttributesList.length === 0) {
fileUp(callback);
return;
}
2013-05-29 19:55:23 +00:00
// Dequeue a synchronized location
var syncAttributes = uploadSyncAttributesList.pop();
2013-06-16 18:29:54 +00:00
var providerSyncUpFunction = syncAttributes.provider.syncUp;
// Call a special function in case of a real time synchronized location
2013-07-20 01:08:17 +00:00
if(syncAttributes.isRealtime === true) {
providerSyncUpFunction = syncAttributes.provider.syncUpRealtime;
2013-07-20 01:08:17 +00:00
}
2013-05-29 19:55:23 +00:00
// Use the specified provider to perform the upload
providerSyncUpFunction(uploadContent, uploadContentCRC, uploadTitle, uploadTitleCRC, syncAttributes, function(error, uploadFlag) {
2013-05-29 19:55:23 +00:00
if(uploadFlag === true) {
// If uploadFlag is true, request another upload cycle
uploadCycle = true;
}
if(error) {
callback(error);
return;
}
if(uploadFlag) {
2013-11-05 23:03:38 +00:00
// Update syncAttributes in storage
2013-05-29 19:55:23 +00:00
utils.storeAttributes(syncAttributes);
}
locationUp(callback);
});
}
2013-04-10 18:14:59 +00:00
2013-05-29 19:55:23 +00:00
// Recursive function to upload multiple files
var uploadFileList = [];
function fileUp(callback) {
// No more fileDesc to synchronize
if(uploadFileList.length === 0) {
syncUp(callback);
return;
}
// Dequeue a fileDesc to synchronize
var fileDesc = uploadFileList.pop();
uploadSyncAttributesList = _.values(fileDesc.syncLocations);
if(uploadSyncAttributesList.length === 0) {
fileUp(callback);
return;
}
// Get document title/content
uploadContent = fileDesc.content;
uploadContentCRC = utils.crc32(uploadContent);
uploadTitle = fileDesc.title;
uploadTitleCRC = utils.crc32(uploadTitle);
locationUp(callback);
}
// Entry point for up synchronization (upload changes)
var uploadCycle = false;
function syncUp(callback) {
if(uploadCycle === true) {
// New upload cycle
uploadCycle = false;
uploadFileList = _.values(fileSystem);
fileUp(callback);
}
else {
callback();
}
}
// Recursive function to download changes from multiple providers
var providerList = [];
function providerDown(callback) {
if(providerList.length === 0) {
callback();
return;
}
var provider = providerList.pop();
// Check that provider has files to sync
2013-07-30 08:46:36 +00:00
if(!synchronizer.hasSync(provider)) {
2013-05-29 19:55:23 +00:00
providerDown(callback);
return;
}
// Perform provider's syncDown
provider.syncDown(function(error) {
if(error) {
callback(error);
return;
}
providerDown(callback);
});
}
// Entry point for down synchronization (download changes)
function syncDown(callback) {
providerList = _.values(providerMap);
providerDown(callback);
}
2013-08-04 00:53:46 +00:00
// Listen to offline status changes
var isOffline = false;
eventMgr.addListener("onOfflineChanged", function(isOfflineParam) {
isOffline = isOfflineParam;
});
2013-05-29 19:55:23 +00:00
// Main entry point for synchronization
var syncRunning = false;
synchronizer.sync = function() {
2013-06-10 22:32:34 +00:00
// If sync is already running or offline
2013-08-04 00:53:46 +00:00
if(syncRunning === true || isOffline === true) {
2013-06-10 22:32:34 +00:00
return false;
2013-05-29 19:55:23 +00:00
}
syncRunning = true;
2013-07-30 08:46:36 +00:00
eventMgr.onSyncRunning(true);
2013-05-29 19:55:23 +00:00
uploadCycle = true;
function isError(error) {
if(error !== undefined) {
syncRunning = false;
2013-07-30 08:46:36 +00:00
eventMgr.onSyncRunning(false);
2013-05-29 19:55:23 +00:00
return true;
}
return false;
}
syncDown(function(error) {
if(isError(error)) {
return;
}
syncUp(function(error) {
if(isError(error)) {
return;
}
syncRunning = false;
2013-07-30 08:46:36 +00:00
eventMgr.onSyncRunning(false);
eventMgr.onSyncSuccess();
2013-05-29 19:55:23 +00:00
});
});
2013-06-10 22:32:34 +00:00
return true;
2013-05-29 19:55:23 +00:00
};
2013-07-18 23:30:28 +00:00
2013-07-20 01:08:17 +00:00
/***************************************************************************
* Realtime synchronization
**************************************************************************/
2013-11-05 23:03:38 +00:00
var realtimeFileDesc;
var realtimeSyncAttributes;
2013-07-20 01:08:17 +00:00
var isOnline = true;
// Determines if open file has real time sync location and tries to start
// real time sync
function onFileOpen(fileDesc) {
2013-07-20 01:08:17 +00:00
realtimeFileDesc = _.some(fileDesc.syncLocations, function(syncAttributes) {
realtimeSyncAttributes = syncAttributes;
return syncAttributes.isRealtime;
}) ? fileDesc : undefined;
tryStartRealtimeSync();
}
2013-07-20 01:08:17 +00:00
// Tries to start/stop real time sync on online/offline event
function onOfflineChanged(isOfflineParam) {
if(isOfflineParam === false) {
isOnline = true;
tryStartRealtimeSync();
}
else {
synchronizer.tryStopRealtimeSync();
isOnline = false;
}
}
2013-07-20 01:08:17 +00:00
// Starts real time synchronization if:
// 1. current file has real time sync location
// 2. we are online
function tryStartRealtimeSync() {
if(realtimeFileDesc !== undefined && isOnline === true) {
2013-07-21 22:18:35 +00:00
realtimeSyncAttributes.provider.startRealtimeSync(realtimeFileDesc, realtimeSyncAttributes);
2013-07-20 01:08:17 +00:00
}
}
// Stops previously started synchronization if any
synchronizer.tryStopRealtimeSync = function() {
if(realtimeFileDesc !== undefined && isOnline === true) {
realtimeSyncAttributes.provider.stopRealtimeSync();
}
};
2013-07-30 08:46:36 +00:00
// Triggers realtime synchronization from eventMgr events
2013-11-05 23:03:38 +00:00
if(window.viewerMode === false) {
2013-07-30 08:46:36 +00:00
eventMgr.addListener("onFileOpen", onFileOpen);
eventMgr.addListener("onFileClosed", synchronizer.tryStopRealtimeSync);
eventMgr.addListener("onOfflineChanged", onOfflineChanged);
2013-07-18 23:30:28 +00:00
}
2013-07-20 01:08:17 +00:00
/***************************************************************************
* Initialize module
**************************************************************************/
2013-05-29 19:55:23 +00:00
// Initialize the export dialog
function initExportDialog(provider) {
// Reset fields
utils.resetModalInputs();
// Load preferences
2013-06-03 22:19:52 +00:00
var exportPreferences = utils.retrieveIgnoreError(provider.providerId + ".exportPreferences");
if(exportPreferences) {
2013-05-29 19:55:23 +00:00
_.each(provider.exportPreferencesInputIds, function(inputId) {
2013-08-23 23:50:14 +00:00
var exportPreferenceValue = exportPreferences[inputId];
if(_.isBoolean(exportPreferenceValue)) {
utils.setInputChecked("#input-sync-export-" + inputId, exportPreferenceValue);
}
else {
utils.setInputValue("#input-sync-export-" + inputId, exportPreferenceValue);
}
2013-05-29 19:55:23 +00:00
});
}
// Open dialog box
2013-08-11 00:52:05 +00:00
$(".modal-upload-" + provider.providerId).modal();
2013-05-29 19:55:23 +00:00
}
2013-08-04 00:53:46 +00:00
eventMgr.addListener("onReady", function() {
2013-05-29 19:55:23 +00:00
// Init each provider
_.each(providerMap, function(provider) {
// Provider's import button
$(".action-sync-import-" + provider.providerId).click(function(event) {
provider.importFiles(event);
});
// Provider's export action
$(".action-sync-export-dialog-" + provider.providerId).click(function() {
initExportDialog(provider);
});
$(".action-sync-export-" + provider.providerId).click(function(event) {
2013-07-18 23:30:28 +00:00
var isRealtime = utils.getInputChecked("#input-sync-export-" + provider.providerId + "-realtime");
2013-06-19 20:33:46 +00:00
var fileDesc = fileMgr.currentFile;
2013-07-18 23:30:28 +00:00
if(isRealtime) {
if(_.size(fileDesc.syncLocations) > 0) {
2013-07-30 08:46:36 +00:00
eventMgr.onError("Real time collaborative document can't be synchronized with multiple locations");
2013-05-29 19:55:23 +00:00
return;
2013-07-20 01:08:17 +00:00
}
2013-07-18 23:30:28 +00:00
// Perform the provider's real time export
provider.exportRealtimeFile(event, fileDesc.title, fileDesc.content, function(error, syncAttributes) {
if(error) {
return;
}
syncAttributes.isRealtime = true;
fileDesc.addSyncLocation(syncAttributes);
2013-07-30 08:46:36 +00:00
eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
2013-07-20 01:08:17 +00:00
// Start the real time sync
realtimeFileDesc = fileDesc;
realtimeSyncAttributes = syncAttributes;
tryStartRealtimeSync();
2013-07-18 23:30:28 +00:00
});
}
else {
2013-07-21 22:18:35 +00:00
if(_.size(fileDesc.syncLocations) > 0 && _.first(_.values(fileDesc.syncLocations)).isRealtime) {
2013-07-30 08:46:36 +00:00
eventMgr.onError("Real time collaborative document can't be synchronized with multiple locations");
2013-07-18 23:30:28 +00:00
return;
2013-07-20 01:08:17 +00:00
}
2013-07-18 23:30:28 +00:00
// Perform the provider's standard export
provider.exportFile(event, fileDesc.title, fileDesc.content, function(error, syncAttributes) {
if(error) {
return;
}
fileDesc.addSyncLocation(syncAttributes);
2013-07-30 08:46:36 +00:00
eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
2013-07-18 23:30:28 +00:00
});
}
2013-05-29 19:55:23 +00:00
// Store input values as preferences for next time we open the
// export dialog
var exportPreferences = {};
_.each(provider.exportPreferencesInputIds, function(inputId) {
2013-08-23 23:50:14 +00:00
var inputElt = document.getElementById("input-sync-export-" + inputId);
if(inputElt.type == 'checkbox') {
exportPreferences[inputId] = inputElt.checked;
}
else {
exportPreferences[inputId] = inputElt.value;
}
2013-05-29 19:55:23 +00:00
});
2013-11-05 23:03:38 +00:00
storage[provider.providerId + ".exportPreferences"] = JSON.stringify(exportPreferences);
2013-05-29 19:55:23 +00:00
});
});
});
2013-07-30 08:46:36 +00:00
eventMgr.onSynchronizerCreated(synchronizer);
2013-05-29 19:55:23 +00:00
return synchronizer;
2013-04-02 18:42:47 +00:00
});