537 lines
19 KiB
JavaScript
537 lines
19 KiB
JavaScript
// ==UserScript==
|
|
// @id iitc-plugin-sync@xelio
|
|
// @name IITC plugin: Sync
|
|
// @version 0.1.0.@@DATETIMEVERSION@@
|
|
// @namespace https://github.com/jonatkins/ingress-intel-total-conversion
|
|
// @updateURL @@UPDATEURL@@
|
|
// @downloadURL @@DOWNLOADURL@@
|
|
// @description [@@BUILDNAME@@-@@BUILDDATE@@] Sync data between clients
|
|
// @include https://www.ingress.com/intel*
|
|
// @include http://www.ingress.com/intel*
|
|
// @match https://www.ingress.com/intel*
|
|
// @match http://www.ingress.com/intel*
|
|
// ==/UserScript==
|
|
|
|
function wrapper() {
|
|
// ensure plugin framework is there, even if iitc is not yet loaded
|
|
if(typeof window.plugin !== 'function') window.plugin = function() {};
|
|
|
|
|
|
// PLUGIN START ////////////////////////////////////////////////////////
|
|
|
|
// use own namespace for plugin
|
|
window.plugin.sync = function() {};
|
|
|
|
window.plugin.sync.KEY_UUID = {key: 'plugin-sync-data-uuid', field: 'uuid'};
|
|
|
|
// Each client has an unique UUID, to identify remote data is udpated by other clients or not
|
|
window.plugin.sync.uuid = null;
|
|
|
|
window.plugin.sync.dialogHTML = null;
|
|
window.plugin.sync.authorizer = null;
|
|
|
|
// Store registered CollaborativeMap
|
|
window.plugin.sync.registerdPluginsFields = null;
|
|
|
|
// Other plugin call this function to push update to Google Realtime API
|
|
// example:
|
|
// plugin.sync.updateMap('keys', 'keysdata', ['guid1', 'guid2', 'guid3'])
|
|
// Which will push plugin.keys.keysdata['guid1'] etc. to Google Realtime API
|
|
window.plugin.sync.updateMap = function(pluginName, fieldName, keyArray) {
|
|
var registeredMap = plugin.sync.registerdPluginsFields.get(pluginName, fieldName);
|
|
if(!registeredMap) return false;
|
|
registeredMap.updateMap(keyArray);
|
|
}
|
|
|
|
// Other plugin call this to register a field as CollaborativeMap to sync with Google Realtime API
|
|
// example: plugin.sync.registerMapForSync('keys', 'keysdata', plugin.keys.updateCallback, plugin.keys.initializedCallback)
|
|
// which register plugin.keys.keysdata
|
|
//
|
|
// updateCallback function format: function(pluginName, fieldName, eventObejct)
|
|
// updateCallback will be fired when local or remote pushed update to Google Realtime API
|
|
// eventObject is a ValueChangedEvent, refer to following url
|
|
// https://developers.google.com/drive/realtime/reference/gapi.drive.realtime.ValueChangedEvent
|
|
//
|
|
// initializedCallback funciton format: function(pluginName, fieldName)
|
|
// initializedCallback will be fired when the CollaborativeMap finished initialize and good to use
|
|
window.plugin.sync.registerMapForSync = function(pluginName, fieldName, callback, initializedCallback) {
|
|
var options, registeredMap;
|
|
options = {'pluginName': pluginName,
|
|
'fieldName': fieldName,
|
|
'callback': callback,
|
|
'initializedCallback': initializedCallback,
|
|
'authorizer': plugin.sync.authorizer,
|
|
'uuid': plugin.sync.uuid};
|
|
registeredMap = new plugin.sync.RegisteredMap(options);
|
|
plugin.sync.registerdPluginsFields.add(registeredMap);
|
|
}
|
|
|
|
|
|
|
|
//// RegisteredMap
|
|
// Create a file named pluginName[fieldName] in folder specified by authorizer
|
|
// The file use as realtime document with CollaborativeMap to store the data and a
|
|
// CollaborativeString to store uuid of last update client
|
|
// callback will called when any local/remote update happen
|
|
// initializedCallback will called when RegisteredMap initialized and good to use.
|
|
window.plugin.sync.RegisteredMap = function(options) {
|
|
this.pluginName = options['pluginName'];
|
|
this.fieldName = options['fieldName'];
|
|
this.callback = options['callback'];
|
|
this.initializedCallback = options['initializedCallback'];
|
|
this.authorizer = options['authorizer'];
|
|
this.uuid = options['uuid'];
|
|
this.fileId = null;
|
|
this.doc = null;
|
|
this.model = null;
|
|
this.map = null;
|
|
this.lastUpdateUUID = null;
|
|
this.initializing = false;
|
|
this.initialized = false;
|
|
this.updateListener = this.updateListener.bind(this);
|
|
this.initialize = this.initialize.bind(this);
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.updateMap = function(keyArray) {
|
|
var _this = this;
|
|
// Use compound operation to ensure update pushed as a batch
|
|
this.model.beginCompoundOperation();
|
|
// Remove before set text to ensure full text change
|
|
this.lastUpdateUUID.removeRange(0, this.lastUpdateUUID.length);
|
|
this.lastUpdateUUID.setText(this.uuid);
|
|
|
|
$.each(keyArray, function(ind, key) {
|
|
var value = window.plugin[_this.pluginName][_this.fieldName][key];
|
|
if(typeof(value) !== 'undefined') {
|
|
_this.map.set(key, value);
|
|
} else {
|
|
_this.map.delete(key);
|
|
}
|
|
});
|
|
this.model.endCompoundOperation();
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.isUpdatedByOthers = function() {
|
|
return this.lastUpdateUUID.toString() !== this.uuid;
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.getFileName = function() {
|
|
return this.pluginName + '[' + this.fieldName + ']'
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.searchOrCreateFile = function(callback) {
|
|
var queryOption, createOption, searchCallBack, _this;
|
|
_this = this;
|
|
|
|
queryOption = 'title = "' + this.getFileName() +'" and "' + this.authorizer.folderId + '" in parents and trashed = false';
|
|
createOption = {'convert': 'false'
|
|
, 'ocr': 'false'
|
|
, 'resource': {'title': this.getFileName(),
|
|
'description': 'IITC plugin data for ' + this.getFileName(),
|
|
'mimeType': 'application/vnd.google-apps.drive-sdk',
|
|
'parents': [{'id': this.authorizer.folderId}]
|
|
}
|
|
};
|
|
searchCallBack = function(resp) {
|
|
if(resp.items) {
|
|
_this.fileId = resp.items[0].id;
|
|
if(callback) callback();
|
|
} else {
|
|
plugin.sync.createFileOrFolder(createOption, function(resp) {
|
|
if (resp.id) {
|
|
_this.fileId = resp.id;
|
|
if(callback) callback();
|
|
} else {
|
|
_this.initializing = false;
|
|
console.log('Plugin Sync: Could not create file ' + _this.getFileName());
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
plugin.sync.searchFileOrFolder(queryOption, searchCallBack);
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.updateListener = function(e) {
|
|
console.log(e);
|
|
if(!e.isLocal) {
|
|
if(!window.plugin[this.pluginName][this.fieldName]) {
|
|
window.plugin[this.pluginName][this.fieldName] = {};
|
|
}
|
|
if(typeof(e.newValue) !== 'undefined' && e.newValue !== null) {
|
|
window.plugin[this.pluginName][this.fieldName][e.property] = e.newValue;
|
|
} else {
|
|
delete window.plugin[this.pluginName][this.fieldName][e.property];
|
|
}
|
|
}
|
|
if(this.callback) this.callback(this.pluginName, this.fieldName, e);
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.initialize = function(callback) {
|
|
this.initializing = true;
|
|
var initRealtime, initializeModel, onFileLoaded, handleError, _this;
|
|
_this = this;
|
|
|
|
initRealtime = function() {
|
|
gapi.drive.realtime.load(_this.fileId, onFileLoaded, initializeModel, handleError);
|
|
};
|
|
|
|
// this function called when the document is created first time
|
|
// and the CollaborativeMap is populated with data in plugin field
|
|
initializeModel = function(model) {
|
|
var map = model.createMap();
|
|
var lastUpdateUUID = model.createString();
|
|
|
|
// Init the map values if this map is first created
|
|
$.each(window.plugin[_this.pluginName][_this.fieldName], function(key, val) {
|
|
map.set(key, val);
|
|
});
|
|
lastUpdateUUID.setText(_this.uuid);
|
|
|
|
model.getRoot().set('map', map);
|
|
model.getRoot().set('last-udpate-uuid', lastUpdateUUID);
|
|
console.log(_this.pluginName + '[' + _this.fieldName + ']' + ': model initialized');
|
|
};
|
|
|
|
// this function called when the document is loaded
|
|
// update local data if the document is updated by other
|
|
// and add update listener to CollaborativeMap
|
|
onFileLoaded = function(doc) {
|
|
_this.doc = doc;
|
|
_this.model = doc.getModel();
|
|
_this.map = doc.getModel().getRoot().get("map");
|
|
_this.lastUpdateUUID = doc.getModel().getRoot().get("last-udpate-uuid");
|
|
_this.map.addEventListener(gapi.drive.realtime.EventType.VALUE_CHANGED, _this.updateListener);
|
|
|
|
// Replace local value if data is changed by others
|
|
if(_this.isUpdatedByOthers()) {
|
|
console.log(_this.pluginName + '[' + _this.fieldName + ']' + ': updated by others, replacing content.');
|
|
window.plugin[_this.pluginName][_this.fieldName] = {};
|
|
$.each(_this.map.keys(), function(ind, key) {
|
|
window.plugin[_this.pluginName][_this.fieldName][key] = _this.map.get(key);
|
|
});
|
|
}
|
|
|
|
_this.initialized = true;
|
|
_this.initializing = false;
|
|
console.log(_this.pluginName + '[' + _this.fieldName + ']' + ': data loaded');
|
|
if(callback) callback();
|
|
if(_this.initializedCallback) _this.initializedCallback(_this.pluginName, _this.fieldName);
|
|
};
|
|
|
|
// Stop the sync if any error occur and try to re-authorize
|
|
handleError = function(e) {
|
|
_this.initializing = false;
|
|
console.log('handle error');
|
|
_this.stopSync();
|
|
_this.authorizer.authorize();
|
|
console.log('Realtime API Error: ' + e.type);
|
|
};
|
|
|
|
this.searchOrCreateFile(initRealtime);
|
|
}
|
|
|
|
window.plugin.sync.RegisteredMap.prototype.stopSync = function() {
|
|
this.map.removeEventListener(gapi.drive.realtime.EventType.VALUE_CHANGED, this.updateListener);
|
|
this.fileId = null;
|
|
this.doc = null;
|
|
this.model = null;
|
|
this.map = null;
|
|
this.lastUpdateUUID = null;
|
|
this.initializing = false;
|
|
this.initialized = false;
|
|
plugin.sync.registerdPluginsFields.addToWaitingInitialize(this.pluginName, this.fieldName);
|
|
}
|
|
//// end RegisteredMap
|
|
|
|
|
|
|
|
|
|
//// registerdPluginsFields
|
|
// Store RegisteredMap and handle initialization of RegisteredMap
|
|
window.plugin.sync.registerdPluginsFields = function(options) {
|
|
this.authorizer = options['authorizer'];
|
|
this.pluginsfields = {};
|
|
this.waitingInitialize = [];
|
|
this.initializeRegistered = this.initializeRegistered.bind(this);
|
|
this.cleanWaitingInitialize = this.cleanWaitingInitialize.bind(this);
|
|
this.initializeWorker = this.initializeWorker.bind(this);
|
|
this.authorizer.addAuthCallback(this.initializeRegistered);
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.add = function(registeredMap) {
|
|
var pluginName, fieldName;
|
|
pluginName = registeredMap.pluginName;
|
|
fieldName = registeredMap.fieldName;
|
|
this.pluginsfields[pluginName] = this.pluginsfields[pluginName] || {};
|
|
|
|
if(this.pluginsfields[pluginName][fieldName]) return false;
|
|
|
|
this.pluginsfields[pluginName][fieldName] = registeredMap;
|
|
this.waitingInitialize.push(registeredMap);
|
|
|
|
this.initializeWorker();
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.addToWaitingInitialize = function(pluginName, fieldName) {
|
|
var registeredMap = this.get(pluginName, fieldName);
|
|
if(!registeredMap) return;
|
|
this.waitingInitialize.push(registeredMap);
|
|
|
|
this.initializeWorker();
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.get = function(pluginName, fieldName) {
|
|
if(!this.pluginsfields[pluginName]) return;
|
|
return this.pluginsfields[pluginName][fieldName];
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.initializeRegistered = function() {
|
|
var _this = this;
|
|
if(this.authorizer.isAuthed()) {
|
|
$.each(this.waitingInitialize, function(ind, map) {
|
|
if(!map.initializing && !map.initialized) {
|
|
map.initialize(_this.cleanWaitingInitialize);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.cleanWaitingInitialize = function() {
|
|
this.waitingInitialize = $.grep(this.waitingInitialize, function(map, ind) {return !map.initialized;});
|
|
}
|
|
|
|
window.plugin.sync.registerdPluginsFields.prototype.initializeWorker = function() {
|
|
var _this = this;
|
|
|
|
if(this.authorizer.isAuthed()) {
|
|
this.initializeRegistered();
|
|
}
|
|
|
|
clearTimeout(this.timer);
|
|
if(this.waitingInitialize.length > 0) {
|
|
this.timer = setTimeout(function() {_this.initializeWorker()}, 10000);
|
|
}
|
|
}
|
|
//// end registerdPluginsFields
|
|
|
|
|
|
|
|
|
|
//// Authorizer
|
|
// authorize user google account and create a folder 'IITC-SYNC-DATA' to store Realtime document
|
|
window.plugin.sync.Authorizer = function(options) {
|
|
this.authCallback = options['authCallback'];
|
|
this.folderId = null;
|
|
this.authorize = this.authorize.bind(this);
|
|
}
|
|
|
|
window.plugin.sync.Authorizer.prototype.CLIENT_ID = '686674438052.apps.googleusercontent.com';
|
|
window.plugin.sync.Authorizer.prototype.SCOPES = ['https://www.googleapis.com/auth/drive.file', 'https://www.googleapis.com/auth/drive.metadata.readonly'];
|
|
|
|
window.plugin.sync.Authorizer.prototype.isAuthed = function() {
|
|
return this.folderId !== null;
|
|
}
|
|
|
|
window.plugin.sync.Authorizer.prototype.addAuthCallback = function(callback) {
|
|
if(typeof(this.authCallback) === 'function') this.authCallback = [this.authCallback];
|
|
this.authCallback.push(callback);
|
|
}
|
|
|
|
window.plugin.sync.Authorizer.prototype.authComplete = function() {
|
|
if(this.authCallback) {
|
|
if(typeof(this.authCallback) === 'function') this.authCallback();
|
|
if(this.authCallback instanceof Array && this.authCallback.length > 0) {
|
|
$.each(this.authCallback, function(ind, func) {
|
|
func();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.Authorizer.prototype.initFolder = function(callback) {
|
|
var queryOption, createOption, searchCallBack, _this;
|
|
_this = this;
|
|
|
|
queryOption = 'title = "IITC-SYNC-DATA" and mimeType = "application/vnd.google-apps.folder" and trashed = false';
|
|
createOption = {'convert': 'false'
|
|
, 'ocr': 'false'
|
|
, 'resource': {'title': 'IITC-SYNC-DATA',
|
|
'description': 'Store IITC sync data',
|
|
'mimeType': 'application/vnd.google-apps.folder'
|
|
}
|
|
};
|
|
searchCallBack = function(resp) {
|
|
if(resp.items) {
|
|
_this.folderId = resp.items[0].id;
|
|
if(callback) callback();
|
|
_this.authComplete();
|
|
} else {
|
|
plugin.sync.createFileOrFolder(createOption, function(resp) {
|
|
if (resp.id) {
|
|
_this.folderId = resp.id;
|
|
if(callback) callback();
|
|
} else {
|
|
console.log('Plugin Sync: Could not create folder "IITC-SYNC-DATA"');
|
|
}
|
|
_this.authComplete();
|
|
});
|
|
}
|
|
};
|
|
|
|
plugin.sync.searchFileOrFolder(queryOption, searchCallBack);
|
|
}
|
|
|
|
window.plugin.sync.Authorizer.prototype.authorize = function(popup, callback) {
|
|
var handleAuthResult, _this;
|
|
_this = this;
|
|
|
|
handleAuthResult = function(authResult) {
|
|
if(authResult && !authResult.error) {
|
|
_this.initFolder(callback);
|
|
} else {
|
|
_this.folderId = null;
|
|
_this.authComplete();
|
|
console.log('Plugin Sync: Authorization error.');
|
|
}
|
|
};
|
|
|
|
gapi.auth.authorize({'client_id': this.CLIENT_ID, 'scope': this.SCOPES, 'immediate': !popup}
|
|
, handleAuthResult);
|
|
}
|
|
//// end Authorizer
|
|
|
|
window.plugin.sync.createFileOrFolder = function(option, callback) {
|
|
gapi.client.load('drive', 'v2', function() {
|
|
gapi.client.drive.files.insert(option).execute(callback);
|
|
});
|
|
}
|
|
|
|
window.plugin.sync.searchFileOrFolder = function(queryOption, callback) {
|
|
gapi.client.load('drive', 'v2', function() {
|
|
var option = {'q': queryOption};
|
|
gapi.client.drive.files.list(option).execute(callback);
|
|
});
|
|
}
|
|
|
|
|
|
// http://stackoverflow.com/a/8809472/2322660
|
|
// http://stackoverflow.com/a/7221797/2322660
|
|
// With format fixing: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx where y in [8,9,a,b]
|
|
window.plugin.sync.generateUUID = function() {
|
|
if(window.crypto && window.crypto.getRandomValues) {
|
|
var buf = new Uint16Array(8);
|
|
window.crypto.getRandomValues(buf);
|
|
var S4 = function(num) {
|
|
var ret = num.toString(16);
|
|
return "000".substring(0, 4-ret.length) + ret;
|
|
};
|
|
var yxxx = function(num) {
|
|
return num&0x3fff|0x8000;
|
|
}
|
|
return (S4(buf[0])+S4(buf[1])+"-"+S4(buf[2])+"-4"+S4(buf[3]).substring(1)+"-"+S4(yxxx(buf[4]))+"-"+S4(buf[5])+S4(buf[6])+S4(buf[7]));
|
|
} else {
|
|
var d = new Date().getTime();
|
|
var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
|
|
var r = (d + Math.random()*16)%16 | 0;
|
|
d = Math.floor(d/16);
|
|
return (c=='x' ? r : (r&0x3|0x8)).toString(16);
|
|
});
|
|
return uuid;
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.storeLocal = function(mapping) {
|
|
if(typeof(plugin.sync[mapping.field]) !== 'undefined' && plugin.sync[mapping.field] !== null) {
|
|
localStorage[mapping.key] = JSON.stringify(plugin.sync[mapping.field]);
|
|
} else {
|
|
localStorage.removeItem(mapping.key);
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.loadLocal = function(mapping) {
|
|
var objectJSON = localStorage[mapping.key];
|
|
if(!objectJSON) return;
|
|
plugin.sync[mapping.field] = mapping.convertFunc
|
|
? mapping.convertFunc(JSON.parse(objectJSON))
|
|
: JSON.parse(objectJSON);
|
|
}
|
|
|
|
window.plugin.sync.loadUUID = function() {
|
|
plugin.sync.loadLocal(plugin.sync.KEY_UUID);
|
|
if(!plugin.sync.uuid) {
|
|
plugin.sync.uuid = plugin.sync.generateUUID();
|
|
plugin.sync.storeLocal(plugin.sync.KEY_UUID);
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.loadGapi = function() {
|
|
try { console.log('Loading Gapi JS now'); } catch(e) {}
|
|
@@INCLUDERAW:external/gapi.js@@
|
|
try { console.log('done loading delaunay JS'); } catch(e) {}
|
|
}
|
|
|
|
window.plugin.sync.toggleAuthButton = function() {
|
|
var authed = plugin.sync.authorizer.isAuthed();
|
|
$('#sync-authButton').attr('disabled', authed);
|
|
$('#sync-authButton').html(authed ? 'Authorized' : 'Authorize');
|
|
if(authed) {
|
|
$('#sync-authButton').addClass('sync-authButton-authed');
|
|
$('#sync-show-dialog').removeClass('sync-show-dialog-error');
|
|
} else {
|
|
$('#sync-authButton').removeClass('sync-authButton-authed');
|
|
$('#sync-show-dialog').addClass('sync-show-dialog-error');
|
|
}
|
|
}
|
|
|
|
window.plugin.sync.showDialog = function() {
|
|
alert(plugin.sync.dialogHTML);
|
|
plugin.sync.toggleAuthButton();
|
|
}
|
|
|
|
window.plugin.sync.setupDialog = function() {
|
|
plugin.sync.dialogHTML = '<div id="sync-dialog">'
|
|
+ '<button id="sync-authButton" class="sync-authButton-authed" onclick="setTimeout(function(){window.plugin.sync.authorizer.authorize(true)}, 1)" disabled="disabled">Authorize</button>'
|
|
+ '</div>';
|
|
$('#toolbox').append('<a id="sync-show-dialog" onclick="window.plugin.sync.showDialog();">Sync</a> ');
|
|
}
|
|
|
|
window.plugin.sync.setupCSS = function() {
|
|
$("<style>")
|
|
.prop("type", "text/css")
|
|
.html(".sync-authButton-authed {\
|
|
opacity: 0.5;\
|
|
}\
|
|
.sync-show-dialog-error {\
|
|
color: #FF2222;\
|
|
}")
|
|
.appendTo("head");
|
|
}
|
|
|
|
var setup = function() {
|
|
window.plugin.sync.loadUUID();
|
|
window.plugin.sync.loadGapi();
|
|
window.plugin.sync.setupCSS();
|
|
window.plugin.sync.setupDialog();
|
|
|
|
window.plugin.sync.authorizer = new window.plugin.sync.Authorizer({'authCallback': [plugin.sync.toggleAuthButton]});
|
|
window.plugin.sync.registerdPluginsFields = new window.plugin.sync.registerdPluginsFields({'authorizer': window.plugin.sync.authorizer});
|
|
gapi.load('auth:client,drive-realtime,drive-share', window.plugin.sync.authorizer.authorize);
|
|
}
|
|
|
|
// PLUGIN END //////////////////////////////////////////////////////////
|
|
|
|
if(window.iitcLoaded && typeof setup === 'function') {
|
|
setup();
|
|
} else {
|
|
if(window.bootPlugins)
|
|
window.bootPlugins.push(setup);
|
|
else
|
|
window.bootPlugins = [setup];
|
|
}
|
|
} // wrapper end
|
|
// inject code into site context
|
|
var script = document.createElement('script');
|
|
script.appendChild(document.createTextNode('('+ wrapper +')();'));
|
|
(document.body || document.head || document.documentElement).appendChild(script);
|