cloud sync updates

MediaBrowser.Server.Implementations/Sync/FolderSync/FolderSyncDataProvider.cs

@@ -0,0 +1,31 @@
+using MediaBrowser.Controller.Sync;
+using MediaBrowser.Model.Sync;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Server.Implementations.Sync.FolderSync
+{
+    public class FolderSyncDataProvider : ISyncDataProvider
+    {
+        public Task<List<string>> GetServerItemIds(SyncTarget target, string serverId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task AddOrUpdate(SyncTarget target, LocalItem item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task Delete(SyncTarget target, string id)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<LocalItem> Get(SyncTarget target, string id)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

MediaBrowser.Server.Implementations/Sync/FolderSync/FolderSyncProvider.cs

@@ -0,0 +1,142 @@
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Sync;
+using MediaBrowser.Model.Sync;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Server.Implementations.Sync.FolderSync
+{
+    public class FolderSyncProvider : IServerSyncProvider
+    {
+        private readonly IApplicationPaths _appPaths;
+        private readonly IUserManager _userManager;
+
+        public FolderSyncProvider(IApplicationPaths appPaths, IUserManager userManager)
+        {
+            _appPaths = appPaths;
+            _userManager = userManager;
+        }
+
+        public Task SendFile(string inputFile, string path, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return Task.Run(() => File.Copy(inputFile, path, true), cancellationToken);
+        }
+
+        public Task DeleteFile(string path, SyncTarget target, CancellationToken cancellationToken)
+        {
+            return Task.Run(() => File.Delete(path), cancellationToken);
+        }
+
+        public Task<Stream> GetFile(string path, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return Task.FromResult((Stream)File.OpenRead(path));
+        }
+
+        public string GetFullPath(IEnumerable<string> paths, SyncTarget target)
+        {
+            var account = GetSyncAccounts()
+                .FirstOrDefault(i => string.Equals(i.Id, target.Id, StringComparison.OrdinalIgnoreCase));
+
+            if (account == null)
+            {
+                throw new ArgumentException("Invalid SyncTarget supplied.");
+            }
+
+            var list = paths.ToList();
+            list.Insert(0, account.Path);
+
+            return Path.Combine(list.ToArray());
+        }
+
+        public string GetParentDirectoryPath(string path, SyncTarget target)
+        {
+            return Path.GetDirectoryName(path);
+        }
+
+        public Task<List<DeviceFileInfo>> GetFileSystemEntries(string path, SyncTarget target)
+        {
+            List<FileInfo> files;
+
+            try
+            {
+                files = new DirectoryInfo(path).EnumerateFiles("*", SearchOption.TopDirectoryOnly).ToList();
+            }
+            catch (DirectoryNotFoundException)
+            {
+                files = new List<FileInfo>();
+            }
+
+            return Task.FromResult(files.Select(i => new DeviceFileInfo
+            {
+                Name = i.Name,
+                Path = i.FullName
+
+            }).ToList());
+        }
+
+        public ISyncDataProvider GetDataProvider()
+        {
+            // If single instances are needed, manage them here
+            return new FolderSyncDataProvider();
+        }
+
+        public string Name
+        {
+            get { return "Folder Sync"; }
+        }
+
+        public IEnumerable<SyncTarget> GetSyncTargets(string userId)
+        {
+            return GetSyncAccounts()
+                .Where(i => i.UserIds.Contains(userId, StringComparer.OrdinalIgnoreCase))
+                .Select(GetSyncTarget);
+        }
+
+        public IEnumerable<SyncTarget> GetAllSyncTargets()
+        {
+            return GetSyncAccounts().Select(GetSyncTarget);
+        }
+
+        private SyncTarget GetSyncTarget(SyncAccount account)
+        {
+            return new SyncTarget
+            {
+                Id = account.Id,
+                Name = account.Name
+            };
+        }
+
+        private IEnumerable<SyncAccount> GetSyncAccounts()
+        {
+            // Dummy this up
+            return _userManager
+                .Users
+                .Select(i => new SyncAccount
+                {
+                    Id = i.Id.ToString("N"),
+                    UserIds = new List<string> { i.Id.ToString("N") },
+                    Path = Path.Combine(_appPaths.DataPath, "foldersync", i.Id.ToString("N")),
+                    Name = i.Name + "'s Folder Sync"
+                });
+        }
+
+        // An internal class to manage all configured Folder Sync accounts for differnet users
+        class SyncAccount
+        {
+            public string Id { get; set; }
+            public string Name { get; set; }
+            public string Path { get; set; }
+            public List<string> UserIds { get; set; }
+
+            public SyncAccount()
+            {
+                UserIds = new List<string>();
+            }
+        }
+    }
+}