mirrors/jellyfin-web
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-web synced 2025-03-30 19:56:21 +00:00
Code Activity

update sync processes

Browse source
This commit is contained in:
Luke Pulverenti 2015-09-09 13:49:44 -04:00
parent cad461b296
commit c23547137d
19 changed files with 400 additions and 326 deletions
Download patch file Download diff file Expand all files Collapse all files

126
dashboard-ui/apiclient/alt/ajax.js
View file

@ -1,126 +0,0 @@
(function (globalScope, angular) {
globalScope.HttpClient = {
param: function(params) {
return serialize(params);
},
send: function(options) {
var request = getAngularRequest(options),
defer = globalScope.DeferredBuilder.Deferred();
request.then(function(results) {
defer.resolve(results.data);
}, function() {
defer.reject();
});
return defer.promise();
}
};
// Code from: http://stackoverflow.com/questions/1714786/querystring-encoding-of-a-javascript-object
function serialize (obj, prefix) {
var str = [];
for(var p in obj) {
if (obj.hasOwnProperty(p)) {
var k = prefix ? prefix + "[" + p + "]" : p, v = obj[p];
str.push(typeof v == "object" ?
serialize(v, k) :
encodeURIComponent(k) + "=" + encodeURIComponent(v));
}
}
return str.join("&");
}
var $http = angular.injector(['ng']).get('$http');
function getAngularRequest(jParams) {
var optionTransforms = [],
promiseTransforms = [],
options = {},
// paramMap houses the param transforms in one of the following formats:
// string - This means there is a direct mapping from jQuery option to Angular option, but allows for a different option name
// function - This means some logic is required in applying this option to the Angular request. Functions should add functions
// to the optionTransforms or promiseTransforms arrays, which will be executed after direct mappings are complete.
paramMap = {
'accepts': undefined,
'async': undefined,
'beforeSend': undefined,
'cache': undefined,
'complete': undefined,
'contents': undefined,
'contentType': function(val) {
optionTransforms.push(function(opt) {
opt.headers = opt.headers || {};
opt.headers['Content-Type'] = val;
return opt;
});
},
'context': undefined,
'converters': undefined,
'crossDomain': undefined,
'data': 'data',
'dataFilter': undefined,
'dataType': 'responseType',
'error': undefined,
'global': undefined,
'headers': 'headers',
'ifModified': undefined,
'isLocal': undefined,
'jsonp': undefined,
'jsonpCallback': undefined,
'mimeType': undefined,
'password': undefined,
'processData': undefined,
'scriptCharset': undefined,
'statusCode': undefined,
'success': undefined,
'timeout': 'timeout',
'traditional': undefined,
'type': 'method',
'url': 'url',
'username': undefined,
'xhr': undefined,
'xhrFields': undefined,
};
// Iterate through each key in the jQuery format options object
for (var key in jParams) {
if (!paramMap[key]) {
// This parameter hasn't been implemented in the paramMap object
Logger.log('ERROR: ajax option property "' + key + '" not implemented by HttpClient.');
continue;
}
if (typeof paramMap[key] === 'string') {
// Direct mapping between two properties
options[paramMap[key]] = jParams[key];
continue;
}
if (typeof paramMap[key] === 'function') {
// Extra logic required. Execute the function with the jQuery option as the only function argument
paramMap[key](jParams[key]);
}
}
// Iterate through any optionTransforms functions and execute them with the options object as argument
while (optionTransforms.length > 0) {
options = optionTransforms.pop()(options);
}
// Create the Angular http request (returns the request's promise object)
var promise = $http(options);
// Iterate through any promiseTransforms functions and execute them with the promise as argument.
while (promiseTransforms.length > 0) {
promiseTransforms.pop()(promise);
}
return promise;
}
})(window, angular);

128
dashboard-ui/apiclient/apiclient.js
View file

@ -533,7 +533,7 @@
} else {
// If that produced a fairly high speed, try again with a larger size to get a more accurate result
self.getDownloadSpeed(3000000).done(function (bitrate) {
self.getDownloadSpeed(2400000).done(function (bitrate) {
deferred.resolveWith(null, [Math.round(bitrate * .8)]);
@ -1587,6 +1587,36 @@
});
};
/**
* Gets the current server configuration
*/
self.getDevicesOptions = function () {
var url = self.getUrl("System/Configuration/devices");
return self.ajax({
type: "GET",
url: url,
dataType: "json"
});
};
/**
* Gets the current server configuration
*/
self.getContentUploadHistory = function () {
var url = self.getUrl("Devices/CameraUploads", {
DeviceId: self.deviceId()
});
return self.ajax({
type: "GET",
url: url,
dataType: "json"
});
};
self.getNamedConfiguration = function (name) {
var url = self.getUrl("System/Configuration/" + name);
@ -2538,29 +2568,31 @@
var url = self.getUrl("Users/authenticatebyname");
var postData = {
password: CryptoJS.SHA1(password || "").toString(),
Username: name
};
require(["cryptojs-sha1"], function () {
var postData = {
password: CryptoJS.SHA1(password || "").toString(),
Username: name
};
self.ajax({
type: "POST",
url: url,
data: JSON.stringify(postData),
dataType: "json",
contentType: "application/json"
self.ajax({
type: "POST",
url: url,
data: JSON.stringify(postData),
dataType: "json",
contentType: "application/json"
}).done(function (result) {
}).done(function (result) {
if (self.onAuthenticated) {
self.onAuthenticated(self, result);
}
if (self.onAuthenticated) {
self.onAuthenticated(self, result);
}
deferred.resolveWith(null, [result]);
deferred.resolveWith(null, [result]);
}).fail(function () {
}).fail(function () {
deferred.reject();
deferred.reject();
});
});
return deferred.promise();
@ -2574,20 +2606,35 @@
*/
self.updateUserPassword = function (userId, currentPassword, newPassword) {
var deferred = DeferredBuilder.Deferred();
if (!userId) {
throw new Error("null userId");
deferred.reject();
return deferred.promise();
}
var url = self.getUrl("Users/" + userId + "/Password");
return self.ajax({
type: "POST",
url: url,
data: {
currentPassword: CryptoJS.SHA1(currentPassword).toString(),
newPassword: CryptoJS.SHA1(newPassword).toString()
}
require(["cryptojs-sha1"], function () {
self.ajax({
type: "POST",
url: url,
data: {
currentPassword: CryptoJS.SHA1(currentPassword).toString(),
newPassword: CryptoJS.SHA1(newPassword).toString()
}
}).done(function (result) {
deferred.resolveWith(null, [result]);
}).fail(function () {
deferred.reject();
});
});
return deferred.promise();
};
/**
@ -2597,19 +2644,34 @@
*/
self.updateEasyPassword = function (userId, newPassword) {
var deferred = DeferredBuilder.Deferred();
if (!userId) {
throw new Error("null userId");
deferred.reject();
return deferred.promise();
}
var url = self.getUrl("Users/" + userId + "/EasyPassword");
return self.ajax({
type: "POST",
url: url,
data: {
newPassword: CryptoJS.SHA1(newPassword).toString()
}
require(["cryptojs-sha1"], function () {
self.ajax({
type: "POST",
url: url,
data: {
newPassword: CryptoJS.SHA1(newPassword).toString()
}
}).done(function (result) {
deferred.resolveWith(null, [result]);
}).fail(function () {
deferred.reject();
});
});
return deferred.promise();
};
/**

20
dashboard-ui/apiclient/connectionmanager.js
View file

@ -126,6 +126,17 @@
return credentialProvider.credentials().ConnectAccessToken;
};
self.getServerInfo = function (id) {
var servers = credentialProvider.credentials().Servers;
return servers.filter(function () {
return s.Id == id;
})[0];
};
self.getLastUsedServer = function () {
var servers = credentialProvider.credentials().Servers;
@ -287,7 +298,9 @@
var server = servers.length ? servers[0] : apiClient.serverInfo();
server.DateLastAccessed = new Date().getTime();
if (options.updateDateLastAccessed !== false) {
server.DateLastAccessed = new Date().getTime();
}
server.Id = result.ServerId;
if (saveCredentials) {
@ -879,6 +892,7 @@
var wakeOnLanSendTime = new Date().getTime();
options = options || {};
testNextConnectionMode(tests, 0, server, wakeOnLanSendTime, options, deferred);
return deferred.promise();
@ -987,7 +1001,9 @@
updateServerInfo(server, systemInfo);
server.DateLastAccessed = new Date().getTime();
if (options.updateDateLastAccessed !== false) {
server.DateLastAccessed = new Date().getTime();
}
server.LastConnectionMode = connectionMode;
credentialProvider.addOrUpdateServer(credentials.Servers, server);
credentialProvider.credentials(credentials);

55
dashboard-ui/apiclient/sync/contentuploader.js Normal file
View file

@ -0,0 +1,55 @@
(function (globalScope) {
function contentUploader(connectionManager) {
self.uploadImages = function (server) {
var deferred = DeferredBuilder.Deferred();
var apiClient = self.getApiClient(server.Id);
apiClient.getDevicesOptions().done(function (devicesOptions) {
if (!devicesOptions.EnabledCameraUploadDevices || devicesOptions.EnabledCameraUploadDevices.indexOf(apiClient.deviceId()) == -1) {
Logger.log("Camera upload is not enabled for this device.");
deferred.reject();
}
else {
uploadImagesInternal(server, apiClient, deferred);
}
}).fail(function () {
deferred.reject();
});
return deferred.promise();
};
function uploadImagesInternal(server, apiClient, deferred) {
apiClient.getContentUploadHistory().done(function (result) {
uploadImagesWithHistory(server, result, apiClient, deferred);
}).fail(function () {
deferred.reject();
});
}
function uploadImagesWithHistory(server, uploadHistory, apiClient, deferred) {
require(['localassetmanager'], function () {
// TODO: Mimic java version of ContentUploader.UploadImagesInternal
deferred.resolve();
});
}
}
if (!globalScope.MediaBrowser) {
globalScope.MediaBrowser = {};
}
globalScope.MediaBrowser.ContentUploader = contentUploader;
})(this);

58
dashboard-ui/apiclient/sync/multiserversync.js Normal file
View file

@ -0,0 +1,58 @@
(function (globalScope) {
function multiServerSync(connectionManager) {
self.sync = function () {
var deferred = DeferredBuilder.Deferred();
connectionManager.getAvailableServers().done(function (result) {
syncNext(result, 0, deferred);
});
return deferred.promise();
};
function syncNext(servers, index, deferred) {
var length = servers.length;
if (index >= length) {
deferred.resolve();
return;
}
if (progress.isCancelled) {
deferred.reject();
return;
}
var server = servers[index];
// get fresh info from connection manager
server = connectionManager.getServerInfo(server.Id) || server;
Logger.log("Creating ServerSync to server: " + server.Id);
require(['serversync'], function () {
new MediaBrowser.ServerSync(connectionManager).sync(server).done(function () {
syncNext(servers, index + 1, deferred);
}).fail(function () {
syncNext(servers, index + 1, deferred);
});
});
}
}
if (!globalScope.MediaBrowser) {
globalScope.MediaBrowser = {};
}
globalScope.MediaBrowser.MultiServerSync = multiServerSync;
})(this);

64
dashboard-ui/apiclient/sync/serversync.js Normal file
View file

@ -0,0 +1,64 @@
(function (globalScope) {
function serverSync(connectionManager) {
self.sync = function (server) {
var deferred = DeferredBuilder.Deferred();
if (!server.AccessToken && !server.ExchangeToken) {
Logger.log('Skipping sync to server ' + server.Id + ' because there is no saved authentication information.');
deferred.resolve();
return;
}
var connectionOptions = {
updateDateLastAccessed: false,
enableWebSocket: false,
reportCapabilities: false
};
connectionManager.connectToServer(server, connectionOptions).done(function (result) {
if (result.State == MediaBrowser.ConnectionState.SignedIn) {
performSync(server, deferred);
} else {
Logger.log('Unable to connect to server id: ' + server.Id);
deferred.reject();
}
}).fail(function () {
Logger.log('Unable to connect to server id: ' + server.Id);
deferred.reject();
});
return deferred.promise();
};
function performSync(server, deferred) {
Logger.log("Creating ContentUploader to server: " + server.Id);
require(['contentuploader'], function () {
new MediaBrowser.ContentUploader(connectionManager).uploadImages(server).done(function () {
deferred.resolve();
}).fail(function () {
deferred.resolve();
});
});
}
}
if (!globalScope.MediaBrowser) {
globalScope.MediaBrowser = {};
}
globalScope.MediaBrowser.ServerSync = serverSync;
})(this);