get api libs from bower

dashboard-ui/bower_components/emby-apiclient/.bower.json

@@ -0,0 +1,29 @@
+{
+  "name": "emby-apiclient",
+  "main": "apiclient.js",
+  "authors": [
+    "The Emby Authors"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/MediaBrowser/Emby.ApiClient.Javascript.git"
+  },
+  "license": "https://github.com/MediaBrowser/Emby.ApiClient.Javascript/blob/master/LICENSE",
+  "homepage": "https://github.com/MediaBrowser/Emby.ApiClient.Javascript",
+  "dependencies": {
+    "cryptojslib": "cryptojslib#^3.1.2"
+  },
+  "devDependencies": {},
+  "ignore": [],
+  "version": "1.0.3",
+  "_release": "1.0.3",
+  "_resolution": {
+    "type": "version",
+    "tag": "1.0.3",
+    "commit": "8e6266950e05e2d032d62340cb7307a3d19a23ec"
+  },
+  "_source": "git://github.com/MediaBrowser/Emby.ApiClient.Javascript.git",
+  "_target": "~1.0.3",
+  "_originalSource": "emby-apiclient",
+  "_direct": true
+}

dashboard-ui/bower_components/emby-apiclient/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Emby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

dashboard-ui/bower_components/emby-apiclient/bower.json

@@ -0,0 +1,20 @@
+{
+  "name": "emby-apiclient",
+  "main": "apiclient.js",
+  "authors": [
+    "The Emby Authors"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/MediaBrowser/Emby.ApiClient.Javascript.git"
+  },
+  "license": "https://github.com/MediaBrowser/Emby.ApiClient.Javascript/blob/master/LICENSE",
+  "homepage": "https://github.com/MediaBrowser/Emby.ApiClient.Javascript",
+  "dependencies": {
+    "cryptojslib": "cryptojslib#^3.1.2"
+  },
+  "devDependencies": {
+    
+  },
+  "ignore": []
+}

dashboard-ui/bower_components/emby-apiclient/connectservice.js

@@ -0,0 +1,34 @@
+(function (globalScope) {
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    function replaceAll(str, find, replace) {
+
+        return str.split(find).join(replace);
+    }
+
+    var connectService = {
+
+        cleanPassword: function (password) {
+
+            password = password || '';
+
+            password = replaceAll(password, "&", "&");
+            password = replaceAll(password, "/", "\");
+            password = replaceAll(password, "!", "!");
+            password = replaceAll(password, "$", "$");
+            password = replaceAll(password, "\"", """);
+            password = replaceAll(password, "<", "&lt;");
+            password = replaceAll(password, ">", "&gt;");
+            password = replaceAll(password, "'", "&#39;");
+
+            return password;
+        }
+
+    };
+
+    globalScope.MediaBrowser.ConnectService = connectService;
+
+})(window);

dashboard-ui/bower_components/emby-apiclient/credentials.js

@@ -0,0 +1,131 @@
+(function (globalScope, JSON) {
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.CredentialProvider = function (key) {
+
+        var self = this;
+        var credentials = null;
+        key = key || 'servercredentials3';
+
+        function ensure() {
+
+            if (!credentials) {
+
+                var json = appStorage.getItem(key) || '{}';
+
+                Logger.log('credentials initialized with: ' + json);
+                credentials = JSON.parse(json);
+                credentials.Servers = credentials.Servers || [];
+            }
+        }
+
+        function get() {
+
+            ensure();
+            return credentials;
+        }
+
+        function set(data) {
+
+            if (data) {
+                credentials = data;
+                appStorage.setItem(key, JSON.stringify(data));
+            } else {
+                self.clear();
+            }
+
+            Events.trigger(self, 'credentialsupdated');
+        }
+
+        self.clear = function () {
+            credentials = null;
+            appStorage.removeItem(key);
+        };
+
+        self.credentials = function (data) {
+
+            if (data) {
+                set(data);
+            }
+
+            return get();
+        };
+
+        self.addOrUpdateServer = function (list, server) {
+
+            if (!server.Id) {
+                throw new Error('Server.Id cannot be null or empty');
+            }
+
+            var existing = list.filter(function (s) {
+                return s.Id == server.Id;
+            })[0];
+
+            if (existing) {
+
+                // Merge the data
+                existing.DateLastAccessed = Math.max(existing.DateLastAccessed || 0, server.DateLastAccessed || 0);
+
+                existing.UserLinkType = server.UserLinkType;
+
+                if (server.AccessToken) {
+                    existing.AccessToken = server.AccessToken;
+                    existing.UserId = server.UserId;
+                }
+                if (server.ExchangeToken) {
+                    existing.ExchangeToken = server.ExchangeToken;
+                }
+                if (server.RemoteAddress) {
+                    existing.RemoteAddress = server.RemoteAddress;
+                }
+                if (server.ManualAddress) {
+                    existing.ManualAddress = server.ManualAddress;
+                }
+                if (server.LocalAddress) {
+                    existing.LocalAddress = server.LocalAddress;
+                }
+                if (server.Name) {
+                    existing.Name = server.Name;
+                }
+                if (server.WakeOnLanInfos && server.WakeOnLanInfos.length) {
+                    existing.WakeOnLanInfos = server.WakeOnLanInfos;
+                }
+                if (server.LastConnectionMode != null) {
+                    existing.LastConnectionMode = server.LastConnectionMode;
+                }
+                if (server.ConnectServerId) {
+                    existing.ConnectServerId = server.ConnectServerId;
+                }
+                existing.DateLastLocalConnection = Math.max(existing.DateLastLocalConnection || 0, server.DateLastLocalConnection || 0);
+
+                return existing;
+            }
+            else {
+                list.push(server);
+                return server;
+            }
+        };
+
+        self.addOrUpdateUser = function (server, user) {
+
+            server.Users = server.Users || [];
+
+            var existing = server.Users.filter(function (s) {
+                return s.Id == user.Id;
+            })[0];
+
+            if (existing) {
+
+                // Merge the data
+                existing.IsSignedInOffline = true;
+            }
+            else {
+                server.Users.push(user);
+            }
+        };
+    };
+
+})(window, window.JSON);

dashboard-ui/bower_components/emby-apiclient/deferred.js

@@ -0,0 +1,16 @@
+(function (globalScope) {
+
+    globalScope.DeferredBuilder = {
+
+        Deferred: function () {
+            return jQuery.Deferred();
+        },
+
+        when: function (promises) {
+
+            return jQuery.when(promises);
+        }
+
+    };
+
+})(window);

dashboard-ui/bower_components/emby-apiclient/events.js

@@ -0,0 +1,20 @@
+(function (globalScope) {
+
+    globalScope.Events = {
+
+        on: function (obj, eventName, selector, fn) {
+
+            jQuery(obj).on(eventName, selector, fn);
+        },
+
+        off: function (obj, eventName, selector, fn) {
+
+            jQuery(obj).off(eventName, selector, fn);
+        },
+
+        trigger: function (obj, eventName, params) {
+            jQuery(obj).trigger(eventName, params);
+        }
+    };
+
+})(window);

dashboard-ui/bower_components/emby-apiclient/fileupload.js

@@ -0,0 +1,22 @@
+(function (globalScope) {
+
+    function fileUpload() {
+
+        var self = this;
+
+        self.upload = function (file, name, url) {
+
+            return new Promise(function (resolve, reject) {
+
+                reject();
+            });
+        };
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.FileUpload = fileUpload;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/localassetmanager.js

@@ -0,0 +1,130 @@
+(function () {
+
+    function getLocalMediaSource(serverId, itemId) {
+        return new Promise(function (resolve, reject) {
+            resolve(null);
+        });
+    }
+
+    function saveOfflineUser(user) {
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function deleteOfflineUser(id) {
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function getCameraPhotos() {
+        return new Promise(function (resolve, reject) {
+            resolve([]);
+        });
+    }
+
+    function getOfflineActions(serverId) {
+        return new Promise(function (resolve, reject) {
+            resolve([]);
+        });
+    }
+
+    function deleteOfflineActions(actions) {
+        return new Promise(function (resolve, reject) {
+            resolve([]);
+        });
+    }
+
+    function getServerItemIds(serverId) {
+        return new Promise(function (resolve, reject) {
+            resolve([]);
+        });
+    }
+
+    function removeLocalItem(itemId, serverId) {
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function getLocalItem(itemId, serverId) {
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function addOrUpdateLocalItem(localItem) {
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function createLocalItem(libraryItem, serverInfo, originalFileName) {
+
+        return new Promise(function (resolve, reject) {
+            resolve({});
+        });
+    }
+
+    function downloadFile(url, localPath) {
+
+        return new Promise(function (resolve, reject) {
+            resolve();
+        });
+    }
+
+    function downloadSubtitles(url, localItem, subtitleStreamh) {
+
+        return new Promise(function (resolve, reject) {
+            resolve("");
+        });
+    }
+
+    function hasImage(serverId, itemId, imageTag) {
+        return new Promise(function (resolve, reject) {
+            resolve(false);
+        });
+    }
+
+    function downloadImage(url, serverId, itemId, imageTag) {
+        return new Promise(function (resolve, reject) {
+            resolve(false);
+        });
+    }
+
+    function fileExists(path) {
+
+        return new Promise(function (resolve, reject) {
+            resolve(false);
+        });
+    }
+
+    function translateFilePath(path) {
+
+        return new Promise(function (resolve, reject) {
+            resolve(path);
+        });
+    }
+
+    window.LocalAssetManager = {
+        getLocalMediaSource: getLocalMediaSource,
+        saveOfflineUser: saveOfflineUser,
+        deleteOfflineUser: deleteOfflineUser,
+        getCameraPhotos: getCameraPhotos,
+        getOfflineActions: getOfflineActions,
+        deleteOfflineActions: deleteOfflineActions,
+        getServerItemIds: getServerItemIds,
+        removeLocalItem: removeLocalItem,
+        getLocalItem: getLocalItem,
+        addOrUpdateLocalItem: addOrUpdateLocalItem,
+        createLocalItem: createLocalItem,
+        downloadFile: downloadFile,
+        downloadSubtitles: downloadSubtitles,
+        hasImage: hasImage,
+        downloadImage: downloadImage,
+        fileExists: fileExists,
+        translateFilePath: translateFilePath
+    };
+
+})();

dashboard-ui/bower_components/emby-apiclient/logger.js

@@ -0,0 +1,6 @@
+var Logger = {
+
+    log: function (str) {
+        console.log(str);
+    }
+};

dashboard-ui/bower_components/emby-apiclient/serverdiscovery.js

@@ -0,0 +1,18 @@
+define([], function () {
+
+    return {
+
+        findServers: function (timeoutMs) {
+
+            return new Promise(function (resolve, reject) {
+
+                var servers = [];
+
+                // Expected server properties
+                // Name, Id, Address, EndpointAddress (optional)
+                resolve(servers);
+            });
+        }
+    };
+
+});

dashboard-ui/bower_components/emby-apiclient/store.js

@@ -0,0 +1,51 @@
+(function (globalScope, localStorage, sessionStorage) {
+
+    function myStore(defaultObject) {
+
+        var self = this;
+        self.localData = {};
+
+        var isDefaultAvailable;
+
+        if (defaultObject) {
+            try {
+                defaultObject.setItem('_test', '0');
+                defaultObject.removeItem('_test');
+                isDefaultAvailable = true;
+            } catch (e) {
+
+            }
+        }
+
+        self.setItem = function (name, value) {
+
+            if (isDefaultAvailable) {
+                defaultObject.setItem(name, value);
+            } else {
+                self.localData[name] = value;
+            }
+        };
+
+        self.getItem = function (name) {
+
+            if (isDefaultAvailable) {
+                return defaultObject.getItem(name);
+            }
+
+            return self.localData[name];
+        };
+
+        self.removeItem = function (name) {
+
+            if (isDefaultAvailable) {
+                defaultObject.removeItem(name);
+            } else {
+                self.localData[name] = null;
+            }
+        };
+    }
+
+    globalScope.appStorage = new myStore(localStorage);
+    globalScope.sessionStore = new myStore(sessionStorage);
+
+})(window, window.localStorage, window.sessionStorage);

dashboard-ui/bower_components/emby-apiclient/sync/contentuploader.js

@@ -0,0 +1,118 @@
+(function (globalScope) {
+
+    function contentUploader(connectionManager) {
+
+        var self = this;
+
+        self.uploadImages = function (server) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            LocalAssetManager.getCameraPhotos().then(function (photos) {
+
+                if (!photos.length) {
+                    deferred.resolve();
+                    return;
+                }
+
+                var apiClient = connectionManager.getApiClient(server.Id);
+
+                apiClient.getContentUploadHistory().then(function (uploadHistory) {
+
+                    photos = getFilesToUpload(photos, uploadHistory);
+
+                    Logger.log('Found ' + photos.length + ' files to upload');
+
+                    uploadNext(photos, 0, server, apiClient, deferred);
+
+                }, function () {
+                    deferred.reject();
+                });
+
+            }, function () {
+                deferred.reject();
+            });
+
+            return deferred.promise();
+        };
+
+        function getFilesToUpload(files, uploadHistory) {
+
+            return files.filter(function (file) {
+
+                // Seeing some null entries for some reason
+                if (!file) {
+                    return false;
+                }
+
+                return uploadHistory.FilesUploaded.filter(function (u) {
+
+                    return getUploadId(file) == u.Id;
+
+                }).length == 0;
+            });
+        }
+
+        function getUploadId(file) {
+            return CryptoJS.SHA1(file + "1").toString();
+        }
+
+        function uploadNext(files, index, server, apiClient, deferred) {
+
+            var length = files.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            uploadFile(files[index], apiClient).then(function () {
+
+                uploadNext(files, index + 1, server, apiClient, deferred);
+            }, function () {
+                uploadNext(files, index + 1, server, apiClient, deferred);
+            });
+        }
+
+        function uploadFile(file, apiClient) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['fileupload', "cryptojs-sha1"], function () {
+
+                var name = 'camera image ' + new Date().getTime();
+
+                var url = apiClient.getUrl('Devices/CameraUploads', {
+                    DeviceId: apiClient.deviceId(),
+                    Name: name,
+                    Album: 'Camera Roll',
+                    Id: getUploadId(file),
+                    api_key: apiClient.accessToken()
+                });
+
+                Logger.log('Uploading file to ' + url);
+
+                new MediaBrowser.FileUpload().upload(file, name, url).then(function () {
+
+                    Logger.log('File upload succeeded');
+                    deferred.resolve();
+
+                }, function () {
+
+                    Logger.log('File upload failed');
+                    deferred.reject();
+                });
+            });
+
+            return deferred.promise();
+        }
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.ContentUploader = contentUploader;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/sync/mediasync.js

@@ -0,0 +1,536 @@
+(function (globalScope) {
+
+    function mediaSync() {
+
+        var self = this;
+
+        self.sync = function (apiClient, serverInfo, options) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            reportOfflineActions(apiClient, serverInfo).then(function () {
+
+                // Do the first data sync
+                syncData(apiClient, serverInfo, false).then(function () {
+
+                    // Download new content
+                    getNewMedia(apiClient, serverInfo, options).then(function () {
+
+                        // Do the second data sync
+                        syncData(apiClient, serverInfo, false).then(function () {
+
+                            deferred.resolve();
+
+                        }, getOnFail(deferred));
+
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+
+            }, getOnFail(deferred));
+
+            return deferred.promise();
+        };
+
+        function reportOfflineActions(apiClient, serverInfo) {
+
+            Logger.log('Begin reportOfflineActions');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                LocalAssetManager.getOfflineActions(serverInfo.Id).then(function (actions) {
+
+                    if (!actions.length) {
+                        deferred.resolve();
+                        return;
+                    }
+
+                    apiClient.reportOfflineActions(actions).then(function () {
+
+                        LocalAssetManager.deleteOfflineActions(actions).then(function () {
+
+                            deferred.resolve();
+
+                        }, getOnFail(deferred));
+
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+            });
+
+            return deferred.promise();
+        }
+
+        function syncData(apiClient, serverInfo, syncUserItemAccess) {
+
+            Logger.log('Begin syncData');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                LocalAssetManager.getServerItemIds(serverInfo.Id).then(function (localIds) {
+
+                    var request = {
+                        TargetId: apiClient.deviceId(),
+                        LocalItemIds: localIds,
+                        OfflineUserIds: (serverInfo.Users || []).map(function (u) { return u.Id; })
+                    };
+
+                    apiClient.syncData(request).then(function (result) {
+
+                        afterSyncData(apiClient, serverInfo, syncUserItemAccess, result, deferred);
+
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+            });
+
+            return deferred.promise();
+        }
+
+        function afterSyncData(apiClient, serverInfo, enableSyncUserItemAccess, syncDataResult, deferred) {
+
+            Logger.log('Begin afterSyncData');
+
+            removeLocalItems(syncDataResult, serverInfo.Id).then(function (result) {
+
+                if (enableSyncUserItemAccess) {
+                    syncUserItemAccess(syncDataResult, serverInfo.Id).then(function () {
+
+                        deferred.resolve();
+
+                    }, getOnFail(deferred));
+                }
+                else {
+                    deferred.resolve();
+                }
+
+            }, getOnFail(deferred));
+
+            deferred.resolve();
+        }
+
+        function removeLocalItems(syncDataResult, serverId) {
+
+            Logger.log('Begin removeLocalItems');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            removeNextLocalItem(syncDataResult.ItemIdsToRemove, 0, serverId, deferred);
+
+            return deferred.promise();
+        }
+
+        function removeNextLocalItem(itemIdsToRemove, index, serverId, deferred) {
+
+            var length = itemIdsToRemove.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            removeLocalItem(itemIdsToRemove[index], serverId).then(function () {
+
+                removeNextLocalItem(itemIdsToRemove, index + 1, serverId, deferred);
+            }, function () {
+                removeNextLocalItem(itemIdsToRemove, index + 1, serverId, deferred);
+            });
+        }
+
+        function removeLocalItem(itemId, serverId) {
+
+            Logger.log('Begin removeLocalItem');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                LocalAssetManager.removeLocalItem(itemId, serverId).then(function (localIds) {
+
+                    deferred.resolve();
+
+                }, getOnFail(deferred));
+            });
+
+            return deferred.promise();
+        }
+
+        function getNewMedia(apiClient, serverInfo, options) {
+
+            Logger.log('Begin getNewMedia');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            apiClient.getReadySyncItems(apiClient.deviceId()).then(function (jobItems) {
+
+                getNextNewItem(jobItems, 0, apiClient, serverInfo, options, deferred);
+
+            }, getOnFail(deferred));
+
+            return deferred.promise();
+        }
+
+        function getNextNewItem(jobItems, index, apiClient, serverInfo, options, deferred) {
+
+            var length = jobItems.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            var hasGoneNext = false;
+            var goNext = function () {
+
+                if (!hasGoneNext) {
+                    hasGoneNext = true;
+                    getNextNewItem(jobItems, index + 1, apiClient, serverInfo, options, deferred);
+                }
+            };
+
+            getNewItem(jobItems[index], apiClient, serverInfo, options).then(goNext, goNext);
+        }
+
+        function getNewItem(jobItem, apiClient, serverInfo, options) {
+
+            Logger.log('Begin getNewItem');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                var libraryItem = jobItem.Item;
+                LocalAssetManager.createLocalItem(libraryItem, serverInfo, jobItem.OriginalFileName).then(function (localItem) {
+
+                    downloadMedia(apiClient, jobItem, localItem, options).then(function (isQueued) {
+
+                        if (isQueued) {
+                            deferred.resolve();
+                            return;
+                        }
+
+                        getImages(apiClient, jobItem, localItem).then(function () {
+
+                            getSubtitles(apiClient, jobItem, localItem).then(function () {
+
+                                apiClient.reportSyncJobItemTransferred(jobItem.SyncJobItemId).then(function () {
+
+                                    deferred.resolve();
+
+                                }, getOnFail(deferred));
+
+                            }, getOnFail(deferred));
+
+                        }, getOnFail(deferred));
+
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+            });
+
+            return deferred.promise();
+        }
+
+        function downloadMedia(apiClient, jobItem, localItem, options) {
+
+            Logger.log('Begin downloadMedia');
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                var url = apiClient.getUrl("Sync/JobItems/" + jobItem.SyncJobItemId + "/File", {
+                    api_key: apiClient.accessToken()
+                });
+
+                var localPath = localItem.LocalPath;
+
+                Logger.log('Downloading media. Url: ' + url + '. Local path: ' + localPath);
+
+                options = options || {};
+
+                LocalAssetManager.downloadFile(url, localPath, options.enableBackgroundTransfer, options.enableNewDownloads).then(function (path, isQueued) {
+
+                    if (isQueued) {
+                        deferred.resolveWith(null, [true]);
+                        return;
+                    }
+                    LocalAssetManager.addOrUpdateLocalItem(localItem).then(function () {
+
+                        deferred.resolveWith(null, [false]);
+
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+
+            });
+
+            return deferred.promise();
+        }
+
+        function getImages(apiClient, jobItem, localItem) {
+
+            Logger.log('Begin getImages');
+            var deferred = DeferredBuilder.Deferred();
+
+            getNextImage(0, apiClient, localItem, deferred);
+
+            return deferred.promise();
+        }
+
+        function getNextImage(index, apiClient, localItem, deferred) {
+
+            Logger.log('Begin getNextImage');
+            if (index >= 4) {
+
+                deferred.resolve();
+                return;
+            }
+
+            // Just for now while media syncing gets worked out
+            deferred.resolve();
+            return;
+
+            var libraryItem = localItem.Item;
+
+            var serverId = libraryItem.ServerId;
+            var itemId = null;
+            var imageTag = null;
+            var imageType = "Primary";
+
+            switch (index) {
+
+                case 0:
+                    itemId = libraryItem.Id;
+                    imageType = "Primary";
+                    imageTag = (libraryItem.ImageTags || {})["Primary"];
+                    break;
+                case 1:
+                    itemId = libraryItem.SeriesId;
+                    imageType = "Primary";
+                    imageTag = libraryItem.SeriesPrimaryImageTag;
+                    break;
+                case 2:
+                    itemId = libraryItem.SeriesId;
+                    imageType = "Thumb";
+                    imageTag = libraryItem.SeriesPrimaryImageTag;
+                    break;
+                case 3:
+                    itemId = libraryItem.AlbumId;
+                    imageType = "Primary";
+                    imageTag = libraryItem.AlbumPrimaryImageTag;
+                    break;
+                default:
+                    break;
+            }
+
+            if (!itemId || !imageTag) {
+                getNextImage(index + 1, apiClient, localItem, deferred);
+                return;
+            }
+
+            downloadImage(apiClient, serverId, itemId, imageTag, imageType).then(function () {
+
+                // For the sake of simplicity, limit to one image
+                deferred.resolve();
+                return;
+
+                getNextImage(index + 1, apiClient, localItem, deferred);
+
+            }, getOnFail(deferred));
+        }
+
+        function downloadImage(apiClient, serverId, itemId, imageTag, imageType) {
+
+            Logger.log('Begin downloadImage');
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                LocalAssetManager.hasImage(serverId, itemId, imageTag).then(function (hasImage) {
+
+                    if (hasImage) {
+                        deferred.resolve();
+                        return;
+                    }
+
+                    var imageUrl = apiClient.getImageUrl(itemId, {
+                        tag: imageTag,
+                        type: imageType,
+                        api_key: apiClient.accessToken()
+                    });
+
+                    LocalAssetManager.downloadImage(imageUrl, serverId, itemId, imageTag).then(function () {
+
+                        deferred.resolve();
+
+                    }, getOnFail(deferred));
+
+                });
+            });
+
+            return deferred.promise();
+        }
+
+        function getSubtitles(apiClient, jobItem, localItem) {
+
+            Logger.log('Begin getSubtitles');
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                if (!jobItem.Item.MediaSources.length) {
+                    logger.Error("Cannot download subtitles because video has no media source info.");
+                    deferred.resolve();
+                    return;
+                }
+
+                var files = jobItem.AdditionalFiles.filter(function (f) {
+                    return f.Type == 'Subtitles';
+                });
+
+                var mediaSource = jobItem.Item.MediaSources[0];
+
+                getNextSubtitle(files, 0, apiClient, jobItem, localItem, mediaSource, deferred);
+            });
+
+            return deferred.promise();
+        }
+
+        function getNextSubtitle(files, index, apiClient, jobItem, localItem, mediaSource, deferred) {
+
+            var length = files.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource).then(function () {
+
+                getNextSubtitle(files, index + 1, apiClient, jobItem, localItem, mediaSource, deferred);
+
+            }, function () {
+                getNextSubtitle(files, index + 1, apiClient, jobItem, localItem, mediaSource, deferred);
+            });
+        }
+
+        function getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource) {
+
+            Logger.log('Begin getItemSubtitle');
+            var deferred = DeferredBuilder.Deferred();
+
+            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
+                Logger.log("Cannot download subtitles because matching stream info wasn't found.");
+                deferred.reject();
+                return;
+            }
+
+            var url = apiClient.getUrl("Sync/JobItems/" + jobItem.SyncJobItemId + "/AdditionalFiles", {
+                Name: file.Name,
+                api_key: apiClient.accessToken()
+            });
+
+            require(['localassetmanager'], function () {
+
+                LocalAssetManager.downloadSubtitles(url, localItem, subtitleStream).then(function (subtitlePath) {
+
+                    subtitleStream.Path = subtitlePath;
+                    LocalAssetManager.addOrUpdateLocalItem(localItem).then(function () {
+                        deferred.resolve();
+                    }, getOnFail(deferred));
+
+                }, getOnFail(deferred));
+            });
+
+            return deferred.promise();
+        }
+
+        function syncUserItemAccess(syncDataResult, serverId) {
+            Logger.log('Begin syncUserItemAccess');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            var itemIds = [];
+            for (var id in syncDataResult.ItemUserAccess) {
+                itemIds.push(id);
+            }
+
+            syncNextUserAccessForItem(itemIds, 0, syncDataResult, serverId, deferred);
+
+            return deferred.promise();
+        }
+
+        function syncNextUserAccessForItem(itemIds, index, syncDataResult, serverId, deferred) {
+
+            var length = itemIds.length;
+
+            if (index >= length) {
+
+                deferred.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) {
+            Logger.log('Begin syncUserAccessForItem');
+
+            var deferred = DeferredBuilder.Deferred();
+
+            require(['localassetmanager'], function () {
+
+                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();
+        }
+
+        function getOnFail(deferred) {
+            return function () {
+
+                deferred.reject();
+            };
+        }
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.MediaSync = mediaSync;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/sync/multiserversync.js

@@ -0,0 +1,52 @@
+(function (globalScope) {
+
+    function multiServerSync(connectionManager) {
+
+        var self = this;
+
+        self.sync = function (options) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            var servers = connectionManager.getSavedServers();
+
+            syncNext(servers, 0, options, deferred);
+
+            return deferred.promise();
+        };
+
+        function syncNext(servers, index, options, deferred) {
+
+            var length = servers.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            var server = servers[index];
+
+            Logger.log("Creating ServerSync to server: " + server.Id);
+
+            require(['serversync'], function () {
+
+                new MediaBrowser.ServerSync(connectionManager).sync(server, options).then(function () {
+
+                    syncNext(servers, index + 1, options, deferred);
+
+                }, function () {
+
+                    syncNext(servers, index + 1, options, deferred);
+                });
+            });
+        }
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.MultiServerSync = multiServerSync;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/sync/offlineusersync.js

@@ -0,0 +1,75 @@
+(function (globalScope) {
+
+    function offlineUserSync() {
+
+        var self = this;
+
+        self.sync = function (apiClient, server) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            var users = server.Users || [];
+            syncNext(users, 0, deferred, apiClient, server);
+
+            return deferred.promise();
+        };
+
+        function syncNext(users, index, deferred, apiClient, server) {
+
+            var length = users.length;
+
+            if (index >= length) {
+
+                deferred.resolve();
+                return;
+            }
+
+            syncUser(users[index], apiClient).then(function () {
+
+                syncNext(users, index + 1, deferred, apiClient, server);
+            }, function () {
+                syncNext(users, index + 1, deferred, apiClient, server);
+            });
+        }
+
+        function syncUser(user, apiClient) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            apiClient.getOfflineUser(user.Id).then(function (result) {
+
+                require(['localassetmanager'], function () {
+
+                    LocalAssetManager.saveOfflineUser(result).then(function () {
+                        deferred.resolve();
+                    }, function () {
+                        deferred.resolve();
+                    });
+                });
+
+            }, function () {
+
+                // TODO: We should only delete if there's a 401 response
+
+                require(['localassetmanager'], function () {
+
+                    LocalAssetManager.deleteOfflineUser(user.Id).then(function () {
+                        deferred.resolve();
+                    }, function () {
+                        deferred.resolve();
+                    });
+                });
+            });
+
+            return deferred.promise();
+        }
+
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.OfflineUserSync = offlineUserSync;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/sync/serversync.js

@@ -0,0 +1,134 @@
+(function (globalScope) {
+
+    function serverSync(connectionManager) {
+
+        var self = this;
+
+        self.sync = function (server, options) {
+
+            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 deferred.promise();
+            }
+
+            var connectionOptions = {
+                updateDateLastAccessed: false,
+                enableWebSocket: false,
+                reportCapabilities: false
+            };
+
+            connectionManager.connectToServer(server, connectionOptions).then(function (result) {
+
+                if (result.State == MediaBrowser.ConnectionState.SignedIn) {
+                    performSync(server, options, deferred);
+                } else {
+                    Logger.log('Unable to connect to server id: ' + server.Id);
+                    deferred.reject();
+                }
+
+            }, function () {
+
+                Logger.log('Unable to connect to server id: ' + server.Id);
+                deferred.reject();
+            });
+
+            return deferred.promise();
+        };
+
+        function performSync(server, options, deferred) {
+
+            Logger.log("Creating ContentUploader to server: " + server.Id);
+
+            var nextAction = function () {
+                syncOfflineUsers(server, options, deferred);
+            };
+
+            options = options || {};
+
+            var uploadPhotos = options.uploadPhotos !== false;
+
+            if (options.cameraUploadServers && options.cameraUploadServers.indexOf(server.Id) == -1) {
+                uploadPhotos = false;
+            }
+
+            if (!uploadPhotos) {
+                nextAction();
+                return;
+            }
+
+            require(['contentuploader'], function () {
+
+                new MediaBrowser.ContentUploader(connectionManager).uploadImages(server).then(function () {
+
+                    Logger.log("ContentUploaded succeeded to server: " + server.Id);
+
+                    nextAction();
+
+                }, function () {
+
+                    Logger.log("ContentUploaded failed to server: " + server.Id);
+
+                    nextAction();
+                });
+            });
+        }
+
+        function syncOfflineUsers(server, options, deferred) {
+
+            if (options.syncOfflineUsers === false) {
+                syncMedia(server, options, deferred);
+                return;
+            }
+
+            require(['offlineusersync'], function () {
+
+                var apiClient = connectionManager.getApiClient(server.Id);
+
+                new MediaBrowser.OfflineUserSync().sync(apiClient, server).then(function () {
+
+                    Logger.log("OfflineUserSync succeeded to server: " + server.Id);
+
+                    syncMedia(server, options, deferred);
+
+                }, function () {
+
+                    Logger.log("OfflineUserSync failed to server: " + server.Id);
+
+                    deferred.reject();
+                });
+            });
+        }
+
+        function syncMedia(server, options, deferred) {
+
+            require(['mediasync'], function () {
+
+                var apiClient = connectionManager.getApiClient(server.Id);
+
+                new MediaBrowser.MediaSync().sync(apiClient, server, options).then(function () {
+
+                    Logger.log("MediaSync succeeded to server: " + server.Id);
+
+                    deferred.resolve();
+
+                }, function () {
+
+                    Logger.log("MediaSync failed to server: " + server.Id);
+
+                    deferred.reject();
+                });
+            });
+        }
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.ServerSync = serverSync;
+
+})(this);

dashboard-ui/bower_components/emby-apiclient/wakeonlan.js

@@ -0,0 +1,15 @@
+define([], function () {
+
+    function send(info) {
+
+        return new Promise(function (resolve, reject) {
+
+            resolve();
+        });
+    }
+
+    return {
+        send: send
+    };
+
+});