?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
folder.icon
[tfs.git] / class / Microsoft.TeamFoundation.VersionControl.Client / Workspace.cs
blob10eadbc6a1a5c4bdf879efa6d9f42470db294f92
1 //
2 // Microsoft.TeamFoundation.VersionControl.Client.Workspace
3 //
4 // Authors:
5 // Joel Reed (joelwreed@gmail.com)
6 //
7 // Copyright (C) 2007 Joel Reed
8 //
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28
29 using System;
30 using System.Collections.Generic;
31 using System.IO;
32 using System.Net;
33 using System.Text;
34 using System.Xml;
35 using System.Web.Services;
36 using Microsoft.TeamFoundation.VersionControl.Common;
37
38 namespace Microsoft.TeamFoundation.VersionControl.Client
39 {
40 public sealed class Workspace : IComparable
41 {
42 private string comment;
43 private string computer;
44 private string name;
45 private string ownerName;
46 private DateTime lastAccessDate;
47 private WorkingFolder[] folders;
48 private VersionControlServer versionControlServer;
49 internal bool readWriteSetting;
50
51 internal Workspace(VersionControlServer versionControlServer, string name,
52 string ownerName, string comment,
53 WorkingFolder[] folders, string computer)
54 {
55 this.versionControlServer = versionControlServer;
56 this.name = name;
57 this.ownerName = ownerName;
58 this.comment = comment;
59 this.folders = folders;
60 this.computer = computer;
61
62 readWriteSetting = Workstation.Settings["File.ReadWrite"];
63 }
64
65 internal Workspace(VersionControlServer versionControlServer,
66 WorkspaceInfo info)
67 {
68 this.versionControlServer = versionControlServer;
69 this.name = info.Name;
70 this.ownerName = info.OwnerName;
71 this.comment = info.Comment;
72 this.folders = new WorkingFolder[0];
73 this.computer = info.Computer;
74
75 readWriteSetting = Workstation.Settings["File.ReadWrite"];
76 }
77
78 public int CheckIn(PendingChange[] changes, string comment)
79 {
80 if (changes.Length == 0) return 0;
81
82 List<string> serverItems = new List<string>();
83 SortedList<string, PendingChange> changesByServerPath = new SortedList<string, PendingChange>();
84
85 foreach (PendingChange change in changes)
86 {
87 // upload new or changed files only
88 if ((change.ItemType == ItemType.File) &&
89 (change.IsAdd || change.IsEdit ))
90 {
91 Repository.CheckInFile(Name, OwnerName, change);
92 SetFileAttributes(change.LocalItem);
93 }
94
95 serverItems.Add(change.ServerItem);
96 changesByServerPath.Add(change.ServerItem, change);
97 }
98
99 SortedList<string, bool> undoneServerItems = new SortedList<string, bool>();
100 int cset = Repository.CheckIn(this, serverItems.ToArray(), comment, ref undoneServerItems);
101
102 foreach (string undoneItem in undoneServerItems.Keys)
103 {
104 PendingChange change = changesByServerPath[undoneItem];
105 VersionControlServer.OnUndonePendingChange(this, change);
106 }
107
108 return cset;
109 }
110
111 public int CompareTo (object o)
112 {
113 Workspace a = this, b = (Workspace)o;
114
115 int r0 = a.VersionControlServer.ServerGuid.CompareTo (b.VersionControlServer.ServerGuid);
116 if (r0 != 0) return r0;
117
118 int r1 = a.Name.CompareTo (b.Name);
119 if (r1 != 0) return r1;
120
121 int r2 = a.OwnerName.CompareTo (b.OwnerName);
122 return r2;
123 }
124
125 public PendingChange[] GetPendingChanges()
126 {
127 return GetPendingChanges(VersionControlPath.RootFolder, RecursionType.Full);
128 }
129
130 public PendingChange[] GetPendingChanges(string item)
131 {
132 return GetPendingChanges(item, RecursionType.None);
133 }
134
135 public PendingChange[] GetPendingChanges(string item, RecursionType rtype)
136 {
137 return GetPendingChanges(item, rtype, false);
138 }
139
140 public PendingChange[] GetPendingChanges(string item, RecursionType rtype,
141 bool includeDownloadInfo)
142 {
143 string[] items = new string[1];
144 items[0] = item;
145 return GetPendingChanges(items, rtype, includeDownloadInfo);
146 }
147
148 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype)
149 {
150 return GetPendingChanges(items, rtype, false);
151 }
152
153 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype,
154 bool includeDownloadInfo)
155 {
156 List<ItemSpec> itemSpecs = new List<ItemSpec>();
157 foreach (string item in items)
158 {
159 itemSpecs.Add(new ItemSpec(item, rtype));
160 }
161
162 Failure[] failures = null;
163 PendingChange[] changes = Repository.QueryPendingSets(Name, OwnerName, Name, OwnerName,
164 itemSpecs.ToArray(), includeDownloadInfo,
165 out failures);
166 foreach (Failure failure in failures)
167 {
168 Console.WriteLine(failure.ToString());
169 }
170
171 return changes;
172 }
173
174 public void Delete()
175 {
176 Repository.DeleteWorkspace(Name, OwnerName);
177 Workstation.Current.RemoveCachedWorkspaceInfo(VersionControlServer.Uri, Name);
178 }
179
180 public GetStatus Get()
181 {
182 return Get(VersionSpec.Latest, GetOptions.None);
183 }
184
185 public GetStatus Get(VersionSpec versionSpec, GetOptions options)
186 {
187 GetRequest request = new GetRequest(versionSpec);
188 return Get(request, GetOptions.None, null, null);
189 }
190
191 public GetStatus Get(GetRequest request, GetOptions options)
192 {
193 return Get(request, options, null, null);
194 }
195
196 public GetStatus Get(GetRequest[] requests, GetOptions options)
197 {
198 return Get(requests, options, null, null);
199 }
200
201 public GetStatus Get(GetRequest request, GetOptions options,
202 GetFilterCallback filterCallback, object userData)
203 {
204 GetRequest[] requests = new GetRequest[1];
205 requests[0] = request;
206 return Get(requests, options, filterCallback, userData);
207 }
208
209 public GetStatus Get (string[] items, VersionSpec version,
210 RecursionType recursion, GetOptions options)
211 {
212 List<GetRequest> requests = new List<GetRequest>();
213 foreach (string item in items)
214 {
215 requests.Add(new GetRequest(item, recursion, version));
216 }
217
218 return Get(requests.ToArray(), options, null, null);
219 }
220
221 public GetStatus Get(GetRequest[] requests, GetOptions options,
222 GetFilterCallback filterCallback, object userData)
223 {
224 bool force = ((GetOptions.Overwrite & options) == GetOptions.Overwrite);
225 bool noGet = false; // not implemented below: ((GetOptions.Preview & options) == GetOptions.Preview);
226
227 GetOperation[] getOperations = Repository.Get(Name, OwnerName, requests, force, noGet);
228 if (null != filterCallback) filterCallback(this, getOperations, userData);
229
230 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
231 foreach (GetOperation getOperation in getOperations)
232 {
233 string uPath = null;
234 GettingEventArgs args = new GettingEventArgs(this, getOperation);
235
236 // Console.WriteLine(getOperation.ToString());
237
238 if (getOperation.DeletionId != 0)
239 {
240 if ((getOperation.ItemType == ItemType.Folder)&&
241 (Directory.Exists(getOperation.SourceLocalItem)))
242 {
243 UnsetDirectoryAttributes(getOperation.SourceLocalItem);
244 Directory.Delete(getOperation.SourceLocalItem, true);
245 }
246 else if ((getOperation.ItemType == ItemType.File)&&
247 (File.Exists(getOperation.SourceLocalItem)))
248 {
249 UnsetFileAttributes(getOperation.SourceLocalItem);
250 File.Delete(getOperation.SourceLocalItem);
251 }
252 }
253 else if ((!String.IsNullOrEmpty(getOperation.TargetLocalItem))&&
254 (!String.IsNullOrEmpty(getOperation.SourceLocalItem))&&
255 (getOperation.SourceLocalItem != getOperation.TargetLocalItem))
256 {
257 uPath = getOperation.TargetLocalItem;
258 try
259 {
260 File.Move(getOperation.SourceLocalItem, getOperation.TargetLocalItem);
261 }
262 catch (IOException)
263 {
264 args.Status = OperationStatus.TargetIsDirectory;
265 }
266 }
267 else if (getOperation.ChangeType == ChangeType.None &&
268 getOperation.VersionServer != 0)
269 {
270 uPath = getOperation.TargetLocalItem;
271 string directory = uPath;
272
273 if (getOperation.ItemType == ItemType.File)
274 directory = Path.GetDirectoryName(uPath);
275
276 if (!Directory.Exists(directory))
277 Directory.CreateDirectory(directory);
278
279 if (getOperation.ItemType == ItemType.File)
280 {
281 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
282 SetFileAttributes(uPath);
283 }
284 }
285
286 versionControlServer.OnDownloading(args);
287 updates.QueueUpdate(getOperation.ItemId, uPath, getOperation.VersionServer);
288 }
289
290 updates.Flush();
291 return new GetStatus(getOperations.Length);
292 }
293
294 public ExtendedItem[][] GetExtendedItems (ItemSpec[] itemSpecs,
295 DeletedState deletedState,
296 ItemType itemType)
297 {
298 return Repository.QueryItemsExtended(Name, OwnerName,
299 itemSpecs, deletedState, itemType);
300 }
301
302 public string GetServerItemForLocalItem(string localItem)
303 {
304 string item = TryGetServerItemForLocalItem(localItem);
305 if (item == null)
306 throw new ItemNotMappedException(localItem);
307 return item;
308 }
309
310 public string GetLocalItemForServerItem(string serverItem)
311 {
312 string item = TryGetLocalItemForServerItem(serverItem);
313 if (item == null)
314 throw new ItemNotMappedException(serverItem);
315 return item;
316 }
317
318 public bool IsLocalPathMapped(string localPath)
319 {
320 foreach (WorkingFolder workingFolder in Folders)
321 {
322 if (localPath.StartsWith(workingFolder.LocalItem))
323 return true;
324 }
325
326 return false;
327 }
328
329 public bool IsServerPathMapped(string serverPath)
330 {
331 foreach (WorkingFolder workingFolder in Folders)
332 {
333 if (serverPath.StartsWith(workingFolder.ServerItem))
334 return true;
335 }
336
337 return false;
338 }
339
340 public void Map(string teamProject, string sourceProject) {
341 WorkingFolder[] folders = new WorkingFolder[1];
342 folders[0] = new WorkingFolder(sourceProject, teamProject);
343 Update(Name, OwnerName, folders);
344 }
345
346 public int PendAdd(string path)
347 {
348 return PendAdd(path, false);
349 }
350
351 public int PendAdd(string path, bool isRecursive)
352 {
353 string[] paths = new string[1];
354 paths[0] = path;
355 return PendAdd(paths, isRecursive);
356 }
357
358 public int PendAdd(string[] paths, bool isRecursive)
359 {
360 List<ChangeRequest> changes = new List<ChangeRequest>();
361
362 foreach (string path in paths)
363 {
364 ItemType itemType = ItemType.File;
365 if (Directory.Exists(path)) itemType = ItemType.Folder;
366 changes.Add(new ChangeRequest(path, RequestType.Add, itemType));
367
368 if (!isRecursive || itemType != ItemType.Folder) continue;
369
370 DirectoryInfo dir = new DirectoryInfo(path);
371 FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
372
373 foreach (FileInfo file in localFiles)
374 changes.Add(new ChangeRequest(file.FullName, RequestType.Add, ItemType.File));
375 }
376
377 if (changes.Count == 0) return 0;
378
379 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
380 return operations.Length;
381 }
382
383 public int PendDelete(string path)
384 {
385 return PendDelete(path, RecursionType.None);
386 }
387
388 public int PendDelete(string path, RecursionType recursionType)
389 {
390 string[] paths = new string[1];
391 paths[0] = path;
392
393 return PendDelete(paths, recursionType);
394 }
395
396 public int PendDelete(string[] paths, RecursionType recursionType)
397 {
398 List<ChangeRequest> changes = new List<ChangeRequest>();
399 foreach (string path in paths)
400 {
401 ItemType itemType = ItemType.File;
402 if (Directory.Exists(path)) itemType = ItemType.Folder;
403 changes.Add(new ChangeRequest(path, RequestType.Delete, itemType));
404 }
405
406 if (changes.Count == 0) return 0;
407
408 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
409 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
410
411 // first delete all files
412 foreach (GetOperation operation in operations)
413 {
414 if (operation.ItemType != ItemType.File) continue;
415 if (!File.Exists(operation.SourceLocalItem)) continue;
416
417 UnsetFileAttributes(operation.SourceLocalItem);
418 File.Delete(operation.SourceLocalItem);
419 updates.QueueUpdate(operation.ItemId, null, operation.VersionServer);
420 }
421
422 // then any directories
423 foreach (GetOperation operation in operations)
424 {
425 if (operation.ItemType != ItemType.Folder) continue;
426 if (!Directory.Exists(operation.SourceLocalItem)) continue;
427
428 //DirectoryInfo dir = new DirectoryInfo(operation.SourceLocalItem);
429 //FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
430 //foreach (FileInfo file in localFiles)
431 // UnsetFileAttributes(file.FullName);
432
433 Directory.Delete(operation.SourceLocalItem, true);
434 updates.QueueUpdate(operation.ItemId, null, operation.VersionServer);
435 }
436
437 updates.Flush();
438 return operations.Length;
439 }
440
441 public int PendEdit(string path)
442 {
443 // Annotation[] annotations = Repository.QueryAnnotation("ExclusiveCheckout",
444 // path, 0);
445 // foreach (Annotation annotation in annotations)
446 // {
447 // Console.WriteLine(annotation.ToString());
448 // }
449
450 return PendEdit(path, RecursionType.None);
451 }
452
453 public int PendEdit(string path, RecursionType recursionType)
454 {
455 string[] paths = new string[1];
456 paths[0] = path;
457
458 return PendEdit(paths, recursionType);
459 }
460
461 public int PendEdit(string[] paths, RecursionType recursionType)
462 {
463 List<ChangeRequest> changes = new List<ChangeRequest>();
464 foreach (string path in paths)
465 {
466 changes.Add(new ChangeRequest(path, RequestType.Edit, ItemType.File));
467 }
468
469 if (changes.Count == 0) return 0;
470
471 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
472 foreach (GetOperation getOperation in getOperations)
473 {
474 UnsetFileAttributes(getOperation.TargetLocalItem);
475 }
476
477 return getOperations.Length;
478 }
479
480 public int PendRename(string oldPath, string newPath)
481 {
482 string newServerPath;
483 if (VersionControlPath.IsServerItem(newPath)) newServerPath = GetServerItemForLocalItem(newPath);
484 else newServerPath = newPath;
485
486 ItemType itemType = ItemType.File;
487 if (Directory.Exists(oldPath)) itemType = ItemType.Folder;
488
489 List<ChangeRequest> changes = new List<ChangeRequest>();
490 changes.Add(new ChangeRequest(oldPath, newServerPath, RequestType.Rename, itemType));
491
492 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
493
494 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
495 foreach (GetOperation getOperation in getOperations)
496 {
497 if (itemType == ItemType.File)
498 File.Move(oldPath, getOperation.TargetLocalItem);
499 else
500 Directory.Move(oldPath, getOperation.TargetLocalItem);
501
502 updates.QueueUpdate(getOperation.ItemId, getOperation.TargetLocalItem, getOperation.VersionServer);
503 }
504
505 updates.Flush();
506 return 1;
507 }
508
509 public int SetLock(string path, LockLevel lockLevel)
510 {
511 return SetLock(path, lockLevel, RecursionType.None);
512 }
513
514 public int SetLock(string path, LockLevel lockLevel, RecursionType recursion)
515 {
516 string[] paths = new string[1];
517 paths[0] = path;
518 return SetLock(paths, lockLevel, recursion);
519 }
520
521 public int SetLock(string[] paths, LockLevel lockLevel)
522 {
523 return SetLock(paths, lockLevel, RecursionType.None);
524 }
525
526 public int SetLock(string[] paths, LockLevel lockLevel, RecursionType recursion)
527 {
528 List<ChangeRequest> changes = new List<ChangeRequest>();
529
530 foreach (string path in paths)
531 {
532 ItemType itemType = ItemType.File;
533 if (Directory.Exists(path)) itemType = ItemType.Folder;
534 changes.Add(new ChangeRequest(path, RequestType.Lock, itemType, recursion, lockLevel));
535 }
536
537 if (changes.Count == 0) return 0;
538
539 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
540 return operations.Length;
541 }
542
543 public void Shelve (Shelveset shelveset, PendingChange[] changes,
544 ShelvingOptions options)
545 {
546 List<string> serverItems = new List<string>();
547
548 foreach (PendingChange change in changes)
549 {
550 // upload new or changed files only
551 if ((change.ItemType == ItemType.File) &&
552 (change.IsAdd || change.IsEdit ))
553 {
554 Repository.ShelveFile(Name, OwnerName, change);
555 }
556
557 serverItems.Add(change.ServerItem);
558 }
559
560 Repository.Shelve(this, shelveset, serverItems.ToArray(), options);
561 }
562
563 internal static Workspace FromXml(Repository repository, XmlReader reader)
564 {
565 string elementName = reader.Name;
566
567 string computer = reader.GetAttribute("computer");
568 string name = reader.GetAttribute("name");
569 string owner = reader.GetAttribute("owner");
570
571 string comment = "";
572 DateTime lastAccessDate = DateTime.Now;
573 List<WorkingFolder> folders = new List<WorkingFolder>();
574
575 while (reader.Read())
576 {
577 if (reader.NodeType == XmlNodeType.EndElement && reader.Name == elementName)
578 break;
579
580 if (reader.NodeType == XmlNodeType.Element)
581 {
582 switch (reader.Name)
583 {
584 case "WorkingFolder":
585 folders.Add(WorkingFolder.FromXml(repository, reader));
586 break;
587 case "Comment":
588 comment = reader.ReadString();
589 break;
590 case "LastAccessDate":
591 lastAccessDate = reader.ReadElementContentAsDateTime();
592 break;
593 }
594 }
595 }
596
597 Workspace w = new Workspace(repository.VersionControlServer, name, owner, comment, folders.ToArray(), computer);
598 w.lastAccessDate = lastAccessDate;
599 return w;
600 }
601
602 internal void ToXml(XmlWriter writer, string element)
603 {
604 writer.WriteStartElement(element);
605 writer.WriteAttributeString("computer", Computer);
606 writer.WriteAttributeString("name", Name);
607 writer.WriteAttributeString("owner", OwnerName);
608 writer.WriteElementString("Comment", Comment);
609
610 if (folders != null)
611 {
612 writer.WriteStartElement("Folders");
613
614 foreach (WorkingFolder folder in folders)
615 {
616 folder.ToXml(writer, element);
617 }
618
619 writer.WriteEndElement();
620 }
621
622 writer.WriteEndElement();
623 }
624
625 public override string ToString()
626 {
627 StringBuilder sb = new StringBuilder();
628
629 sb.Append("Workspace instance ");
630 sb.Append(GetHashCode());
631
632 sb.Append("\n Comment: ");
633 sb.Append(Comment);
634
635 sb.Append("\n LastAccessDate: ");
636 sb.Append(LastAccessDate);
637
638 sb.Append("\n Folders: ");
639 if (folders != null)
640 {
641 foreach (WorkingFolder folder in folders)
642 {
643 sb.Append(folder.ToString());
644 }
645 }
646
647 sb.Append("\n Computer: ");
648 sb.Append(Computer);
649
650 sb.Append("\n Name: ");
651 sb.Append(Name);
652
653 sb.Append("\n OwnerName: ");
654 sb.Append(OwnerName);
655
656 return sb.ToString();
657 }
658
659 public string TryGetServerItemForLocalItem(string localItem)
660 {
661 string serverItem = null;
662 int longest = 0;
663
664 // find the longest matching serveritem
665 foreach (WorkingFolder folder in folders)
666 {
667 //Console.WriteLine("item: {0} =? folder: {1}", localItem, folder.LocalItem);
668 if (!localItem.StartsWith(folder.LocalItem, StringComparison.InvariantCultureIgnoreCase)) continue;
669
670 int clen = folder.LocalItem.Length;
671 if (clen > longest)
672 {
673 serverItem = String.Format("{0}{1}", folder.ServerItem, localItem.Substring(clen));
674 longest = clen;
675 }
676 }
677
678 return serverItem;
679 }
680
681 public string TryGetLocalItemForServerItem(string serverItem)
682 {
683 string localItem = null;
684 int longest = 0;
685
686 foreach (WorkingFolder folder in folders)
687 {
688 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
689
690 int clen = folder.ServerItem.Length;
691 if (clen > longest)
692 {
693 localItem = String.Format("{0}{1}", folder.LocalItem, serverItem.Substring(clen));
694 longest = clen;
695 }
696 }
697
698 return localItem;
699 }
700
701 public WorkingFolder TryGetWorkingFolderForServerItem(string serverItem)
702 {
703 int maxPath = 0;
704 WorkingFolder workingFolder = null;
705
706 foreach (WorkingFolder folder in folders)
707 {
708 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
709
710 if (folder.LocalItem.Length > maxPath)
711 {
712 workingFolder = folder;
713 maxPath = folder.LocalItem.Length;
714 }
715 }
716
717 return workingFolder;
718 }
719
720 public int Undo(string path)
721 {
722 return Undo(path, RecursionType.None);
723 }
724
725 public int Undo(string path, RecursionType recursionType)
726 {
727 string[] paths = new string[1];
728 paths[0] = path;
729 return Undo(paths, recursionType);
730 }
731
732 public int Undo(string[] paths, RecursionType recursionType)
733 {
734 List<ItemSpec> specs = new List<ItemSpec>();
735
736 foreach (string path in paths)
737 {
738 specs.Add(new ItemSpec(path, recursionType));
739 }
740
741 // is this the same logic as a workspace Get?
742 // can we make one function to handle both cases?
743
744 GetOperation[] getOperations = Repository.UndoPendingChanges(Name, OwnerName, specs.ToArray());
745 foreach (GetOperation getOperation in getOperations)
746 {
747 if (getOperation.ChangeType == ChangeType.Edit ||
748 getOperation.ChangeType == ChangeType.Delete)
749 {
750 string uPath = getOperation.TargetLocalItem;
751 string directory = uPath;
752
753 if (getOperation.ItemType == ItemType.File)
754 directory = Path.GetDirectoryName(uPath);
755
756 if (!Directory.Exists(directory))
757 Directory.CreateDirectory(directory);
758
759 if (getOperation.ItemType == ItemType.File)
760 {
761 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
762 SetFileAttributes(uPath);
763 }
764 }
765 }
766
767 return getOperations.Length;
768 }
769
770 public void Update (string newName, string newComment, WorkingFolder[] newMappings)
771 {
772 Workspace w1 = new Workspace(VersionControlServer, newName, OwnerName,
773 newComment, newMappings, Computer);
774 Workspace w2 = Repository.UpdateWorkspace(Name, OwnerName, w1);
775
776 Workstation.Current.UpdateCachedWorkspaceInfo(VersionControlServer.Uri,
777 w2, newMappings);
778
779 folders = w2.Folders;
780 }
781
782 public void RefreshMappings ()
783 {
784 Workspace w = Repository.QueryWorkspace(Name, OwnerName);
785 this.folders = w.folders;
786 }
787
788 public string Comment
789 {
790 get { return comment; }
791 }
792
793 public string Computer
794 {
795 get { return computer; }
796 }
797
798 public WorkingFolder[] Folders
799 {
800 get { return folders; }
801 }
802
803 public string Name
804 {
805 get { return name; }
806 }
807
808 public DateTime LastAccessDate
809 {
810 get { return lastAccessDate; }
811 }
812
813 public string OwnerName
814 {
815 get { return ownerName; }
816 }
817
818 public VersionControlServer VersionControlServer
819 {
820 get { return versionControlServer; }
821 }
822
823 internal Repository Repository
824 {
825 get { return versionControlServer.Repository; }
826 }
827
828 internal void SetFileAttributes(string path)
829 {
830 if (!readWriteSetting)
831 File.SetAttributes(path, FileAttributes.ReadOnly);
832 }
833
834 internal void UnsetFileAttributes(string path)
835 {
836 if (!readWriteSetting)
837 File.SetAttributes(path, FileAttributes.Normal);
838 }
839
840 internal void UnsetDirectoryAttributes(string path)
841 {
842 if (readWriteSetting) return;
843
844 DirectoryInfo dir = new DirectoryInfo(path);
845 FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
846 foreach (FileInfo file in localFiles)
847 File.SetAttributes(file.FullName, FileAttributes.Normal);
848 }
849
850 }
851 }
Team Foundation for Mono