Statistics
| Branch: | Revision:

root / trunk / Pithos.Client.WPF / FileProperties / FilePropertiesViewModel.cs @ f3d080df

History | View | Annotate | Download (13.1 kB)

1
// -----------------------------------------------------------------------
2
// <copyright file="FilePropertiesViewModel.cs" company="GRNet">
3
// Copyright 2011 GRNET S.A. All rights reserved.
4
// 
5
// Redistribution and use in source and binary forms, with or
6
// without modification, are permitted provided that the following
7
// conditions are met:
8
// 
9
//   1. Redistributions of source code must retain the above
10
//      copyright notice, this list of conditions and the following
11
//      disclaimer.
12
// 
13
//   2. Redistributions in binary form must reproduce the above
14
//      copyright notice, this list of conditions and the following
15
//      disclaimer in the documentation and/or other materials
16
//      provided with the distribution.
17
// 
18
// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
19
// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
22
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
25
// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29
// POSSIBILITY OF SUCH DAMAGE.
30
// 
31
// The views and conclusions contained in the software and
32
// documentation are those of the authors and should not be
33
// interpreted as representing official policies, either expressed
34
// or implied, of GRNET S.A.
35
// </copyright>
36
// -----------------------------------------------------------------------
37

    
38
using System.Collections;
39
using System.Collections.Concurrent;
40
using System.Collections.ObjectModel;
41
using System.Collections.Specialized;
42
using System.ComponentModel.Composition;
43
using System.Diagnostics;
44
using System.Diagnostics.Contracts;
45
using System.Drawing;
46
using System.IO;
47
using System.Net;
48
using System.Threading.Tasks;
49
using System.Windows;
50
using System.Windows.Interop;
51
using System.Windows.Media.Imaging;
52
using Caliburn.Micro;
53
using Pithos.Client.WPF.FileProperties;
54
using Pithos.Client.WPF.Properties;
55
using Pithos.Interfaces;
56
using Pithos.Network;
57

    
58
namespace Pithos.Client.WPF
59
{
60
    using System;
61
    using System.Collections.Generic;
62
    using System.Linq;
63
    using System.Text;
64

    
65
    /// <summary>
66
    /// TODO: Update summary.
67
    /// </summary>
68
    [Export(typeof(FilePropertiesViewModel))]
69
    public class FilePropertiesViewModel : Screen
70
    {
71
        private string _title;
72
        public string Title
73
        {
74
            get { return _title; }
75
            set
76
            {
77
                _title = value;
78
                NotifyOfPropertyChange(()=>Title);
79
            }
80
        }
81

    
82

    
83
        private bool _isPublic;
84
        public bool IsPublic
85
        {
86
            get { return _isPublic; }
87
            set
88
            {
89
                _isPublic = value;
90
                NotifyOfPropertyChange(()=>IsPublic);
91
            }
92
        }
93

    
94
        private string _contentDisposition;
95
        public string ContentDisposition
96
        {
97
            get { return _contentDisposition; }
98
            set
99
            {
100
                _contentDisposition = value;
101
                NotifyOfPropertyChange(() => ContentDisposition);
102
            }
103
        }
104

    
105
        private string _contentEncoding;
106
        public string ContentEncoding
107
        {
108
            get { return _contentEncoding; }
109
            set
110
            {
111
                _contentEncoding = value;
112
                NotifyOfPropertyChange(() => ContentEncoding);
113
            }
114
        }
115

    
116

    
117
        private string _manifest;
118
        public string Manifest
119
        {
120
            get { return _manifest; }
121
            set
122
            {
123
                _manifest = value;
124
                NotifyOfPropertyChange(() => Manifest);
125
            }
126
        }
127

    
128
        private string _kind;
129
        public string Kind
130
        {
131
            get { return _kind; }
132
            set
133
            {
134
                _kind = value;
135
                NotifyOfPropertyChange(() => Kind);
136
            }
137
        }
138

    
139
        private string _size;
140
        public string Size
141
        {
142
            get { return _size; }
143
            set
144
            {
145
                _size = value;
146
                NotifyOfPropertyChange(() => Size);
147
            }
148
        }
149

    
150
        private string _shortSize;
151
        public string ShortSize
152
        {
153
            get { return _shortSize; }
154
            set
155
            {
156
                _shortSize = value;
157
                NotifyOfPropertyChange(() => ShortSize);
158
            }
159
        }
160

    
161
        private string _where;
162
        public string Where
163
        {
164
            get { return _where; }
165
            set
166
            {
167
                _where = value;
168
                NotifyOfPropertyChange(() => Where);
169
            }
170
        }
171

    
172
        private DateTime _modified;
173
        public DateTime Modified
174
        {
175
            get { return _modified; }
176
            set
177
            {
178
                _modified = value;
179
                NotifyOfPropertyChange(() => Modified);
180
            }
181
        }
182

    
183
        private string _modifiedBy;
184
        public string ModifiedBy
185
        {
186
            get { return _modifiedBy; }
187
            set
188
            {
189
                _modifiedBy = value;
190
                NotifyOfPropertyChange(() => ModifiedBy);
191
            }
192
        }
193

    
194
        private long _version;
195
        public long Version
196
        {
197
            get { return _version; }
198
            set
199
            {
200
                _version = value;
201
                NotifyOfPropertyChange(() => Version);
202
            }
203
        }
204

    
205
        private string _localFileName;
206
        protected string LocalFileName
207
        {
208
            get { return _localFileName; }
209
            set
210
            {
211
                _localFileName = value;
212
                NotifyOfPropertyChange(() => LocalFileName);
213
            }
214
        }
215

    
216
        private BitmapSource _fileIcon;
217
        public BitmapSource FileIcon
218
        {
219
            get { return _fileIcon; }
220
            set
221
            {
222
                _fileIcon = value;
223
                NotifyOfPropertyChange(() => FileIcon);
224
            }
225
        }
226

    
227
        private string _publicUrl;
228
        public string PublicUrl
229
        {
230
            get { return _publicUrl; }
231
            set
232
            {
233
                _publicUrl = value;
234
                NotifyOfPropertyChange(() => PublicUrl);
235
            }
236
        }
237

    
238
        private string _fileName;
239
        public string FileName
240
        {
241
            get { return _fileName; }
242
            set
243
            {
244
                _fileName = value;
245
                NotifyOfPropertyChange(() => FileName);
246
            }
247
        }
248

    
249
        private string _container;
250
        public string Container
251
        {
252
            get { return _container; }
253
            set
254
            {
255
                _container = value;
256
                NotifyOfPropertyChange(() => Container);
257
            }
258
        }
259

    
260
        public bool TagsChanged { get; private set; }
261
        public bool PermissionsChanged { get; private set; }
262

    
263
        private bool _isBusy = true;
264
        public bool IsBusy
265
        {
266
            get { return _isBusy; }
267
            set
268
            {
269
                _isBusy = value;
270
                NotifyOfPropertyChange(() => IsBusy);
271
            }
272
        }
273

    
274

    
275
        public FilePropertiesViewModel(ShellViewModel shell,Task<ObjectInfo> pithosFile,string localFileName)
276
        {
277
            if (shell==null)
278
                throw new ArgumentNullException("shell");
279
            if (pithosFile==null)
280
                throw new ArgumentNullException("pithosFile");
281
            if (String.IsNullOrWhiteSpace(localFileName))
282
                throw new ArgumentNullException("localFileName");
283
            Contract.EndContractBlock();
284

    
285

    
286
            _tags = new ObservableCollection<MetaValue>();
287
            _tags.CollectionChanged += (sender, evt) => { TagsChanged = true; };
288
            _permissions = new ObservableCollection<Permission>();
289
            _permissions.CollectionChanged += (sender, evt) => { PermissionsChanged = true; };
290
            
291
            Shell = shell;
292
            LocalFileName = localFileName;
293
            pithosFile.ContinueWith(t =>
294
            {
295
                if (t.IsFaulted)
296
                {
297
                    IsBusy = false;
298
                    Execute.OnUIThread(()=>ShowError(t.Exception));
299
                    this.TryClose();
300

    
301
                }
302
                else
303
                    Execute.OnUIThread(() => PithosFile = t.Result);
304
            });                        
305
        }
306

    
307
        private void ShowError(AggregateException exception)
308
        {
309
            MessageView view = null;
310
            if (exception.InnerException is RetryException)
311
                view = new MessageView(exception.InnerException as RetryException);
312
            else if (exception.InnerException is WebException)
313
                view = new MessageView(exception.InnerException as WebException);
314
            else
315
                view = new MessageView(exception.InnerException);
316
            view.ShowDialog();
317
        }
318

    
319

    
320
        protected ShellViewModel Shell { get; set; }
321

    
322
        private ObjectInfo _pithosFile;
323
        public ObjectInfo PithosFile
324
        {
325
            get { return _pithosFile; }
326
            set
327
            {
328
                _pithosFile = value;
329
                
330
                Permissions.Clear();
331
                Tags.Clear();
332

    
333
                var perms=from permission in value.Permissions
334
                            select new Permission(permission.Key, permission.Value);
335
                perms.Apply(perm=>Permissions.Add(perm));
336
                
337
                var tags=from tag in value.Tags
338
                             select new MetaValue(tag.Key, tag.Value);
339
                tags.Apply(tag=>Tags.Add(tag));
340

    
341
                Title = String.Format("{0} Properties", value.Name);
342
                Kind=value.Content_Type;
343
                ShortSize = value.Bytes.ToByteSize();
344
                Size = String.Format("{0} ({1:N0} bytes)", ShortSize, value.Bytes);
345
                Where = Uri.UnescapeDataString(value.Name);
346
                FileName = Uri.UnescapeDataString(value.Name.Split('/').Last());
347
                Container = value.Container;
348
                Modified = value.Last_Modified;
349
                ModifiedBy = value.ModifiedBy;
350
                Version = value.Version??0;
351

    
352
                ContentDisposition = value.ContendDisposition;
353
                ContentEncoding = value.ContentEncoding;
354
                Manifest = value.Manifest;
355
                IsPublic = value.IsPublic;
356
                if (IsPublic)
357
                    PublicUrl = String.Format("{0}/v1{1}", Shell.Accounts.First(account=>account.UserName==PithosFile.Account).SiteUri,value.PublicUrl);
358

    
359
                if (Directory.Exists(LocalFileName))
360
                {
361
                    FileIcon= new BitmapImage(new Uri("../Images/Folder.ico",UriKind.Relative));
362
                }
363
                else if (File.Exists(LocalFileName))
364
                {
365
                    using (var icon = Icon.ExtractAssociatedIcon(LocalFileName))
366
                    {
367
                        FileIcon = Imaging.CreateBitmapSourceFromHIcon(icon.Handle, Int32Rect.Empty,
368
                                                                       BitmapSizeOptions.FromEmptyOptions());
369
                    }
370
                }
371
                NotifyOfPropertyChange(()=>PithosFile);
372
                IsBusy = false;
373
            }
374
        }
375

    
376

    
377
        private readonly ObservableCollection<MetaValue> _tags ;
378
        public ObservableCollection<MetaValue> Tags
379
        {
380
            get { return _tags;}
381
        }
382

    
383
        private readonly ObservableCollection<Permission> _permissions ;
384
        
385

    
386
        public ObservableCollection<Permission> Permissions
387
        {
388
            get { return _permissions; }
389
        }
390

    
391
        public void Reload()
392
        {
393
            PithosFile=Shell.RefreshObjectInfo(PithosFile);
394
        }
395

    
396
        public override void CanClose(Action<bool> callback)
397
        {
398
            base.CanClose(callback);
399
        }
400

    
401
        public void SaveChanges()
402
        {
403
            DoSave();
404
            TryClose();
405
        }
406

    
407
        public void RejectChanges()
408
        {
409
            TryClose();
410
        }
411

    
412
        public void ApplyChanges()
413
        {
414
            DoSave();
415
        }
416

    
417
        private void DoSave()
418
        {
419
            if (TagsChanged)
420
            {
421
                PithosFile.Tags = this.Tags.ToDictionary(tag => tag.Name, tag => tag.Value);
422
            }
423
            
424
            if (PermissionsChanged)
425
            {
426
                PithosFile.Permissions = this.Permissions.ToDictionary(perm => perm.UserName, perm => perm.Value);
427
            }
428

    
429
            PithosFile.ContendDisposition = ContentDisposition;
430
            PithosFile.ContentEncoding = ContentEncoding;
431
            PithosFile.Manifest = Manifest;
432
            PithosFile.IsPublic = IsPublic;
433

    
434
            var monitor = Shell.Monitors[PithosFile.Account];
435
            monitor.CloudClient.UpdateMetadata(PithosFile);
436

    
437

    
438
            TagsChanged = false;
439
            PermissionsChanged = false;
440
        }
441

    
442

    
443
    }
444
}