Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="FilePropertiesViewModel.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using System.Collections;

using System.Collections.Concurrent;

using System.Collections.ObjectModel;

using System.Collections.Specialized;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.Drawing;

using System.Windows;

using System.Windows.Interop;

using System.Windows.Media.Imaging;

using Caliburn.Micro;

using Pithos.Client.WPF.FileProperties;

using Pithos.Client.WPF.Properties;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Client.WPF

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

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

            }

        }

        public string Kind { get; set; }

        public string Size { get; set; }

        public string ShortSize { get; set; }

        public string Where { get; set; }

        public DateTime Modified { get; set; }

        public string ModifiedBy { get; set; }

        public long Version { get; set; }

        protected string LocalFileName { get; set; }

        public BitmapSource FileIcon { get; set; }

        public string PublicUrl { get; set; }

        public string FileName { get; set; }

        public string Container { get; set; }

        public bool TagsChanged { get; private set; }

        public bool PermissionsChanged { get; private set; }

        public FilePropertiesViewModel(ShellViewModel shell,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<Tag>();

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

            _permissions = new ObservableCollection<Permission>();

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

            Shell = shell;

            LocalFileName = localFileName;

            PithosFile = pithosFile;

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

        }

        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 Tag(tag.Key, tag.Value);

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

                Kind=value.Content_Type;

                ShortSize = value.Bytes.ToByteSize();

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

                Where = Uri.UnescapeDataString(value.Name);

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

                Container = value.Container;

                Modified = value.Last_Modified;

                ModifiedBy = value.ModifiedBy;

                Version = value.Version??0;

                ContentDisposition = value.ContendDisposition;

                ContentEncoding = value.ContentEncoding;

                Manifest = value.Manifest;

                IsPublic = value.IsPublic;

                PublicUrl = String.Format("{0}/v1{1}", Settings.Default.PithosSite ,value.PublicUrl);

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

                {

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

                                                                   BitmapSizeOptions.FromEmptyOptions());

                }

                NotifyOfPropertyChange(()=>PithosFile);

            }

        }

        private readonly ObservableCollection<Tag> _tags ;

        public ObservableCollection<Tag> Tags

        {

            get { return _tags;}

        }

        private readonly ObservableCollection<Permission> _permissions ;

        public ObservableCollection<Permission> Permissions

        {

            get { return _permissions; }

        }

        public void Reload()

        {

            PithosFile=Shell.RefreshObjectInfo(PithosFile);

        }

        public override void CanClose(Action<bool> callback)

        {

            base.CanClose(callback);

        }

        public void SaveChanges()

        {

            DoSave();

            TryClose();

        }

        public void RejectChanges()

        {

            TryClose();

        }

        public void ApplyChanges()

        {

            DoSave();

        }

        private void DoSave()

        {

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

            }

            PithosFile.ContendDisposition = ContentDisposition;

            PithosFile.ContentEncoding = ContentEncoding;

            PithosFile.Manifest = Manifest;

            PithosFile.IsPublic = IsPublic;

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

            monitor.CloudClient.UpdateMetadata(PithosFile);

            TagsChanged = false;

            PermissionsChanged = false;

        }

    }

}