373 lines
14 KiB
JavaScript
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;
|
|
});
|