code.grnet.gr Git - pithos-ms-client/blob - trunk/Pithos.Client.WPF/SelectiveSynch/SelectiveSynchViewModel.cs

   1 #region
   2 /* -----------------------------------------------------------------------
   3  * <copyright file="SelectiveSynchViewModel.cs" company="GRNet">
   4  *
   5  * Copyright 2011-2012 GRNET S.A. All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or
   8  * without modification, are permitted provided that the following
   9  * conditions are met:
  10  *
  11  *   1. Redistributions of source code must retain the above
  12  *      copyright notice, this list of conditions and the following
  13  *      disclaimer.
  14  *
  15  *   2. Redistributions in binary form must reproduce the above
  16  *      copyright notice, this list of conditions and the following
  17  *      disclaimer in the documentation and/or other materials
  18  *      provided with the distribution.
  19  *
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  22  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  25  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  28  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * The views and conclusions contained in the software and
  35  * documentation are those of the authors and should not be
  36  * interpreted as representing official policies, either expressed
  37  * or implied, of GRNET S.A.
  38  * </copyright>
  39  * -----------------------------------------------------------------------
  40  */
  41 #endregion
  42 using System;
  43 using System.Collections.Generic;
  44 using System.Collections.ObjectModel;
  45 using System.Linq;
  46 using System.Threading.Tasks;
  47 using Caliburn.Micro;
  48 using Pithos.Client.WPF.Properties;
  49 using Pithos.Client.WPF.Utils;
  50 using Pithos.Core;
  51 using Pithos.Interfaces;
  52 using Pithos.Network;
  53
  54 namespace Pithos.Client.WPF.SelectiveSynch
  55 {
  56     class SelectiveSynchViewModel:Screen
  57     {
  58         private readonly IEventAggregator _events ;
  59
  60
  61         public AccountSettings Account { get; set; }
  62
  63         private readonly ObservableCollection<DirectoryRecord> _rootNodes=new ObservableCollection<DirectoryRecord>();
  64         public ObservableCollection<DirectoryRecord> RootNodes
  65         {
  66             get { return _rootNodes; }
  67         }
  68
  69         private ObservableCollection<ObjectInfo> _checks;
  70         //private readonly PithosMonitor _monitor;
  71         private bool _isBusy=true;
  72         private string _apiKey;
  73
  74         public ObservableCollection<ObjectInfo> Checks
  75         {
  76             get { return _checks; }
  77         }
  78
  79         public void GetChecks()
  80         {
  81             var root = RootNodes[0];
  82             _checks = new ObservableCollection<ObjectInfo>(
  83                 from DirectoryRecord record in root
  84                 where record.IsChecked==true
  85                 select record.ObjectInfo);
  86             NotifyOfPropertyChange(() => Checks);
  87         }
  88
  89         public SelectiveSynchViewModel(/*PithosMonitor monitor,*/ IEventAggregator events, AccountSettings account, string apiKey)
  90         {
  91             Account = account;
  92             AccountName = account.AccountName;
  93             DisplayName = String.Format("Selective folder synchronization for {0}",account.AccountName);
  94             //_monitor = monitor;
  95             _events = events;
  96             _apiKey = apiKey;
  97             TaskEx.Run(LoadRootNode);
  98         }
  99
 100         private void LoadRootNode()
 101         {
 102             //TODO: Check this
 103             var client = new CloudFilesClient(AccountName,_apiKey){AuthenticationUrl=Account.ServerUrl,UsePithos=true};
 104             client.Authenticate();
 105
 106
 107             var dirs = from container in client.ListContainers(AccountName)
 108                        select new DirectoryRecord
 109                                   {
 110                                       DisplayName = container.Name,
 111                                       Uri=new Uri(client.StorageUrl,String.Format(@"{0}/{1}",Account.AccountName, container.Name)),
 112                                       Directories = (from dir in client.ListObjects(AccountName, container.Name)
 113                                                      where dir.IsDirectory
 114                                                      select dir).ToTree()
 115                                   };
 116             var ownFolders = dirs.ToList();
 117
 118             var accountNodes=from account in client.ListSharingAccounts()
 119                              select new DirectoryRecord
 120                              {
 121                                 DisplayName=account.name,
 122                                 Uri=new Uri(client.StorageUrl,"../"+ account.name),
 123                                 Directories=(from container in client.ListContainers(account.name)
 124                                             select new DirectoryRecord
 125                                                         {
 126                                                             DisplayName=container.Name,
 127                                                             Uri = new Uri(client.StorageUrl, "../" + account.name + "/" + container.Name),
 128                                                             Directories=(from folder in client.ListObjects(account.name,container.Name)
 129                                                                         where folder.IsDirectory
 130                                                                         select folder).ToTree()
 131                                                         }).ToList()
 132                              };
 133
 134             var othersNode = new DirectoryRecord
 135                                  {
 136                                      DisplayName = "Shared to me",
 137                                      Directories=accountNodes.ToList()
 138                                  };
 139
 140
 141             var rootItem = new DirectoryRecord
 142                                {
 143                                    DisplayName = AccountName ,
 144                                    Directories = ownFolders.ToList()
 145                                };
 146
 147             Execute.OnUIThread(() =>
 148                                    {
 149                                        RootNodes.Add(rootItem);
 150                                        RootNodes.Add(othersNode);
 151                                    });
 152
 153             SetInitialSelections(Account);
 154
 155             IsBusy = false;
 156         }
 157
 158         public bool IsBusy
 159         {
 160             get {
 161                 return _isBusy;
 162             }
 163             set {
 164                 _isBusy = value;
 165                 NotifyOfPropertyChange(()=>IsBusy);
 166             }
 167         }
 168
 169         private void SetInitialSelections(AccountSettings account)
 170         {
 171             var selections = account.SelectiveFolders;
 172
 173
 174
 175             //Initially, all nodes are checked
 176             //We need to *uncheck* the nodes that are not selected
 177
 178             var allNodes = (from DirectoryRecord rootRecord in RootNodes
 179                            from DirectoryRecord record in rootRecord
 180                            select record).ToList();
 181
 182             allNodes.Apply(record => record.IsChecked = false);
 183
 184             if (selections.Count == 0)
 185             {
 186             //    allNodes.Apply(record => record.IsChecked = false);
 187                 return;
 188             }
 189
 190             var selects = (from DirectoryRecord rootRecord in RootNodes
 191                           from DirectoryRecord record in rootRecord
 192                           where record.Uri !=null &&  selections.Contains(record.Uri.ToString())
 193                           select record).ToList();
 194             //var shouldBeChecked = allNodes.Except(selects).ToList();
 195
 196             selects.Apply(record=>record.IsExplicitlyChecked=true);
 197
 198             //shouldBeChecked.Apply(record => record.IsChecked = true);
 199
 200
 201
 202         }
 203
 204         protected string AccountName { get; set; }
 205
 206         public void SaveChanges()
 207         {
 208             var uris = (from DirectoryRecord root in RootNodes
 209                         from DirectoryRecord record in root
 210                         where record.IsChecked == true && record.Uri != null
 211                         select record.Uri).ToArray();
 212
 213             SaveSettings(uris);
 214
 215             //RootNodes is an ObservableCollection, it can't be enumerated iterativelly
 216
 217             var added = (from DirectoryRecord root in RootNodes
 218                          from DirectoryRecord record in root
 219                          where record.Added && record.Uri != null
 220                          select record.Uri).ToArray();
 221             var removed = (from DirectoryRecord root in RootNodes
 222                            from DirectoryRecord record in root
 223                           where record.Removed && record.Uri != null
 224                          select record.Uri).ToArray();
 225             //TODO: Include Uris for the containers as well
 226             _events.Publish(new SelectiveSynchChanges{Account=Account,Uris=uris,Added=added,Removed=removed});
 227
 228
 229
 230
 231             TryClose(true);
 232         }
 233
 234
 235         private void SaveSettings(IEnumerable<Uri> uris)
 236         {
 237             var selections = uris.Select(uri => uri.ToString()).ToArray();
 238
 239             Account.SelectiveFolders.Clear();
 240             Account.SelectiveFolders.AddRange(selections);
 241             Settings.Default.Save();
 242         }
 243
 244         public void RejectChanges()
 245         {
 246             TryClose(false);
 247         }
 248     }
 249 }