Synnefo » Pithos MS Client

#region

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

 * <copyright file="FilePropertiesViewModel.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.Collections.ObjectModel;

using System.ComponentModel.Composition;

using System.Diagnostics.Contracts;

using System.Drawing;

using System.IO;

using System.Net;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Interop;

using System.Windows.Media.Imaging;

using Caliburn.Micro;

using Pithos.Client.WPF.FileProperties;

using Pithos.Core;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Client.WPF

{

    using System;

    using System.Linq;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [Export(typeof(FilePropertiesViewModel))]

    public class FilePropertiesViewModel : Screen

    {

        private string _title;

        public string Title

        {

            get { return _title; }

            set

            {

                _title = value;

                NotifyOfPropertyChange(()=>Title);

            }

        }

        private bool _isPublic;

        public bool IsPublic

        {

            get { return _isPublic; }

            set

            {

                _isPublic = value;

                NotifyOfPropertyChange(()=>IsPublic);

            }

        }

        private string _contentDisposition;

        public string ContentDisposition

        {

            get { return _contentDisposition; }

            set

            {

                _contentDisposition = value;

                NotifyOfPropertyChange(() => ContentDisposition);

            }

        }

        private string _contentEncoding;

        public string ContentEncoding

        {

            get { return _contentEncoding; }

            set

            {

                _contentEncoding = value;

                NotifyOfPropertyChange(() => ContentEncoding);

            }

        }

        private string _manifest;

        public string Manifest

        {

            get { return _manifest; }

            set

            {

                _manifest = value;

                NotifyOfPropertyChange(() => Manifest);

            }

        }

        private string _kind;

        public string Kind

        {

            get { return _kind; }

            set

            {

                _kind = value;

                NotifyOfPropertyChange(() => Kind);

            }

        }

        private string _size;

        public string Size

        {

            get { return _size; }

            set

            {

                _size = value;

                NotifyOfPropertyChange(() => Size);

            }

        }

        private string _shortSize;

        public string ShortSize

        {

            get { return _shortSize; }

            set

            {

                _shortSize = value;

                NotifyOfPropertyChange(() => ShortSize);

            }

        }

        private string _where;

        public string Where

        {

            get { return _where; }

            set

            {

                _where = value;

                NotifyOfPropertyChange(() => Where);

            }

        }

        private DateTimeOffset? _modified;

        public DateTimeOffset? Modified

        {

            get { return _modified; }

            set

            {

                _modified = value;

                NotifyOfPropertyChange(() => Modified);

            }

        }

        private string _modifiedBy;

        public string ModifiedBy

        {

            get { return _modifiedBy; }

            set

            {

                _modifiedBy = value;

                NotifyOfPropertyChange(() => ModifiedBy);

            }

        }

        private long _version;

        public long Version

        {

            get { return _version; }

            set

            {

                _version = value;

                NotifyOfPropertyChange(() => Version);

            }

        }

        private string _localFileName;

        protected string LocalFileName

        {

            get { return _localFileName; }

            set

            {

                _localFileName = value;

                NotifyOfPropertyChange(() => LocalFileName);

            }

        }

        private BitmapSource _fileIcon;

        public BitmapSource FileIcon

        {

            get { return _fileIcon; }

            set

            {

                _fileIcon = value;

                NotifyOfPropertyChange(() => FileIcon);

            }

        }

        private string _publicUrl;

        public string PublicUrl

        {

            get { return _publicUrl; }

            set

            {

                _publicUrl = value;

                NotifyOfPropertyChange(() => PublicUrl);

            }

        }

        private string _fileName;

        public string FileName

        {

            get { return _fileName; }

            set

            {

                _fileName = value;

                NotifyOfPropertyChange(() => FileName);

            }

        }

        private string _container;

        public string Container

        {

            get { return _container; }

            set

            {

                _container = value;

                NotifyOfPropertyChange(() => Container);

            }

        }

        private string _synchStatus;

        public string SynchStatus

        {

            get { return _synchStatus; }

            set

            {

                _synchStatus = value;

                NotifyOfPropertyChange(()=>SynchStatus);

            }

        }

        private Permission _currentPermission;

        public Permission CurrentPermission

        {

            get { return _currentPermission; }

            set

            {                

                _currentPermission = (value==null)?new Permission() : value.Clone();

                _currentPermission.PropertyChanged += (o, e) => NotifyOfPropertyChange(() => CanAddPermission);

                NotifyOfPropertyChange(()=>CurrentPermission);

                NotifyOfPropertyChange(() => CanAddPermission);

            }

        }

        public bool CanAddPermission

        {

            get { return !String.IsNullOrWhiteSpace(CurrentPermission.UserName); }

        }

        public void AddPermission()

        {

            var existingPermission = Permissions.FirstOrDefault(perm => perm.UserName == CurrentPermission.UserName);

            if (existingPermission==null)

                Permissions.Add(CurrentPermission.Clone());

            else

            {

                existingPermission.Read = CurrentPermission.Read;

            }

            PermissionsChanged= true;

        }

        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 bool _tagsChanged;

        public bool TagsChanged

        {

            get { return _tagsChanged; }

            private set

            {

                _tagsChanged = value;

                NotifyOfPropertyChange(() => CanApplyChanges);                

            }

        }

        private bool _permissionsChanged;

        public bool PermissionsChanged

        {

            get { return _permissionsChanged; }

            private set

            {

                _permissionsChanged = value;

                NotifyOfPropertyChange(() => CanApplyChanges);

            }

        }

        private bool _isBusy = true;

        public bool IsBusy

        {

            get { return _isBusy; }

            set

            {

                _isBusy = value;

                NotifyOfPropertyChange(() => IsBusy);

            }

        }

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

        public string BusyMessage

        {

            get { return _busyMessage; }

            set

            {

                _busyMessage = value;

                NotifyOfPropertyChange(()=>BusyMessage);

            }

        }

        public FilePropertiesViewModel(ShellViewModel shell,Task<ObjectInfo> pithosFile,string localFileName)

        {

            if (shell==null)

                throw new ArgumentNullException("shell");

            if (pithosFile==null)

                throw new ArgumentNullException("pithosFile");

            if (String.IsNullOrWhiteSpace(localFileName))

                throw new ArgumentNullException("localFileName");

            Contract.EndContractBlock();

            _tags = new ObservableCollection<MetaValue>();

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

            _permissions = new ObservableCollection<Permission>();

            _permissions.CollectionChanged += (sender, evt) => { PermissionsChanged = true; };

            CurrentPermission=new Permission();

            CurrentTag=new MetaValue();

            Shell = shell;

            LocalFileName = localFileName;

            var name=Path.GetFileName(localFileName);

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

            pithosFile.ContinueWith(t =>

            {

                if (t.IsFaulted)

                {

                    IsBusy = false;

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

                    this.TryClose();

                }

                else

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

            });       

        }

        private void ShowError(AggregateException exception)

        {

            MessageView view;

            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();

        }

        protected ShellViewModel Shell { get; set; }

        private ObjectInfo _pithosFile;

        public ObjectInfo PithosFile

        {

            get { return _pithosFile; }

            set

            {

                _pithosFile = value;

                Permissions.Clear();

                Tags.Clear();

                var perms=from permission in value.Permissions

                            select new Permission(permission.Key, permission.Value);

                perms.Apply(perm=>Permissions.Add(perm));

                var tags=from tag in value.Tags

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

                tags.Apply(tag=>Tags.Add(tag));

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

                Kind=value.Content_Type;

                ShortSize = value.Bytes.ToByteSize();

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

                Where = value.Name.ToUnescapedString();

                FileName = Uri.UnescapeDataString(Where.Split('/').Last());

                Container = value.Container.ToUnescapedString();

                Modified = value.Last_Modified;

                ModifiedBy = value.ModifiedBy;

                Version = value.Version??0;

                ContentDisposition = value.ContendDisposition;

                ContentEncoding = value.ContentEncoding;

                Manifest = value.Manifest;

                IsPublic = value.IsPublic;

                if (IsPublic)

                    PublicUrl = String.Format("{0}/v1{1}", Shell.Accounts.First(account=>account.UserName==PithosFile.Account).SiteUri,value.PublicUrl);

                if (Directory.Exists(LocalFileName))

                {

                    FileIcon= new BitmapImage(new Uri("../Images/Folder.ico",UriKind.Relative));

                }

                else if (File.Exists(LocalFileName))

                {

                    using (var icon = Icon.ExtractAssociatedIcon(LocalFileName))

                    {

                        FileIcon = Imaging.CreateBitmapSourceFromHIcon(icon.Handle, Int32Rect.Empty,

                                                                       BitmapSizeOptions.FromEmptyOptions());

                    }

                }

                var status=Shell.GetFileStatus(LocalFileName);

                SynchStatus = Enum.GetName(typeof (FileStatus), status);

                NotifyOfPropertyChange(()=>PithosFile);

                IsBusy = false;

            }

        }

        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;}

        }

        private readonly ObservableCollection<Permission> _permissions ;

        public ObservableCollection<Permission> Permissions

        {

            get { return _permissions; }

        }

        public async Task Reload()

        {

            PithosFile=await Shell.RefreshObjectInfo(PithosFile);

        }

        public override void CanClose(Action<bool> callback)

        {

            base.CanClose(callback);

        }

        public async Task SaveChanges()

        {

            await DoSave();

            TryClose();

        }

        public void RejectChanges()

        {

            TryClose();

        }

        public bool CanApplyChanges

        {

            get { return TagsChanged || PermissionsChanged; }

        }

        public async Task ApplyChanges()

        {

            await DoSave();

        }

        private async Task DoSave()

        {

            try

            {

                IsBusy = true;

                BusyMessage = "Updating Object Info ...";

                await TaskEx.Run(() =>{

                    if (TagsChanged)

                    {

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

                    }

                    if (PermissionsChanged)

                    {

                        PithosFile.Permissions =

                            this.Permissions.ToDictionary(perm => perm.UserName, perm =>

                                                                                (perm.Value.Trim()));

                    }

                    PithosFile.ContendDisposition = ContentDisposition;

                    PithosFile.ContentEncoding = ContentEncoding;

                    PithosFile.Manifest = Manifest;

                    PithosFile.IsPublic = IsPublic;

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

                    monitor.CloudClient.UpdateMetadata(PithosFile);

                    TagsChanged = false;

                    PermissionsChanged = false;

                }).ConfigureAwait(false);

            }

            finally

            {

                IsBusy = false;

                TagsChanged = false;

                PermissionsChanged = false;

            }

        }

    }

}