Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.IO;

using System.Linq;

using System.Text;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Core.Agents

{

    [Export(typeof(Selectives))]

    public class Selectives

    {

        public ConcurrentDictionary<Uri, List<Uri>> SelectiveUris { get; private set; }

        private ConcurrentDictionary<Uri, List<string>> SelectivePaths { get; set; }

        public Selectives()

        {

            SelectiveUris = new ConcurrentDictionary<Uri, List<Uri>>();

            SelectivePaths = new ConcurrentDictionary<Uri, List<string>>();

        }

        readonly Dictionary<Uri, bool> _selectiveEnabled = new Dictionary<Uri, bool>();

/*

        public void SetIsSelectiveEnabled(AccountInfo account,bool value)

        {

            _selectiveEnabled[account.AccountKey]=value;

        }

*/

        public void SetIsSelectiveEnabled(Uri accountKey,bool value)

        {

            _selectiveEnabled[accountKey]=value;

        }

/*

        public bool IsSelectiveEnabled(AccountInfo account)

        {

            bool isEnabled;

            _selectiveEnabled.TryGetValue(account.AccountKey, out isEnabled);

            return isEnabled;

        }

*/

        public bool IsSelectiveEnabled(Uri accountKey)

        {

            bool isEnabled;

            _selectiveEnabled.TryGetValue(accountKey, out isEnabled);

            return isEnabled;

        }

        public void SetSelectedUris(AccountInfo account,List<Uri> uris)

        {

            SelectiveUris[account.AccountKey] = uris;

            SelectivePaths[account.AccountKey] = UrisToFilePaths(account,uris);

        }

        public bool IsSelected(ObjectInfo info)

        {

            //Shared folders should NOT be synced if selective syncing is disabled

            var isShared = info.IsShared??false;

            if (info.StorageUri == null)

                return true;

            var selectiveEnabled = IsSelectiveEnabled(info.AccountKey);

            if (!selectiveEnabled)

                return !isShared;

            List<Uri> filterUris;

            return !SelectiveUris.TryGetValue(info.AccountKey, out filterUris) 

                || filterUris.Count ==0

                || filterUris.Any(f => info.Uri.IsAtOrDirectlyBelow(f));

        }

        public bool IsSelected(AccountInfo account,FileSystemInfo info)

        {

            if (info is DirectoryInfo)

                return true;

            return IsSelected(account,info.FullName);

        }

        public bool IsSelected(AccountInfo account, string fullPath)

        {

            if (Directory.Exists(fullPath))

                return true;

            //Shared folders should NOT be synced if selective syncing is disabled

            var isShared = fullPath.IsSharedTo(account);

            var selectiveEnabled = IsSelectiveEnabled(account.AccountKey);

            if (!selectiveEnabled)

                return !isShared;

            List<string> paths;

            return !SelectivePaths.TryGetValue(account.AccountKey, out paths)

                || paths.Count == 0

                || paths.Any(fullPath.IsAtOrDirectlyBelow);

        }

        /// <summary>

        /// Return a list of absolute filepaths from a list of Uris

        /// </summary>

        /// <param name="uris"></param>

        /// <returns></returns>

        private List<string> UrisToFilePaths(AccountInfo account,IEnumerable<Uri> uris)

        {

            if (uris == null)

                return new List<string>();

            var accountPath = account.AccountPath;

            var storageUrl = account.StorageUri.ToString();

            var own = (from uri in uris

                       where uri.ToString().StartsWith(storageUrl)

                       let relativePath = account.StorageUri.MakeRelativeUri(uri).RelativeUriToFilePath()

                       //Trim the account name

                       select Path.Combine(accountPath, relativePath.After(account.UserName + '\\'))).ToList();

            var others = (from uri in uris

                          where !uri.ToString().StartsWith(storageUrl)

                          let relativePath = account.StorageUri.MakeRelativeUri(uri).RelativeUriToFilePath()

                          //Trim the account name

                          select Path.Combine(accountPath, "others-shared", relativePath)).ToList();

            return own.Union(others).ToList();

        }

    }

}