Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="ContainerPropertiesViewModel.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.ComponentModel.Composition;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Net;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using Caliburn.Micro;

using Pithos.Network;

namespace Pithos.Client.WPF.FileProperties

{

    [Export(typeof(ContainerPropertiesViewModel))]

    public class ContainerPropertiesViewModel:Screen

    {

        private string _containerName;

        /// <summary>

        /// Name of the displayed container

        /// </summary>

        public string ContainerName

        {

            get { return _containerName; }

            set

            {

                _containerName = value;

                NotifyOfPropertyChange(()=>ContainerName);

            }

        }

        private string _title;

        /// <summary>

        /// Window title

        /// </summary>

        public string Title

        {

            get { return _title; }

            set

            {

                _title = value;

                NotifyOfPropertyChange(() => Title);

            }

        }

        private long _count;

        /// <summary>

        /// Count of files in the container

        /// </summary>

        public long Count

        {

            get { return _count; }

            set

            {

                _count = value;

                NotifyOfPropertyChange(() => Count);

            }

        }

        private DateTimeOffset? _modified;

        /// <summary>

        /// Date of last modification

        /// </summary>

        public DateTimeOffset? Modified

        {

            get { return _modified; }

            set

            {

                _modified = value;

                NotifyOfPropertyChange(() => Modified);

            }

        }

        private string _size;

        /// <summary>

        /// Total size of the container in bytes

        /// </summary>

        public string Size

        {

            get { return _size; }

            set

            {

                _size = value;

                NotifyOfPropertyChange(() => Size);

            }

        }

        private string _shortSize;

        /// <summary>

        /// Total size of the container formatted in KB,MB etc

        /// </summary>

        public string ShortSize

        {

            get { return _shortSize; }

            set

            {

                _shortSize = value;

                NotifyOfPropertyChange(() => ShortSize);

            }

        }

        private int _blockSize;

        /// <summary>

        /// Block size used by the container

        /// </summary>

        public int BlockSize

        {

            get { return _blockSize; }

            set

            {

                _blockSize = value;

                NotifyOfPropertyChange(() => BlockSize);

            }

        }

        private string _blockHash;

        /// <summary>

        /// Hash algorithm used to calculate block hashes

        /// </summary>

        public string BlockHash

        {

            get { return _blockHash; }

            set

            {

                _blockHash = value;

                NotifyOfPropertyChange(() => BlockHash);

            }

        }

        private ShellViewModel _shell;

        /// <summary>

        /// Reference to the parent Shell

        /// </summary>

        protected ShellViewModel Shell

        {

            get { return _shell; }

            set

            {

                _shell = value;

                NotifyOfPropertyChange(() => Shell);

            }

        }

        private ContainerInfo _container;

        /// <summary>

        /// The displayed ContainerInfo

        /// </summary>

        protected ContainerInfo Container

        {

            get { return _container; }

            set

            {

                _container = value;

                LoadFromDictionary(Tags, value.Tags);

                TagsChanged = false;

                //LoadFromDictionary(Policies, value.Policies);

                if (value.Policies.ContainsKey("Versioning"))

                {

                    Versioning version;

                    if (Enum.TryParse(value.Policies["Versioning"], out version))

                    {

                        SelectedVersion = version;

                    }

                }

                if (value.Policies.ContainsKey("Quota"))

                {

                    int quota;

                    if (int.TryParse(value.Policies["Quota"], out quota))

                    {

                        Quota=quota;

                    }

                }

                Title = String.Format("{0} Properties", _container.Name);

                Count = value.Count;

                ShortSize = value.Bytes.ToByteSize();

                Size = String.Format("{0} ({1:N0} bytes)", ShortSize, value.Bytes);

                Modified = value.Last_Modified;

                BlockSize = value.BlockSize;

                BlockHash = value.BlockHash;                

                ContainerName = Uri.UnescapeDataString(value.Name.ToString().Split('/').Last());                                                

                NotifyOfPropertyChange(() => Container);

                IsBusy = false;

            }

        }

        private int _quota;

        public int Quota

        {

            get { return _quota; }

            set

            {

                if (value < 0)

                    throw new ArgumentOutOfRangeException("Quota");

                _quota = value;                

                NotifyOfPropertyChange(() => Quota);

            }

        }

        private Versioning[] _versions={Versioning.manual,Versioning.auto,Versioning.none};

        public Versioning[] Versions

        {

            get { return _versions; }

        }

        private Versioning _selectedVersion;

        public Versioning SelectedVersion

        {

            get { return _selectedVersion; }

            set { 

                _selectedVersion = value;

                NotifyOfPropertyChange(()=>SelectedVersion);

            }

        }

        private void LoadFromDictionary(ICollection<MetaValue> collection,Dictionary<string,string> source  )

        {

            collection.Clear();

            var items = from item in source

                        select new MetaValue(item.Key, item.Value);

            items.Apply(collection.Add);

        }

        private MetaValue _currentTag;

        public MetaValue CurrentTag

        {

            get { return _currentTag; }

            set

            {

                _currentTag = (value == null) ? new MetaValue() : value.Clone();

                _currentTag.PropertyChanged += (o, e) => NotifyOfPropertyChange(() => CanAddTag);

                NotifyOfPropertyChange(() => CurrentTag);

                NotifyOfPropertyChange(() => CanAddTag);

            }

        }

        private readonly ObservableCollection<MetaValue> _tags;

        public ObservableCollection<MetaValue> Tags

        {

            get { return _tags; }

        }

        public bool CanAddTag

        {

            get { return !String.IsNullOrWhiteSpace(CurrentTag.Name); }

        }

        public void AddTag()

        {

            var existingTag = Tags.FirstOrDefault(tag => tag.Name == CurrentTag.Name);

            if (existingTag == null)

                Tags.Add(CurrentTag.Clone());

            else

            {

                existingTag.Value = CurrentTag.Value;

            }

            TagsChanged = true;

        }

       /* private readonly ObservableCollection<MetaValue> _policies;

        public ObservableCollection<MetaValue> Policies

        {

            get { return _policies; }

        }*/

        private bool _tagsChanged;

        public bool TagsChanged

        {

            get { return _tagsChanged; }

            private set

            {

                _tagsChanged = value;

                NotifyOfPropertyChange(()=>TagsChanged);

                NotifyOfPropertyChange(() => CanApplyChanges);

            }

        }

        //public bool PoliciesChanged { get; private set; }

        private bool _isBusy=true;

        public bool IsBusy

        {

            get { return _isBusy; }

            set

            {

                _isBusy = value;

                NotifyOfPropertyChange(()=>IsBusy);

            }

        }

        private string _busyMessage = "Loading Container Info ...";

        public string BusyMessage

        {

            get { return _busyMessage; }

            set

            {

                _busyMessage = value;

                NotifyOfPropertyChange(() => BusyMessage);

            }

        }

        public ContainerPropertiesViewModel(ShellViewModel shell, Task<ContainerInfo> container, string localFolderName)

        {

            if (shell==null)

                throw new ArgumentNullException("shell");

            if (container==null)

                throw new ArgumentNullException("container");

            if (String.IsNullOrWhiteSpace(localFolderName))

                throw new ArgumentNullException("localFolderName");

            Contract.EndContractBlock();

            _tags = new ObservableCollection<MetaValue>();

            _tags.CollectionChanged += (sender, evt) => { TagsChanged = true; };

            CurrentTag=new MetaValue();

            /*_policies = new ObservableCollection<MetaValue>();

            _policies.CollectionChanged += (sender, evt) => { PoliciesChanged = true; };

*/

            var name = Path.GetFileName(localFolderName);

            DisplayName = String.Format("{0} Container Properties", name);

            Shell = shell;

            ContainerName = localFolderName;

            container.ContinueWith(t =>{                

                if (t.IsFaulted)

                {

                    IsBusy = false;

                    Execute.OnUIThread(() => ShowError(t.Exception));

                    this.TryClose();

                }

                else

                    Execute.OnUIThread(()=>Container = t.Result);                                           

            });

        }

        private void ShowError(AggregateException exception)

        {

            MessageView view=null;

            if (exception.InnerException is RetryException)

                view=new MessageView(exception.InnerException as RetryException);

            else if (exception.InnerException is WebException)

                view = new MessageView(exception.InnerException as WebException);

            else

                view = new MessageView(exception.InnerException);

            view.ShowDialog();

        }

        public async Task Reload()

        {

            Container =await Shell.RefreshContainerInfo(Container);

        }

        public override void CanClose(Action<bool> callback)

        {

            base.CanClose(callback);

        }

        public async Task SaveChanges()

        {

            await DoSave();

            TryClose();

        }

        public void RejectChanges()

        {

            TryClose();

        }

        public async Task ApplyChanges()

        {

            await DoSave();

        }

        public bool CanApplyChanges

        {

            get { return TagsChanged; }

        }

        private async Task DoSave()

        {

            try

            {

                IsBusy = true;

                BusyMessage = "Updating Container Info ...";

                await TaskEx.Run(() =>{

                    if (TagsChanged)

                    {

                        Container.Tags = this.Tags.ToDictionary(tag => tag.Name, tag => tag.Value);

                        var monitor = Shell.Monitors[Container.AccountKey];

                        monitor.CloudClient.UpdateMetadata(Container);

                    }

                    /*

                        Container.Policies["Quota"] = Quota.ToString();

                        Container.Policies["Versioning"] = Enum.GetName(typeof (Versioning), SelectedVersion);

                        if (PoliciesChanged)

                        {

                            Container.Policies = this.Policies.ToDictionary(policy=> policy.Name, tag => tag.Value);

                        }

                    */

                }).ConfigureAwait(false);

            }

            finally

            {

                IsBusy = false;

                TagsChanged = false;                

            }

        }

    }

}