?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
prep for online patch
[tfs.git] / class / Microsoft.TeamFoundation.VersionControl.Client / Workspace.cs
blob715172160e9b8aeb44f4bdee3ef84653d96ef6f3
1 //
2 // Microsoft.TeamFoundation.VersionControl.Client.Workspace
3 //
4 // Authors:
5 // Joel Reed (joelwreed@gmail.com)
6 //
7
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
50 internal Workspace(VersionControlServer versionControlServer, string name,
51 string ownerName, string comment,
52 WorkingFolder[] folders, string computer)
53 {
54 this.versionControlServer = versionControlServer;
55 this.name = name;
56 this.ownerName = ownerName;
57 this.comment = comment;
58 this.folders = folders;
59 this.computer = computer;
60 }
61
62 public int CheckIn(PendingChange[] changes, string comment)
63 {
64 if (changes.Length == 0) return 0;
65
66 List<string> serverItems = new List<string>();
67 foreach (PendingChange change in changes)
68 {
69 // upload new or changed files only
70 if ((change.ItemType == ItemType.File) &&
71 (change.IsAdd || change.IsEdit ))
72 {
73 Repository.UploadFile(Name, OwnerName, change);
74 File.SetAttributes(change.LocalItem, FileAttributes.ReadOnly);
75 }
76
77 serverItems.Add(change.ServerItem);
78 }
79
80 return Repository.CheckIn(this, serverItems.ToArray(), comment);
81 }
82
83 public int CompareTo (object o)
84 {
85 Workspace a = this, b = (Workspace)o;
86
87 int r0 = a.VersionControlServer.ServerGuid.CompareTo (b.VersionControlServer.ServerGuid);
88 if (r0 != 0) return r0;
89
90 int r1 = a.Name.CompareTo (b.Name);
91 if (r1 != 0) return r1;
92
93 int r2 = a.OwnerName.CompareTo (b.OwnerName);
94 return r2;
95 }
96
97 public PendingChange[] GetPendingChanges()
98 {
99 return GetPendingChanges(VersionControlPath.RootFolder, RecursionType.Full);
100 }
101
102 public PendingChange[] GetPendingChanges(string item)
103 {
104 return GetPendingChanges(item, RecursionType.None);
105 }
106
107 public PendingChange[] GetPendingChanges(string item, RecursionType rtype)
108 {
109 return GetPendingChanges(item, rtype, false);
110 }
111
112 public PendingChange[] GetPendingChanges(string item, RecursionType rtype,
113 bool includeDownloadInfo)
114 {
115 string[] items = new string[1];
116 items[0] = item;
117 return GetPendingChanges(items, rtype, includeDownloadInfo);
118 }
119
120 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype)
121 {
122 return GetPendingChanges(items, rtype, false);
123 }
124
125 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype,
126 bool includeDownloadInfo)
127 {
128 List<ItemSpec> itemSpecs = new List<ItemSpec>();
129 foreach (string item in items)
130 {
131 itemSpecs.Add(new ItemSpec(item, rtype));
132 }
133
134 Failure[] failures = null;
135 PendingChange[] changes = Repository.QueryPendingSets(Name, OwnerName, Name, OwnerName,
136 itemSpecs.ToArray(), includeDownloadInfo,
137 out failures);
138 foreach (Failure failure in failures)
139 {
140 Console.WriteLine(failure.ToString());
141 }
142
143 return changes;
144 }
145
146 public void Delete()
147 {
148 Repository.DeleteWorkspace(Name, OwnerName);
149 Workstation.Current.RemoveCachedWorkspaceInfo(VersionControlServer.Uri, Name);
150 }
151
152 public GetStatus Get()
153 {
154 return Get(VersionSpec.Latest, GetOptions.None);
155 }
156
157 public GetStatus Get(VersionSpec versionSpec, GetOptions options)
158 {
159 GetRequest request = new GetRequest(versionSpec);
160 return Get(request, GetOptions.None, null, null);
161 }
162
163 public GetStatus Get(GetRequest request, GetOptions options)
164 {
165 return Get(request, options, null, null);
166 }
167
168 public GetStatus Get(GetRequest[] requests, GetOptions options)
169 {
170 return Get(requests, options, null, null);
171 }
172
173 public GetStatus Get(GetRequest request, GetOptions options,
174 GetFilterCallback filterCallback, object userData)
175 {
176 GetRequest[] requests = new GetRequest[1];
177 requests[0] = request;
178 return Get(requests, options, filterCallback, userData);
179 }
180
181 public GetStatus Get (string[] items, VersionSpec version,
182 RecursionType recursion, GetOptions options)
183 {
184 List<GetRequest> requests = new List<GetRequest>();
185 foreach (string item in items)
186 {
187 requests.Add(new GetRequest(item, recursion, version));
188 }
189
190 return Get(requests.ToArray(), options, null, null);
191 }
192
193 public GetStatus Get(GetRequest[] requests, GetOptions options,
194 GetFilterCallback filterCallback, object userData)
195 {
196 bool force = ((GetOptions.Overwrite & options) == GetOptions.Overwrite);
197 bool noGet = ! ((GetOptions.GetAll & options) == GetOptions.GetAll);
198
199 GetOperation[] getOperations = Repository.Get(Name, OwnerName, requests, force, noGet);
200 if (null != filterCallback) filterCallback(this, getOperations, userData);
201
202 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
203 foreach (GetOperation getOperation in getOperations)
204 {
205 string uPath = null;
206 GettingEventArgs args = new GettingEventArgs(this, getOperation);
207
208 Console.WriteLine(getOperation.ToString());
209
210 if (getOperation.DeletionId != 0)
211 {
212 if ((getOperation.ItemType == ItemType.Folder)&&
213 (Directory.Exists(getOperation.SourceLocalItem)))
214 {
215 Directory.Delete(getOperation.SourceLocalItem, true);
216 }
217 else if ((getOperation.ItemType == ItemType.File)&&
218 (File.Exists(getOperation.SourceLocalItem)))
219 {
220 File.SetAttributes(getOperation.SourceLocalItem, FileAttributes.Normal);
221 File.Delete(getOperation.SourceLocalItem);
222 }
223 }
224 else if ((!String.IsNullOrEmpty(getOperation.TargetLocalItem))&&
225 (!String.IsNullOrEmpty(getOperation.SourceLocalItem))&&
226 (getOperation.SourceLocalItem != getOperation.TargetLocalItem))
227 {
228 uPath = getOperation.TargetLocalItem;
229 try
230 {
231 File.Move(getOperation.SourceLocalItem, getOperation.TargetLocalItem);
232 }
233 catch (IOException)
234 {
235 args.Status = OperationStatus.TargetIsDirectory;
236 }
237 }
238 else if (getOperation.ChangeType == ChangeType.None)
239 {
240 uPath = getOperation.TargetLocalItem;
241 string directory = uPath;
242
243 if (getOperation.ItemType == ItemType.File)
244 directory = Path.GetDirectoryName(uPath);
245
246 if (!Directory.Exists(directory))
247 Directory.CreateDirectory(directory);
248
249 if (getOperation.ItemType == ItemType.File)
250 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
251 }
252
253 versionControlServer.OnDownloading(args);
254 updates.QueueUpdate(getOperation.ItemId, uPath, getOperation.VersionServer);
255 }
256
257 updates.Flush();
258 return new GetStatus(getOperations.Length);
259 }
260
261 public ExtendedItem[][] GetExtendedItems (ItemSpec[] itemSpecs,
262 DeletedState deletedState,
263 ItemType itemType)
264 {
265 return Repository.QueryItemsExtended(Name, OwnerName,
266 itemSpecs, deletedState, itemType);
267 }
268
269 public string GetServerItemForLocalItem(string localItem)
270 {
271 string item = TryGetServerItemForLocalItem(localItem);
272 if (item == null)
273 throw new ItemNotMappedException(localItem);
274 return item;
275 }
276
277 public string GetLocalItemForServerItem(string serverItem)
278 {
279 string item = TryGetLocalItemForServerItem(serverItem);
280 if (item == null)
281 throw new ItemNotMappedException(serverItem);
282 return item;
283 }
284
285 public bool IsLocalPathMapped(string localPath)
286 {
287 foreach (WorkingFolder workingFolder in Folders)
288 {
289 if (workingFolder.LocalItem == localPath) return true;
290 }
291
292 return false;
293 }
294
295 public bool IsServerPathMapped(string serverPath)
296 {
297 foreach (WorkingFolder workingFolder in Folders)
298 {
299 if (workingFolder.ServerItem == serverPath) return true;
300 }
301
302 return false;
303 }
304
305 public void Map(string teamProject, string sourceProject) {
306 WorkingFolder[] folders = new WorkingFolder[1];
307 folders[0] = new WorkingFolder(sourceProject, teamProject);
308 Update(Name, OwnerName, folders);
309 }
310
311 public int PendAdd(string path)
312 {
313 return PendAdd(path, false);
314 }
315
316 public int PendAdd(string path, bool isRecursive)
317 {
318 string[] paths = new string[1];
319 paths[0] = path;
320 return PendAdd(paths, isRecursive);
321 }
322
323 public int PendAdd(string[] paths, bool isRecursive)
324 {
325 List<ChangeRequest> changes = new List<ChangeRequest>();
326
327 foreach (string path in paths)
328 {
329 ItemType itemType = ItemType.File;
330 if (Directory.Exists(path)) itemType = ItemType.Folder;
331 changes.Add(new ChangeRequest(path, RequestType.Add, itemType));
332
333 if (!isRecursive || itemType != ItemType.Folder) continue;
334
335 DirectoryInfo dir = new DirectoryInfo(path);
336 FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
337
338 foreach (FileInfo file in localFiles)
339 changes.Add(new ChangeRequest(file.FullName, RequestType.Add, ItemType.File));
340 }
341
342 if (changes.Count == 0) return 0;
343
344 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
345 return operations.Length;
346 }
347
348 public int PendDelete(string path)
349 {
350 return PendDelete(path, RecursionType.None);
351 }
352
353 public int PendDelete(string path, RecursionType recursionType)
354 {
355 string[] paths = new string[1];
356 paths[0] = path;
357
358 return PendDelete(paths, recursionType);
359 }
360
361 public int PendDelete(string[] paths, RecursionType recursionType)
362 {
363 List<ChangeRequest> changes = new List<ChangeRequest>();
364 foreach (string path in paths)
365 {
366 ItemType itemType = ItemType.File;
367 if (Directory.Exists(path)) itemType = ItemType.Folder;
368 changes.Add(new ChangeRequest(path, RequestType.Delete, itemType));
369 }
370
371 if (changes.Count == 0) return 0;
372
373 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
374 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
375
376 foreach (GetOperation operation in operations)
377 {
378 if (File.Exists(operation.SourceLocalItem))
379 {
380 File.SetAttributes(operation.SourceLocalItem, FileAttributes.Normal);
381 File.Delete(operation.SourceLocalItem);
382 }
383 else
384 {
385 Directory.Delete(operation.SourceLocalItem);
386 }
387
388 updates.QueueUpdate(operation.ItemId, null, operation.VersionServer);
389 }
390
391 updates.Flush();
392 return operations.Length;
393 }
394
395 public int PendEdit(string path)
396 {
397 // Annotation[] annotations = Repository.QueryAnnotation("ExclusiveCheckout",
398 // path, 0);
399 // foreach (Annotation annotation in annotations)
400 // {
401 // Console.WriteLine(annotation.ToString());
402 // }
403
404 return PendEdit(path, RecursionType.None);
405 }
406
407 public int PendEdit(string path, RecursionType recursionType)
408 {
409 string[] paths = new string[1];
410 paths[0] = path;
411
412 return PendEdit(paths, recursionType);
413 }
414
415 public int PendEdit(string[] paths, RecursionType recursionType)
416 {
417 List<ChangeRequest> changes = new List<ChangeRequest>();
418 foreach (string path in paths)
419 {
420 changes.Add(new ChangeRequest(path, RequestType.Edit, ItemType.File));
421 }
422
423 if (changes.Count == 0) return 0;
424
425 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
426
427 foreach (GetOperation getOperation in getOperations)
428 {
429 File.SetAttributes(getOperation.TargetLocalItem, FileAttributes.Normal);
430 }
431
432 return getOperations.Length;
433 }
434
435 public int PendRename(string oldPath, string newPath)
436 {
437 string newServerPath;
438 if (VersionControlPath.IsServerItem(newPath)) newServerPath = GetServerItemForLocalItem(newPath);
439 else newServerPath = newPath;
440
441 ItemType itemType = ItemType.File;
442 if (Directory.Exists(oldPath)) itemType = ItemType.Folder;
443
444 List<ChangeRequest> changes = new List<ChangeRequest>();
445 changes.Add(new ChangeRequest(oldPath, newServerPath, RequestType.Rename, itemType));
446
447 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
448
449 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
450 foreach (GetOperation getOperation in getOperations)
451 {
452 File.Move(oldPath, getOperation.TargetLocalItem);
453 updates.QueueUpdate(getOperation.ItemId, getOperation.TargetLocalItem, getOperation.VersionServer);
454 }
455
456 updates.Flush();
457 return 1;
458 }
459
460 internal static Workspace FromXml(Repository repository, XmlReader reader)
461 {
462 string elementName = reader.Name;
463
464 string computer = reader.GetAttribute("computer");
465 string name = reader.GetAttribute("name");
466 string owner = reader.GetAttribute("owner");
467
468 string comment = "";
469 DateTime lastAccessDate = DateTime.Now;
470 List<WorkingFolder> folders = new List<WorkingFolder>();
471
472 while (reader.Read())
473 {
474 if (reader.NodeType == XmlNodeType.EndElement && reader.Name == elementName)
475 break;
476
477 if (reader.NodeType == XmlNodeType.Element)
478 {
479 switch (reader.Name)
480 {
481 case "WorkingFolder":
482 folders.Add(WorkingFolder.FromXml(repository, reader));
483 break;
484 case "Comment":
485 comment = reader.ReadString();
486 break;
487 case "LastAccessDate":
488 lastAccessDate = reader.ReadElementContentAsDateTime();
489 break;
490 }
491 }
492 }
493
494 Workspace w = new Workspace(repository.VersionControlServer, name, owner, comment, folders.ToArray(), computer);
495 w.lastAccessDate = lastAccessDate;
496 return w;
497 }
498
499 internal void ToXml(XmlWriter writer, string element)
500 {
501 writer.WriteStartElement(element);
502 writer.WriteAttributeString("computer", Computer);
503 writer.WriteAttributeString("name", Name);
504 writer.WriteAttributeString("owner", OwnerName);
505 writer.WriteElementString("Comment", Comment);
506
507 if (folders != null)
508 {
509 writer.WriteStartElement("Folders");
510
511 foreach (WorkingFolder folder in folders)
512 {
513 folder.ToXml(writer, element);
514 }
515
516 writer.WriteEndElement();
517 }
518
519 writer.WriteEndElement();
520 }
521
522 public override string ToString()
523 {
524 StringBuilder sb = new StringBuilder();
525
526 sb.Append("Workspace instance ");
527 sb.Append(GetHashCode());
528
529 sb.Append("\n Comment: ");
530 sb.Append(Comment);
531
532 sb.Append("\n LastAccessDate: ");
533 sb.Append(LastAccessDate);
534
535 sb.Append("\n Folders: ");
536 if (folders != null)
537 {
538 foreach (WorkingFolder folder in folders)
539 {
540 sb.Append(folder.ToString());
541 }
542 }
543
544 sb.Append("\n Computer: ");
545 sb.Append(Computer);
546
547 sb.Append("\n Name: ");
548 sb.Append(Name);
549
550 sb.Append("\n OwnerName: ");
551 sb.Append(OwnerName);
552
553 return sb.ToString();
554 }
555
556 public string TryGetServerItemForLocalItem(string localItem)
557 {
558 foreach (WorkingFolder folder in folders)
559 {
560 if (!localItem.StartsWith(folder.LocalItem, StringComparison.InvariantCultureIgnoreCase)) continue;
561 string suffix = localItem.Substring(folder.LocalItem.Length);
562 return String.Format("{0}{1}", folder.ServerItem, suffix);
563 }
564
565 return null;
566 }
567
568 public string TryGetLocalItemForServerItem(string serverItem)
569 {
570 foreach (WorkingFolder folder in folders)
571 {
572 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
573 string suffix = serverItem.Substring(folder.ServerItem.Length);
574 return String.Format("{0}{1}", folder.LocalItem, suffix);
575 }
576
577 return null;
578 }
579
580 public WorkingFolder TryGetWorkingFolderForServerItem(string serverItem)
581 {
582 int maxPath = 0;
583 WorkingFolder workingFolder = null;
584
585 foreach (WorkingFolder folder in folders)
586 {
587 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
588
589 if (folder.LocalItem.Length > maxPath)
590 {
591 workingFolder = folder;
592 maxPath = folder.LocalItem.Length;
593 }
594 }
595
596 return workingFolder;
597 }
598
599 public int Undo(string path)
600 {
601 return Undo(path, RecursionType.None);
602 }
603
604 public int Undo(string path, RecursionType recursionType)
605 {
606 string[] paths = new string[1];
607 paths[0] = path;
608 return Undo(paths, recursionType);
609 }
610
611 public int Undo(string[] paths, RecursionType recursionType)
612 {
613 List<ItemSpec> specs = new List<ItemSpec>();
614
615 foreach (string path in paths)
616 {
617 specs.Add(new ItemSpec(path, recursionType));
618 }
619
620 // is this the same logic as a workspace Get?
621 // can we make one function to handle both cases?
622
623 GetOperation[] getOperations = Repository.UndoPendingChanges(Name, OwnerName, specs.ToArray());
624 foreach (GetOperation getOperation in getOperations)
625 {
626 if (getOperation.ChangeType == ChangeType.Edit ||
627 getOperation.ChangeType == ChangeType.Delete)
628 {
629 string uPath = getOperation.TargetLocalItem;
630 string directory = uPath;
631
632 if (getOperation.ItemType == ItemType.File)
633 directory = Path.GetDirectoryName(uPath);
634
635 if (!Directory.Exists(directory))
636 Directory.CreateDirectory(directory);
637
638 if (getOperation.ItemType == ItemType.File)
639 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
640 }
641 }
642
643 return getOperations.Length;
644 }
645
646 public void Update (string newName, string newComment, WorkingFolder[] newMappings)
647 {
648 Workspace w1 = new Workspace(VersionControlServer, newName, OwnerName,
649 newComment, newMappings, Computer);
650 Workspace w2 = Repository.UpdateWorkspace(Name, OwnerName, w1);
651
652 Workstation.Current.UpdateCachedWorkspaceInfo(VersionControlServer.Uri,
653 w2, newMappings);
654
655 folders = w2.Folders;
656 }
657
658 public void RefreshMappings ()
659 {
660 Workspace w = Repository.QueryWorkspace(Name, OwnerName);
661 this.folders = w.folders;
662 }
663
664 public string Comment
665 {
666 get { return comment; }
667 }
668
669 public string Computer
670 {
671 get { return computer; }
672 }
673
674 public WorkingFolder[] Folders
675 {
676 get { return folders; }
677 }
678
679 public string Name
680 {
681 get { return name; }
682 }
683
684 public DateTime LastAccessDate
685 {
686 get { return lastAccessDate; }
687 }
688
689 public string OwnerName
690 {
691 get { return ownerName; }
692 }
693
694 public VersionControlServer VersionControlServer
695 {
696 get { return versionControlServer; }
697 }
698
699 internal Repository Repository
700 {
701 get { return versionControlServer.Repository; }
702 }
703 }
704
705 }
Team Foundation for Mono