mirror of
https://github.com/jellyfin/jellyfin-web.git
synced 2024-11-19 11:58:20 -07:00
646 lines
23 KiB
JavaScript
646 lines
23 KiB
JavaScript
define(['localassetmanager'], function (localassetmanager) {
|
|
'use strict';
|
|
|
|
function processDownloadStatus(apiClient, serverInfo, options) {
|
|
|
|
console.log('[mediasync] Begin processDownloadStatus');
|
|
|
|
return localassetmanager.resyncTransfers().then(function () {
|
|
|
|
return localassetmanager.getServerItems(serverInfo.Id).then(function (items) {
|
|
|
|
console.log('[mediasync] Begin processDownloadStatus getServerItems completed');
|
|
|
|
var progressItems = items.filter(function (item) {
|
|
return item.SyncStatus === 'transferring' || item.SyncStatus === 'queued';
|
|
});
|
|
|
|
var p = Promise.resolve();
|
|
var cnt = 0;
|
|
|
|
progressItems.forEach(function (item) {
|
|
p = p.then(function () {
|
|
return reportTransfer(apiClient, item);
|
|
});
|
|
cnt++;
|
|
});
|
|
|
|
return p.then(function () {
|
|
console.log('[mediasync] Exit processDownloadStatus. Items reported: ' + cnt.toString());
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
function reportTransfer(apiClient, item) {
|
|
|
|
return localassetmanager.getItemFileSize(item.LocalPath).then(function (size) {
|
|
// The background transfer service on Windows leaves the file empty (size = 0) until it
|
|
// has been downloaded completely
|
|
if (size > 0) {
|
|
return apiClient.reportSyncJobItemTransferred(item.SyncJobItemId).then(function () {
|
|
item.SyncStatus = 'synced';
|
|
return localassetmanager.addOrUpdateLocalItem(item);
|
|
}, function (error) {
|
|
console.error('[mediasync] Mediasync error on reportSyncJobItemTransferred', error);
|
|
item.SyncStatus = 'error';
|
|
return localassetmanager.addOrUpdateLocalItem(item);
|
|
});
|
|
} else {
|
|
return localassetmanager.isDownloadFileInQueue(item.LocalPath).then(function (result) {
|
|
if (result) {
|
|
// just wait for completion
|
|
return Promise.resolve();
|
|
}
|
|
|
|
console.log('[mediasync] reportTransfer: Size is 0 and download no longer in queue. Deleting item.');
|
|
return localassetmanager.removeLocalItem(item).then(function () {
|
|
console.log('[mediasync] reportTransfer: Item deleted.');
|
|
return Promise.resolve();
|
|
}, function (err2) {
|
|
console.log('[mediasync] reportTransfer: Failed to delete item.', err2);
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
}, function (error) {
|
|
|
|
console.error('[mediasync] reportTransfer: error on getItemFileSize. Deleting item.', error);
|
|
return localassetmanager.removeLocalItem(item).then(function () {
|
|
console.log('[mediasync] reportTransfer: Item deleted.');
|
|
return Promise.resolve();
|
|
}, function (err2) {
|
|
console.log('[mediasync] reportTransfer: Failed to delete item.', error);
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
function reportOfflineActions(apiClient, serverInfo) {
|
|
|
|
console.log('[mediasync] Begin reportOfflineActions');
|
|
|
|
return localassetmanager.getUserActions(serverInfo.Id).then(function (actions) {
|
|
|
|
if (!actions.length) {
|
|
console.log('[mediasync] Exit reportOfflineActions (no actions)');
|
|
return Promise.resolve();
|
|
}
|
|
|
|
return apiClient.reportOfflineActions(actions).then(function () {
|
|
|
|
return localassetmanager.deleteUserActions(actions).then(function () {
|
|
console.log('[mediasync] Exit reportOfflineActions (actions reported and deleted.)');
|
|
return Promise.resolve();
|
|
});
|
|
|
|
}, function (err) {
|
|
|
|
// delete those actions even on failure, because if the error is caused by
|
|
// the action data itself, this could otherwise lead to a situation that
|
|
// never gets resolved
|
|
console.error('[mediasync] error on apiClient.reportOfflineActions: ' + err.toString());
|
|
return localassetmanager.deleteUserActions(actions);
|
|
});
|
|
});
|
|
}
|
|
|
|
function syncData(apiClient, serverInfo, syncUserItemAccess) {
|
|
|
|
console.log('[mediasync] Begin syncData');
|
|
|
|
return localassetmanager.getServerItems(serverInfo.Id).then(function (items) {
|
|
|
|
var completedItems = items.filter(function (item) {
|
|
return (item) && ((item.SyncStatus === 'synced') || (item.SyncStatus === 'error'));
|
|
});
|
|
|
|
var request = {
|
|
TargetId: apiClient.deviceId(),
|
|
LocalItemIds: completedItems.map(function (xitem) { return xitem.ItemId; }),
|
|
OfflineUserIds: (serverInfo.Users || []).map(function (u) { return u.Id; })
|
|
};
|
|
|
|
return apiClient.syncData(request).then(function (result) {
|
|
|
|
return afterSyncData(apiClient, serverInfo, syncUserItemAccess, result).then(function () {
|
|
console.log('[mediasync] Exit syncData');
|
|
return Promise.resolve();
|
|
}, function (err) {
|
|
console.error('[mediasync] Error in syncData: ' + err.toString());
|
|
return Promise.resolve();
|
|
});
|
|
|
|
});
|
|
});
|
|
}
|
|
|
|
function afterSyncData(apiClient, serverInfo, enableSyncUserItemAccess, syncDataResult) {
|
|
|
|
console.log('[mediasync] Begin afterSyncData');
|
|
|
|
var p = Promise.resolve();
|
|
|
|
if (syncDataResult.ItemIdsToRemove) {
|
|
syncDataResult.ItemIdsToRemove.forEach(function (itemId) {
|
|
p = p.then(function () {
|
|
return removeLocalItem(itemId, serverInfo.Id);
|
|
});
|
|
});
|
|
}
|
|
|
|
if (enableSyncUserItemAccess) {
|
|
p = p.then(function () {
|
|
return syncUserItemAccess(syncDataResult, serverInfo.Id);
|
|
});
|
|
}
|
|
|
|
return p.then(function () {
|
|
console.log('[mediasync] Exit afterSyncData');
|
|
return Promise.resolve();
|
|
});
|
|
}
|
|
|
|
function removeLocalItem(itemId, serverId) {
|
|
|
|
console.log('[mediasync] Begin removeLocalItem');
|
|
|
|
return localassetmanager.getLocalItem(serverId, itemId).then(function (item) {
|
|
|
|
if (item) {
|
|
return localassetmanager.removeLocalItem(item);
|
|
}
|
|
|
|
return Promise.resolve();
|
|
|
|
});
|
|
}
|
|
|
|
function getNewMedia(apiClient, serverInfo, options, downloadCount) {
|
|
|
|
console.log('[mediasync] Begin getNewMedia');
|
|
|
|
return apiClient.getReadySyncItems(apiClient.deviceId()).then(function (jobItems) {
|
|
|
|
var p = Promise.resolve();
|
|
|
|
var maxDownloads = 10;
|
|
var currentCount = downloadCount;
|
|
|
|
jobItems.forEach(function (jobItem) {
|
|
if (currentCount++ <= maxDownloads) {
|
|
p = p.then(function () {
|
|
return getNewItem(jobItem, apiClient, serverInfo, options);
|
|
});
|
|
}
|
|
});
|
|
|
|
return p.then(function () {
|
|
console.log('[mediasync] Exit getNewMedia');
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
function getNewItem(jobItem, apiClient, serverInfo, options) {
|
|
|
|
console.log('[mediasync] Begin getNewItem');
|
|
|
|
var libraryItem = jobItem.Item;
|
|
|
|
return localassetmanager.getLocalItem(serverInfo.Id, libraryItem.Id).then(function (existingItem) {
|
|
|
|
if (existingItem) {
|
|
if (existingItem.SyncStatus === 'queued' || existingItem.SyncStatus === 'transferring' || existingItem.SyncStatus === 'synced') {
|
|
console.log('[mediasync] getNewItem: getLocalItem found existing item');
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
|
|
libraryItem.CanDelete = false;
|
|
libraryItem.CanDownload = false;
|
|
libraryItem.SupportsSync = false;
|
|
libraryItem.People = [];
|
|
libraryItem.UserData = [];
|
|
libraryItem.SpecialFeatureCount = null;
|
|
|
|
return localassetmanager.createLocalItem(libraryItem, serverInfo, jobItem).then(function (localItem) {
|
|
|
|
console.log('[mediasync] getNewItem: createLocalItem completed');
|
|
|
|
localItem.SyncStatus = 'queued';
|
|
|
|
return downloadParentItems(apiClient, jobItem, localItem, serverInfo, options).then(function () {
|
|
|
|
return downloadMedia(apiClient, jobItem, localItem, options).then(function () {
|
|
|
|
return getImages(apiClient, jobItem, localItem).then(function () {
|
|
|
|
return getSubtitles(apiClient, jobItem, localItem);
|
|
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
function downloadParentItems(apiClient, jobItem, localItem, serverInfo, options) {
|
|
|
|
var p = Promise.resolve();
|
|
|
|
var libraryItem = localItem.Item;
|
|
|
|
var itemType = (libraryItem.Type || '').toLowerCase();
|
|
var logoImageTag = (libraryItem.ImageTags || {}).Logo;
|
|
|
|
switch (itemType) {
|
|
case 'episode':
|
|
if (libraryItem.SeriesId && libraryItem.SeriesId) {
|
|
p = p.then(function () {
|
|
return downloadItem(apiClient, libraryItem, libraryItem.SeriesId, serverInfo).then(function (seriesItem) {
|
|
libraryItem.SeriesLogoImageTag = (seriesItem.Item.ImageTags || {}).Logo;
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
}
|
|
if (libraryItem.SeasonId && libraryItem.SeasonId) {
|
|
p = p.then(function () {
|
|
return downloadItem(apiClient, libraryItem, libraryItem.SeasonId, serverInfo).then(function (seasonItem) {
|
|
libraryItem.SeasonPrimaryImageTag = (seasonItem.Item.ImageTags || {}).Primary;
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
}
|
|
break;
|
|
|
|
case 'audio':
|
|
case 'photo':
|
|
if (libraryItem.AlbumId && libraryItem.AlbumId) {
|
|
p = p.then(function () {
|
|
return downloadItem(apiClient, libraryItem, libraryItem.AlbumId, serverInfo);
|
|
});
|
|
}
|
|
break;
|
|
|
|
case 'video':
|
|
case 'movie':
|
|
case 'musicvideo':
|
|
// no parent item download for now
|
|
break;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
function downloadItem(apiClient, libraryItem, itemId, serverInfo) {
|
|
|
|
return apiClient.getItem(apiClient.getCurrentUserId(), itemId).then(function (downloadedItem) {
|
|
|
|
downloadedItem.CanDelete = false;
|
|
downloadedItem.CanDownload = false;
|
|
downloadedItem.SupportsSync = false;
|
|
downloadedItem.People = [];
|
|
downloadedItem.UserData = {};
|
|
downloadedItem.SpecialFeatureCount = null;
|
|
downloadedItem.BackdropImageTags = null;
|
|
|
|
return localassetmanager.createLocalItem(downloadedItem, serverInfo, null).then(function (localItem) {
|
|
|
|
return localassetmanager.addOrUpdateLocalItem(localItem).then(function () {
|
|
return Promise.resolve(localItem);
|
|
});
|
|
});
|
|
}, function (err) {
|
|
|
|
console.error('[mediasync] downloadItem failed: ' + err.toString());
|
|
return Promise.resolve(null);
|
|
});
|
|
}
|
|
|
|
function downloadMedia(apiClient, jobItem, localItem, options) {
|
|
|
|
var url = apiClient.getUrl('Sync/JobItems/' + jobItem.SyncJobItemId + '/File', {
|
|
api_key: apiClient.accessToken()
|
|
});
|
|
|
|
var localPath = localItem.LocalPath;
|
|
|
|
console.log('[mediasync] Downloading media. Url: ' + url + '. Local path: ' + localPath);
|
|
|
|
options = options || {};
|
|
|
|
return localassetmanager.downloadFile(url, localItem).then(function (filename) {
|
|
|
|
localItem.SyncStatus = 'transferring';
|
|
return localassetmanager.addOrUpdateLocalItem(localItem);
|
|
});
|
|
}
|
|
|
|
function getImages(apiClient, jobItem, localItem) {
|
|
|
|
console.log('[mediasync] Begin getImages');
|
|
|
|
var p = Promise.resolve();
|
|
|
|
var libraryItem = localItem.Item;
|
|
|
|
var serverId = libraryItem.ServerId;
|
|
|
|
// case 0
|
|
var mainImageTag = (libraryItem.ImageTags || {}).Primary;
|
|
|
|
if (libraryItem.Id && mainImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.Id, mainImageTag, 'Primary');
|
|
});
|
|
}
|
|
|
|
// case 0a
|
|
var logoImageTag = (libraryItem.ImageTags || {}).Logo;
|
|
if (libraryItem.Id && logoImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.Id, logoImageTag, 'Logo');
|
|
});
|
|
}
|
|
|
|
// case 0b
|
|
var artImageTag = (libraryItem.ImageTags || {}).Art;
|
|
if (libraryItem.Id && artImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.Id, artImageTag, 'Art');
|
|
});
|
|
}
|
|
|
|
// case 0c
|
|
var bannerImageTag = (libraryItem.ImageTags || {}).Banner;
|
|
if (libraryItem.Id && bannerImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.Id, bannerImageTag, 'Banner');
|
|
});
|
|
}
|
|
|
|
// case 0d
|
|
var thumbImageTag = (libraryItem.ImageTags || {}).Thumb;
|
|
if (libraryItem.Id && thumbImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.Id, thumbImageTag, 'Thumb');
|
|
});
|
|
}
|
|
|
|
// Backdrops
|
|
//if (libraryItem.Id && libraryItem.BackdropImageTags) {
|
|
// for (var i = 0; i < libraryItem.BackdropImageTags.length; i++) {
|
|
|
|
// var backdropImageTag = libraryItem.BackdropImageTags[i];
|
|
|
|
// // use self-invoking function to simulate block-level variable scope
|
|
// (function (index, tag) {
|
|
// p = p.then(function () {
|
|
// return downloadImage(localItem, apiClient, serverId, libraryItem.Id, tag, 'backdrop', index);
|
|
// });
|
|
// })(i, backdropImageTag);
|
|
// }
|
|
//}
|
|
|
|
// case 1/2:
|
|
if (libraryItem.SeriesId && libraryItem.SeriesPrimaryImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.SeriesId, libraryItem.SeriesPrimaryImageTag, 'Primary');
|
|
});
|
|
}
|
|
|
|
if (libraryItem.SeriesId && libraryItem.SeriesThumbImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.SeriesId, libraryItem.SeriesThumbImageTag, 'Thumb');
|
|
});
|
|
}
|
|
|
|
if (libraryItem.SeriesId && libraryItem.SeriesLogoImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.SeriesId, libraryItem.SeriesLogoImageTag, 'Logo');
|
|
});
|
|
}
|
|
|
|
if (libraryItem.SeasonId && libraryItem.SeasonPrimaryImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.SeasonId, libraryItem.SeasonPrimaryImageTag, 'Primary');
|
|
});
|
|
}
|
|
|
|
// case 3:
|
|
if (libraryItem.AlbumId && libraryItem.AlbumPrimaryImageTag) {
|
|
p = p.then(function () {
|
|
return downloadImage(localItem, apiClient, serverId, libraryItem.AlbumId, libraryItem.AlbumPrimaryImageTag, 'Primary');
|
|
});
|
|
}
|
|
|
|
return p.then(function () {
|
|
console.log('[mediasync] Finished getImages');
|
|
return localassetmanager.addOrUpdateLocalItem(localItem);
|
|
}, function (err) {
|
|
console.log('[mediasync] Error getImages: ' + err.toString());
|
|
return Promise.resolve();
|
|
});
|
|
}
|
|
|
|
function downloadImage(localItem, apiClient, serverId, itemId, imageTag, imageType, index) {
|
|
|
|
|
|
index = index || 0;
|
|
|
|
return localassetmanager.hasImage(serverId, itemId, imageType, index).then(function (hasImage) {
|
|
|
|
if (hasImage) {
|
|
console.log('[mediasync] downloadImage - skip existing: ' + itemId + ' ' + imageType + '_' + index.toString());
|
|
return Promise.resolve();
|
|
}
|
|
|
|
var maxWidth = 400;
|
|
|
|
if (imageType === 'backdrop') {
|
|
maxWidth = null;
|
|
}
|
|
|
|
var imageUrl = apiClient.getScaledImageUrl(itemId, {
|
|
tag: imageTag,
|
|
type: imageType,
|
|
maxWidth: maxWidth,
|
|
api_key: apiClient.accessToken()
|
|
});
|
|
|
|
console.log('[mediasync] downloadImage ' + itemId + ' ' + imageType + '_' + index.toString());
|
|
|
|
return localassetmanager.downloadImage(localItem, imageUrl, serverId, itemId, imageType, index).then(function (result) {
|
|
return Promise.resolve();
|
|
}, function (err) {
|
|
console.log('[mediasync] Error downloadImage: ' + err.toString());
|
|
return Promise.resolve();
|
|
});
|
|
}, function (err) {
|
|
console.log('[mediasync] Error downloadImage: ' + err.toString());
|
|
return Promise.resolve();
|
|
});
|
|
}
|
|
|
|
function getSubtitles(apiClient, jobItem, localItem) {
|
|
|
|
console.log('[mediasync] Begin getSubtitles');
|
|
|
|
if (!jobItem.Item.MediaSources.length) {
|
|
console.log('[mediasync] Cannot download subtitles because video has no media source info.');
|
|
return Promise.resolve();
|
|
}
|
|
|
|
var files = jobItem.AdditionalFiles.filter(function (f) {
|
|
return f.Type === 'Subtitles';
|
|
});
|
|
|
|
var mediaSource = jobItem.Item.MediaSources[0];
|
|
|
|
var p = Promise.resolve();
|
|
|
|
files.forEach(function (file) {
|
|
p = p.then(function () {
|
|
return getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource);
|
|
});
|
|
});
|
|
|
|
return p.then(function () {
|
|
console.log('[mediasync] Exit getSubtitles');
|
|
return Promise.resolve();
|
|
});
|
|
}
|
|
|
|
function getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource) {
|
|
|
|
console.log('[mediasync] Begin getItemSubtitle');
|
|
|
|
var subtitleStream = mediaSource.MediaStreams.filter(function (m) {
|
|
return m.Type === 'Subtitle' && m.Index === file.Index;
|
|
})[0];
|
|
|
|
if (!subtitleStream) {
|
|
|
|
// We shouldn't get in here, but let's just be safe anyway
|
|
console.log('[mediasync] Cannot download subtitles because matching stream info was not found.');
|
|
return Promise.resolve();
|
|
}
|
|
|
|
var url = apiClient.getUrl('Sync/JobItems/' + jobItem.SyncJobItemId + '/AdditionalFiles', {
|
|
Name: file.Name,
|
|
api_key: apiClient.accessToken()
|
|
});
|
|
|
|
var fileName = localassetmanager.getSubtitleSaveFileName(localItem, jobItem.OriginalFileName, subtitleStream.Language, subtitleStream.IsForced, subtitleStream.Codec);
|
|
|
|
return localassetmanager.downloadSubtitles(url, fileName).then(function (subtitlePath) {
|
|
|
|
if (localItem.AdditionalFiles) {
|
|
localItem.AdditionalFiles.forEach(function (item) {
|
|
if (item.Name === file.Name) {
|
|
item.Path = subtitlePath;
|
|
}
|
|
});
|
|
}
|
|
|
|
subtitleStream.Path = subtitlePath;
|
|
return localassetmanager.addOrUpdateLocalItem(localItem);
|
|
});
|
|
}
|
|
|
|
return function () {
|
|
|
|
var self = this;
|
|
|
|
self.sync = function (apiClient, serverInfo, options) {
|
|
|
|
console.log('[mediasync]************************************* Start sync');
|
|
|
|
return processDownloadStatus(apiClient, serverInfo, options).then(function () {
|
|
|
|
return localassetmanager.getDownloadItemCount().then(function (downloadCount) {
|
|
|
|
if (options.syncCheckProgressOnly === true && downloadCount > 2) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
return reportOfflineActions(apiClient, serverInfo).then(function () {
|
|
|
|
// Download new content
|
|
return getNewMedia(apiClient, serverInfo, options, downloadCount).then(function () {
|
|
|
|
// Do the second data sync
|
|
return syncData(apiClient, serverInfo, false).then(function () {
|
|
console.log('[mediasync]************************************* Exit sync');
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
//});
|
|
});
|
|
});
|
|
}, function (err) {
|
|
console.error(err.toString());
|
|
});
|
|
};
|
|
};
|
|
|
|
//function syncUserItemAccess(syncDataResult, serverId) {
|
|
// console.log('[mediasync] Begin syncUserItemAccess');
|
|
|
|
// var itemIds = [];
|
|
// for (var id in syncDataResult.ItemUserAccess) {
|
|
// itemIds.push(id);
|
|
// }
|
|
|
|
// return syncNextUserAccessForItem(itemIds, 0, syncDataResult, serverId);
|
|
//}
|
|
|
|
//function syncNextUserAccessForItem(itemIds, index, syncDataResult, serverId) {
|
|
|
|
// var length = itemIds.length;
|
|
|
|
// if (index >= length) {
|
|
|
|
// return Promise.resolve
|
|
// return;
|
|
// }
|
|
|
|
// syncUserAccessForItem(itemIds[index], syncDataResult).then(function () {
|
|
|
|
// syncNextUserAccessForItem(itemIds, index + 1, syncDataResult, serverId, deferred);
|
|
// }, function () {
|
|
// syncNextUserAccessForItem(itemIds, index + 1, syncDataResult, serverId, deferred);
|
|
// });
|
|
//}
|
|
|
|
//function syncUserAccessForItem(itemId, syncDataResult) {
|
|
// console.log('[mediasync] Begin syncUserAccessForItem');
|
|
|
|
// var deferred = DeferredBuilder.Deferred();
|
|
|
|
// localassetmanager.getUserIdsWithAccess(itemId, serverId).then(function (savedUserIdsWithAccess) {
|
|
|
|
// var userIdsWithAccess = syncDataResult.ItemUserAccess[itemId];
|
|
|
|
// if (userIdsWithAccess.join(',') === savedUserIdsWithAccess.join(',')) {
|
|
// // Hasn't changed, nothing to do
|
|
// deferred.resolve();
|
|
// }
|
|
// else {
|
|
|
|
// localassetmanager.saveUserIdsWithAccess(itemId, serverId, userIdsWithAccess).then(function () {
|
|
// deferred.resolve();
|
|
// }, getOnFail(deferred));
|
|
// }
|
|
|
|
// }, getOnFail(deferred));
|
|
|
|
// return deferred.promise();
|
|
//}
|
|
|
|
//}
|
|
|
|
}); |