Stackedit/public/res/synchronizer.js
2014-05-04 18:31:57 +01:00

373 lines
14 KiB
JavaScript

define([
"jquery",
"underscore",
"utils",
"storage",
"eventMgr",
"fileSystem",
"fileMgr",
"classes/Provider",
"providers/teamserverProvider",
"providers/dropboxProvider",
"providers/gdriveProvider",
"providers/gdrivesecProvider",
"providers/gdriveterProvider"
], function($, _, utils, storage, eventMgr, fileSystem, fileMgr, Provider) {
var synchronizer = {};
// Create a map with providerId: providerModule
var providerMap = _.chain(arguments).map(function(argument) {
return argument instanceof Provider && [
argument.providerId,
argument
];
}).compact().object().value();
// Retrieve sync locations from storage
(function() {
var syncIndexMap = {};
_.each(fileSystem, function(fileDesc) {
utils.retrieveIndexArray(fileDesc.fileIndex + ".sync").forEach(function(syncIndex) {
try {
var syncAttributes = JSON.parse(storage[syncIndex]);
// 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;
fileDesc.syncLocations[syncIndex] = syncAttributes;
syncIndexMap[syncIndex] = syncAttributes;
}
catch(e) {
// storage can be corrupted
eventMgr.onError(e);
// Remove sync location
utils.removeIndexFromArray(fileDesc.fileIndex + ".sync", syncIndex);
}
});
});
// Clean fields from deleted files in local storage
Object.keys(storage).forEach(function(key) {
var match = key.match(/sync\.\S+/);
if(match && !syncIndexMap.hasOwnProperty(match[0])) {
storage.removeItem(key);
}
});
})();
// AutoSync configuration
_.each(providerMap, function(provider) {
provider.autosyncConfig = utils.retrieveIgnoreError(provider.providerId + ".autosyncConfig") || {};
});
// Returns true if at least one file has synchronized location
synchronizer.hasSync = function(provider) {
return _.some(fileSystem, function(fileDesc) {
return _.some(fileDesc.syncLocations, function(syncAttributes) {
return provider === undefined || syncAttributes.provider === provider;
});
});
};
/***************************************************************************
* Synchronization
**************************************************************************/
// Entry point for up synchronization (upload changes)
var uploadCycle = false;
function syncUp(callback) {
var uploadFileList = [];
// Recursive function to upload multiple files
function fileUp() {
// No more fileDesc to synchronize
if(uploadFileList.length === 0) {
return syncUp(callback);
}
// Dequeue a fileDesc to synchronize
var fileDesc = uploadFileList.pop();
var uploadSyncAttributesList = _.values(fileDesc.syncLocations);
if(uploadSyncAttributesList.length === 0) {
return fileUp();
}
var uploadContent = fileDesc.content;
var uploadContentCRC = utils.crc32(uploadContent);
var uploadTitle = fileDesc.title;
var uploadTitleCRC = utils.crc32(uploadTitle);
var uploadDiscussionList = fileDesc.discussionListJSON;
var uploadDiscussionListCRC = utils.crc32(uploadDiscussionList);
// Recursive function to upload a single file on multiple locations
function locationUp() {
// No more synchronized location for this document
if(uploadSyncAttributesList.length === 0) {
return fileUp();
}
// Dequeue a synchronized location
var syncAttributes = uploadSyncAttributesList.pop();
syncAttributes.provider.syncUp(
uploadContent,
uploadContentCRC,
uploadTitle,
uploadTitleCRC,
uploadDiscussionList,
uploadDiscussionListCRC,
syncAttributes,
function(error, uploadFlag) {
if(uploadFlag === true) {
// If uploadFlag is true, request another upload cycle
uploadCycle = true;
}
if(error) {
return callback(error);
}
if(uploadFlag) {
// Update syncAttributes in storage
utils.storeAttributes(syncAttributes);
}
locationUp();
}
);
}
locationUp();
}
if(uploadCycle === true) {
// New upload cycle
uploadCycle = false;
uploadFileList = _.values(fileSystem);
fileUp();
}
else {
callback();
}
}
// Entry point for down synchronization (download changes)
function syncDown(callback) {
var providerList = _.values(providerMap);
// Recursive function to download changes from multiple providers
function providerDown() {
if(providerList.length === 0) {
return callback();
}
var provider = providerList.pop();
// Check that provider has files to sync
if(!synchronizer.hasSync(provider)) {
return providerDown();
}
// Perform provider's syncDown
provider.syncDown(function(error) {
if(error) {
return callback(error);
}
providerDown();
});
}
providerDown();
}
// Entry point for the autosync feature
function autosyncAll(callback) {
var autosyncFileList = _.filter(fileSystem, function(fileDesc) {
return _.size(fileDesc.syncLocations) === 0;
});
// Recursive function to autosync multiple files
function fileAutosync() {
// No more fileDesc to synchronize
if(autosyncFileList.length === 0) {
return callback();
}
var fileDesc = autosyncFileList.pop();
var providerList = _.filter(providerMap, function(provider) {
return provider.autosyncConfig.mode == 'all';
});
function providerAutosync() {
// No more provider
if(providerList.length === 0) {
return fileAutosync();
}
var provider = providerList.pop();
provider.autosyncFile(fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, provider.autosyncConfig, function(error, syncAttributes) {
if(error) {
return callback(error);
}
fileDesc.addSyncLocation(syncAttributes);
eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
providerAutosync();
});
}
providerAutosync();
}
fileAutosync();
}
// Listen to offline status changes
var isOffline = false;
eventMgr.addListener("onOfflineChanged", function(isOfflineParam) {
isOffline = isOfflineParam;
});
// Main entry point for synchronization
var syncRunning = false;
synchronizer.sync = function() {
// If sync is already running or offline
if(syncRunning === true || isOffline === true) {
return false;
}
syncRunning = true;
eventMgr.onSyncRunning(true);
uploadCycle = true;
function isError(error) {
if(error !== undefined) {
syncRunning = false;
eventMgr.onSyncRunning(false);
return true;
}
return false;
}
autosyncAll(function(error) {
if(isError(error)) {
return;
}
syncDown(function(error) {
if(isError(error)) {
return;
}
syncUp(function(error) {
if(isError(error)) {
return;
}
syncRunning = false;
eventMgr.onSyncRunning(false);
eventMgr.onSyncSuccess();
});
});
});
return true;
};
/***************************************************************************
* Initialize module
**************************************************************************/
// Initialize the export dialog
function initExportDialog(provider) {
// Reset fields
utils.resetModalInputs();
// Load preferences
var exportPreferences = utils.retrieveIgnoreError(provider.providerId + ".exportPreferences");
if(exportPreferences) {
_.each(provider.exportPreferencesInputIds, function(inputId) {
var exportPreferenceValue = exportPreferences[inputId];
if(_.isBoolean(exportPreferenceValue)) {
utils.setInputChecked("#input-sync-export-" + inputId, exportPreferenceValue);
}
else {
utils.setInputValue("#input-sync-export-" + inputId, exportPreferenceValue);
}
});
}
// Open dialog
$(".modal-upload-" + provider.providerId).modal();
}
eventMgr.addListener("onFileCreated", function(fileDesc) {
if(_.size(fileDesc.syncLocations) === 0) {
_.each(providerMap, function(provider) {
if(provider.autosyncConfig.mode != 'new') {
return;
}
provider.autosyncFile(fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, provider.autosyncConfig, function(error, syncAttributes) {
if(error) {
return;
}
fileDesc.addSyncLocation(syncAttributes);
eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
});
});
}
});
eventMgr.addListener("onReady", function() {
// 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);
});
// Provider's autosync action
$(".action-autosync-dialog-" + provider.providerId).click(function() {
// Reset fields
utils.resetModalInputs();
// Load config
provider.setAutosyncDialogConfig(provider);
// Open dialog
$(".modal-autosync-" + provider.providerId).modal();
});
$(".action-sync-export-" + provider.providerId).click(function(event) {
var fileDesc = fileMgr.currentFile;
provider.exportFile(event, fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, function(error, syncAttributes) {
if(error) {
return;
}
fileDesc.addSyncLocation(syncAttributes);
eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
});
// Store input values as preferences for next time we open the
// export dialog
var exportPreferences = {};
_.each(provider.exportPreferencesInputIds, function(inputId) {
var inputElt = document.getElementById("input-sync-export-" + inputId);
if(inputElt.type == 'checkbox') {
exportPreferences[inputId] = inputElt.checked;
}
else {
exportPreferences[inputId] = inputElt.value;
}
});
storage[provider.providerId + ".exportPreferences"] = JSON.stringify(exportPreferences);
});
$(".action-autosync-" + provider.providerId).click(function(event) {
var config = provider.getAutosyncDialogConfig(event);
if(config !== undefined) {
storage[provider.providerId + ".autosyncConfig"] = JSON.stringify(config);
provider.autosyncConfig = config;
}
});
});
});
eventMgr.onSynchronizerCreated(synchronizer);
return synchronizer;
});