class/Microsoft.TeamFoundation.VersionControl.Client/VersionControlServer.cs

   1 //
   2 // Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer
   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;
  31 using System.Collections.Generic;
  32 using System.IO;
  33 using System.Net;
  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 VersionControlServer
  41         {
  42                 private Repository repository;
  43                 private string authenticatedUser;
  44                 internal Uri uri;
  45
  46                 public event ExceptionEventHandler NonFatalError;
  47                 public event GettingEventHandler Getting;
  48                 public event ProcessingChangeEventHandler BeforeCheckinPendingChange;
  49                 public event PendingChangeEventHandler NewPendingChange;
  50                 public event ConflictEventHandler Conflict;
  51
  52                 //internal event FileTransferEventHandler Uploading;
  53
  54                 public VersionControlServer(Uri uri, ICredentials credentials)
  55                 {
  56                         this.uri = uri;
  57                         this.repository = new Repository(this, uri, credentials);
  58
  59                         if (credentials != null)
  60                                 this.authenticatedUser = credentials.GetCredential(uri, "").UserName;
  61                 }
  62
  63                 public LabelResult[] CreateLabel (VersionControlLabel label,
  64                                                                                                                                                         LabelItemSpec[] labelSpecs,
  65                                                                                                                                                         LabelChildOption childOption)
  66                 {
  67                         Workspace workspace = GetWorkspace(labelSpecs[0].ItemSpec.Item);
  68                         return repository.LabelItem(workspace, label, labelSpecs, childOption);
  69                 }
  70
  71                 public Workspace CreateWorkspace(string name, string owner)
  72                 {
  73                         return CreateWorkspace(name, owner, null, new WorkingFolder[0], Environment.MachineName);
  74                 }
  75
  76                 public Workspace CreateWorkspace(string name, string owner, string comment,
  77                                                                                                                                                  WorkingFolder[] folders, string computer)
  78                 {
  79                         Workspace w1 = new Workspace(this, name, owner, comment, folders, computer);
  80                         Workspace w2 = repository.CreateWorkspace(w1);
  81                         Workstation.Current.AddCachedWorkspaceInfo(ServerGuid, Uri, w2);
  82                         return w2;
  83                 }
  84
  85                 public void DeleteWorkspace(string workspaceName, string workspaceOwner)
  86                 {
  87                         repository.DeleteWorkspace(workspaceName, workspaceOwner);
  88                         Workstation.Current.RemoveCachedWorkspaceInfo(Uri, workspaceName);
  89                 }
  90
  91                 public Changeset GetChangeset (int changesetId)
  92                 {
  93                         return GetChangeset(changesetId, false, false);
  94                 }
  95
  96                 public Changeset GetChangeset (int changesetId, bool includeChanges,
  97                                                                                                                                          bool includeDownloadInfo)
  98                 {
  99                         return repository.QueryChangeset(changesetId, includeChanges, includeDownloadInfo);
 100                 }
 101
 102                 public Item GetItem(int id, int changeSet)
 103                 {
 104                         return GetItem(id, changeSet, false);
 105                 }
 106
 107                 public Item GetItem(int id, int changeSet, bool includeDownloadInfo)
 108                 {
 109                         int[] ids = new int[1];
 110                         ids[0] = id;
 111
 112                         Item[] items = GetItems(ids, changeSet, includeDownloadInfo);
 113                         if (items.Length > 0) return items[0];
 114                         return null;
 115                 }
 116
 117                 public Item[] GetItems(int[] ids, int changeSet)
 118                 {
 119                         return GetItems(ids, changeSet, false);
 120                 }
 121
 122                 public Item[] GetItems(int[] ids, int changeSet, bool includeDownloadInfo)
 123                 {
 124                         return repository.QueryItemsById(ids, changeSet, includeDownloadInfo);
 125                 }
 126
 127                 public ItemSet GetItems(string path, RecursionType recursionType)
 128                 {
 129                         ItemSpec itemSpec = new ItemSpec(path, recursionType);
 130                         LatestVersionSpec versionSpec = new LatestVersionSpec();
 131
 132                         return GetItems(itemSpec, versionSpec, DeletedState.NonDeleted,
 133                                                                                         ItemType.Any, false);
 134                 }
 135
 136                 public ItemSet GetItems(string path, VersionSpec versionSpec,
 137                                                                                                                 RecursionType recursionType)
 138                 {
 139                         ItemSpec itemSpec = new ItemSpec(path, recursionType);
 140                         return GetItems(itemSpec, versionSpec, DeletedState.NonDeleted,
 141                                                                                         ItemType.Any, false);
 142                 }
 143
 144                 public ItemSet GetItems(ItemSpec itemSpec, VersionSpec versionSpec,
 145                                                                                                                 DeletedState deletedState, ItemType itemType,
 146                                                                                                                 bool includeDownloadInfo)
 147                 {
 148                         string workspaceName = String.Empty;
 149                         string workspaceOwner = String.Empty;
 150
 151                         if (!VersionControlPath.IsServerItem(itemSpec.Item))
 152                                 {
 153                                         WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(itemSpec.Item);
 154                                         if (info != null)
 155                                                 {
 156                                                         workspaceName = info.Name;
 157                                                         workspaceOwner = info.OwnerName;
 158                                                 }
 159                                 }
 160
 161                         return repository.QueryItems(workspaceName, workspaceOwner,
 162                                                                                                                                          itemSpec, versionSpec, deletedState,
 163                                                                                                                                          itemType, includeDownloadInfo);
 164                 }
 165
 166                 public Workspace GetWorkspace(string localPath)
 167                 {
 168                         string path = Path.GetFullPath(localPath);
 169
 170                         WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(path);
 171                         if (info == null) throw new ItemNotMappedException(path);
 172
 173                         return new Workspace(this, info.Name, info.OwnerName,
 174                                                                                                          info.Comment, new WorkingFolder[0], Workstation.Current.Name);
 175                 }
 176
 177                 public Workspace GetWorkspace(string workspaceName, string workspaceOwner)
 178                 {
 179                         return repository.QueryWorkspace(workspaceName, workspaceOwner);
 180                 }
 181
 182                 public IEnumerable QueryHistory (string path, VersionSpec version,
 183                                                                                                                                                  int deletionId, RecursionType recursion,
 184                                                                                                                                                  string user, VersionSpec versionFrom,
 185                                                                                                                                                  VersionSpec versionTo, int maxCount,
 186                                                                                                                                                  bool includeChanges, bool slotMode)
 187                 {
 188                         return QueryHistory(path, version, deletionId, recursion,
 189                                                                                                         user, versionFrom, versionTo, maxCount,
 190                                                                                                         includeChanges, slotMode, false);
 191                 }
 192
 193                 public IEnumerable QueryHistory (string path, VersionSpec version,
 194                                                                                                                                                  int deletionId, RecursionType recursion,
 195                                                                                                                                                  string user, VersionSpec versionFrom,
 196                                                                                                                                                  VersionSpec versionTo, int maxCount,
 197                                                                                                                                                  bool includeChanges, bool slotMode,
 198                                                                                                                                                  bool includeDownloadInfo)
 199                 {
 200                         ItemSpec itemSpec = new ItemSpec(path, recursion, deletionId);
 201
 202                         string workspaceName = String.Empty;
 203                         string workspaceOwner = String.Empty;
 204
 205                         if (!VersionControlPath.IsServerItem(itemSpec.Item))
 206                                 {
 207                                         WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(itemSpec.Item);
 208                                         if (info != null)
 209                                                 {
 210                                                         workspaceName = info.Name;
 211                                                         workspaceOwner = info.OwnerName;
 212                                                 }
 213                                 }
 214
 215                         return repository.QueryHistory(workspaceName, workspaceOwner,
 216                                                                                                                                                  itemSpec, version,
 217                                                                                                                                                  user, versionFrom, versionTo, maxCount,
 218                                                                                                                                                  includeChanges, slotMode, includeDownloadInfo);
 219                 }
 220
 221     public Workspace GetWorkspace(WorkspaceInfo workspaceInfo)
 222     {
 223                         if (workspaceInfo == null)
 224                                 throw new ArgumentNullException("workspaceInfo");
 225
 226                         return new Workspace(this, workspaceInfo.Name, workspaceInfo.OwnerName,
 227                                                                                                          workspaceInfo.Comment, new WorkingFolder[0], workspaceInfo.Computer);
 228                 }
 229
 230                 public VersionControlLabel[] QueryLabels(string labelName, string labelScope,
 231                                                                                                                                                                                  string owner, bool includeItems)
 232                 {
 233                         return repository.QueryLabels(null, null, labelName, labelScope, owner, null,
 234                                                                                                                                                 VersionSpec.Latest, includeItems, false);
 235                 }
 236
 237                 public VersionControlLabel[] QueryLabels(string labelName, string labelScope,
 238                                                                                                                                                                                  string owner, bool includeItems,
 239                                                                                                                                                                                  string filterItem, VersionSpec versionFilterItem)
 240                 {
 241                         return repository.QueryLabels(null, null, labelName, labelScope, owner, filterItem,
 242                                                                                                                                                 versionFilterItem, includeItems, false);
 243                 }
 244
 245                 public VersionControlLabel[] QueryLabels(string labelName, string labelScope,
 246                                                                                                                                                                                  string owner, bool includeItems,
 247                                                                                                                                                                                  string filterItem, VersionSpec versionFilterItem,
 248                                                                                                                                                                                  bool generateDownloadUrls)
 249                 {
 250                         return repository.QueryLabels(null, null, labelName, labelScope, owner, filterItem,
 251                                                                                                                                                 versionFilterItem, includeItems, generateDownloadUrls);
 252                 }
 253
 254                 public ItemSecurity[] GetPermissions(string[] items, RecursionType recursion)
 255                 {
 256                         return GetPermissions(null, items, recursion);
 257                 }
 258
 259                 public ItemSecurity[] GetPermissions(string[] identityNames, string[] items,
 260                                                                                                                                                                  RecursionType recursion)
 261                 {
 262                         return Repository.QueryItemPermissions(identityNames, items, recursion);
 263                 }
 264
 265                 public Workspace[] QueryWorkspaces(string workspaceName, string ownerName,
 266                                                                                                                                                          string computer)
 267                 {
 268                         return repository.QueryWorkspaces(workspaceName, ownerName, computer);
 269                 }
 270
 271                 internal void OnDownloading(GettingEventArgs args)
 272                 {
 273                         if (null != Getting) Getting(this, args);
 274                 }
 275
 276                 internal void OnNonFatalError(Workspace workspace, Failure failure)
 277                 {
 278                         if (null != NonFatalError) NonFatalError(workspace, new ExceptionEventArgs(workspace, failure));
 279                 }
 280
 281                 internal void OnUploading()
 282                 {
 283                         //if (null != Uploading) Uploading(null, null);
 284                 }
 285
 286                 internal void UpdateWorkspaceInfoCache(XmlNode parent, string ownerName,
 287                                                                                                                                                                          string computer)
 288                 {
 289                         Workspace[] workspaces = QueryWorkspaces(null, ownerName, computer);
 290                         InternalServerInfo serverInfo = new InternalServerInfo(Uri.ToString(), ServerGuid, workspaces);
 291                         XmlElement xmlElement = serverInfo.ToXml(parent.OwnerDocument);
 292                         parent.AppendChild(xmlElement);
 293                 }
 294
 295                 public string AuthenticatedUser
 296                 {
 297                         get { return authenticatedUser; }
 298                 }
 299
 300                 public Guid ServerGuid
 301                 {
 302                         get { return new Guid(); }
 303                 }
 304
 305                 internal Repository Repository
 306                 {
 307                         get { return repository; }
 308                 }
 309
 310                 internal Uri Uri
 311                 {
 312                         get { return uri; }
 313                 }
 314         }
 315
 316 }