update camera upload

dashboard-ui/apiclient/apiclient.js

@@ -398,7 +398,7 @@
 
         self.openWebSocket = function () {
 
-            var accessToken = self.serverInfo().AccessToken;
+            var accessToken = self.accessToken();
 
             if (!accessToken) {
                 throw new Error("Cannot open web socket without access token.");
@@ -653,7 +653,7 @@
                 self.setAuthenticationInfo(null, null);
             };
 
-            if (self.serverInfo().AccessToken) {
+            if (self.accessToken()) {
                 var url = self.getUrl("Sessions/Logout");
 
                 return self.ajax({
@@ -663,8 +663,9 @@
             }
 
             var deferred = DeferredBuilder.Deferred();
+            done();
             deferred.resolveWith(null, []);
-            return deferred.promise().always(done);
+            return deferred.promise();
         };
 
         function getRemoteImagePrefix(options) {
@@ -2222,6 +2223,25 @@
             });
         };
 
+        /**
+         * Gets a user by id
+         * @param {String} id
+         */
+        self.getOfflineUser = function (id) {
+
+            if (!id) {
+                throw new Error("Must supply a userId");
+            }
+
+            var url = self.getUrl("Users/" + id + "/Offline");
+
+            return self.ajax({
+                type: "GET",
+                url: url,
+                dataType: "json"
+            });
+        };
+
         /**
          * Gets a studio
          */

dashboard-ui/apiclient/connectionmanager.js

@@ -322,12 +322,12 @@
 
         function saveUserInfoIntoCredentials(server, user) {
 
-            //ServerUserInfo info = new ServerUserInfo();
-            //info.setIsSignedInOffline(true);
-            //info.setId(user.getId());
+            var info = new {
+                Id: user.Id,
+                IsSignedInOffline: true
+            }
 
-            //// Record user info here
-            //server.AddOrUpdate(info);
+            credentialProvider.addOrUpdateUser(server, info);
         }
 
         function afterConnected(apiClient, options) {

dashboard-ui/apiclient/credentials.js

@@ -13,7 +13,7 @@
         function ensure() {
 
             if (!credentials) {
-                
+
                 var json = appStorage.getItem(key) || '{}';
 
                 Logger.log('credentials initialized with: ' + json);
@@ -108,6 +108,24 @@
                 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/apiclient/fileupload.js

@@ -0,0 +1,23 @@
+(function (globalScope) {
+
+    function fileUpload() {
+
+        var self = this;
+
+        self.upload = function (file, name, url) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            deferred.reject();
+
+            return deferred.promise();
+        };
+    }
+
+    if (!globalScope.MediaBrowser) {
+        globalScope.MediaBrowser = {};
+    }
+
+    globalScope.MediaBrowser.FileUpload = fileUpload;
+
+})(this);

dashboard-ui/apiclient/localassetmanager.js

@@ -4,8 +4,22 @@
         return null;
     }
 
+    function saveOfflineUser(user) {
+        var deferred = DeferredBuilder.Deferred();
+        deferred.resolve();
+        return deferred.promise();
+    }
+
+    function getCameraPhotos() {
+        var deferred = DeferredBuilder.Deferred();
+        deferred.resolveWith(null, [[]]);
+        return deferred.promise();
+    }
+
     window.LocalAssetManager = {
-        getLocalMediaSource: getLocalMediaSource
+        getLocalMediaSource: getLocalMediaSource,
+        saveOfflineUser: saveOfflineUser,
+        getCameraPhotos: getCameraPhotos
     };
 
 })();

dashboard-ui/apiclient/sync/contentuploader.js

@@ -40,12 +40,93 @@
 
         function uploadImagesWithHistory(server, uploadHistory, apiClient, deferred) {
 
-            require(['localassetmanager'], function () {
+            require(['localassetmanager', "cryptojs-sha1"], function () {
 
-                // TODO: Mimic java version of ContentUploader.UploadImagesInternal
-                deferred.resolve();
+                LocalAssetManager.getCameraPhotos().done(function (photos) {
+
+                    photos = getFilesToUpload(photos, uploadHistory);
+
+                    Logger.log('Found ' + photos.length + ' files to upload');
+
+                    uploadNext(photos, 0, server, apiClient, deferred);
+
+                }).fail(function () {
+                    deferred.reject();
+                });
             });
         }
+
+        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).done(function () {
+
+                uploadNext(files, index + 1, server, apiClient, deferred);
+            }).fail(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).done(function () {
+
+                    Logger.log('File upload succeeded');
+                    deferred.resolve();
+
+                }).fail(function () {
+
+                    Logger.log('File upload failed');
+                    deferred.reject();
+                });
+            });
+
+            return deferred.promise();
+        }
     }
 
     if (!globalScope.MediaBrowser) {

dashboard-ui/apiclient/sync/offlineusersync.js

@@ -4,14 +4,56 @@
 
         var self = this;
 
-        self.sync = function (apiClient) {
+        self.sync = function (apiClient, server) {
 
             var deferred = DeferredBuilder.Deferred();
 
-            deferred.resolve();
+            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).done(function () {
+
+                syncNext(users, index + 1, deferred, apiClient, server);
+            }).fail(function () {
+                syncNext(users, index + 1, deferred, apiClient, server);
+            });
+        }
+
+        function syncUser(user, apiClient) {
+
+            var deferred = DeferredBuilder.Deferred();
+
+            apiClient.getOfflineUser(user.Id).done(function (result) {
+
+                require(['localassetmanager'], function () {
+
+                    LocalAssetManager.saveOfflineUser(result).done(function () {
+                        deferred.resolve();
+                    }).fail(function () {
+                        deferred.resolve();
+                    });
+                });
+
+            }).fail(function () {
+                deferred.reject();
+            });
+
+            return deferred.promise();
+        }
+
     }
 
     if (!globalScope.MediaBrowser) {

dashboard-ui/apiclient/sync/serversync.js

@@ -12,7 +12,7 @@
 
                 Logger.log('Skipping sync to server ' + server.Id + ' because there is no saved authentication information.');
                 deferred.resolve();
-                return;
+                return deferred.promise();
             }
 
             var connectionOptions = {
@@ -66,7 +66,7 @@
 
                 var apiClient = connectionManager.getApiClient(server.Id);
 
-                new MediaBrowser.OfflineUserSync().sync(apiClient).done(function () {
+                new MediaBrowser.OfflineUserSync().sync(apiClient, server).done(function () {
 
                     Logger.log("OfflineUserSync succeeded to server: " + server.Id);