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

   1 //
   2 // Microsoft.TeamFoundation.VersionControl.Client.Repository
   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.IO;
  31 using System.Collections.Generic;
  32 using System.Net;
  33 using System.Reflection;
  34 using System.Text;
  35 using System.Xml;
  36 using System.Xml.Schema;
  37 using System.Web.Services;
  38 using System.Web.Services.Description;
  39 using System.Web.Services.Discovery;
  40 using System.Web.Services.Protocols;
  41 using Microsoft.TeamFoundation.VersionControl.Common;
  42
  43 namespace Microsoft.TeamFoundation.VersionControl.Client
  44 {
  45         [System.Web.Services.WebServiceBinding(Name="RepositorySoap", Namespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03")]
  46         [System.Diagnostics.DebuggerStepThroughAttribute()]
  47         [System.ComponentModel.DesignerCategoryAttribute("code")]
  48         [System.Xml.Serialization.XmlIncludeAttribute(typeof(SecurityChange))]
  49         internal class Repository : System.Web.Services.Protocols.SoapHttpClientProtocol {
  50
  51                 private VersionControlServer versionControlServer;
  52                 private string itemUrl;
  53                 private string uploadUrl;
  54
  55                 public Repository(VersionControlServer versionControlServer,
  56                                                                                         Uri url, ICredentials credentials)
  57                         {
  58                                 this.versionControlServer = versionControlServer;
  59                                 this.Url = String.Format("{0}/{1}", url, "VersionControl/v1.0/Repository.asmx");
  60                                 this.itemUrl = String.Format("{0}/{1}", url, RepositoryConstants.DownloadUrlSuffix);
  61                                 this.uploadUrl = String.Format("{0}/{1}", url, RepositoryConstants.UploadUrlSuffix);
  62                                 this.Credentials = credentials;
  63                         }
  64
  65                 public void UploadFile(string workspaceName, string ownerName, PendingChange change)
  66                 {
  67                         FileInfo fi = new FileInfo(change.LocalItem);
  68                         long len = fi.Length;
  69
  70                         UploadFile upload = new UploadFile(uploadUrl, Credentials);
  71                         upload.AddValue(RepositoryConstants.ServerItemField, change.ServerItem);
  72                         upload.AddValue(RepositoryConstants.WorkspaceNameField, workspaceName);
  73                         upload.AddValue(RepositoryConstants.WorkspaceOwnerField, ownerName);
  74                         upload.AddValue(RepositoryConstants.LengthField, len.ToString());
  75                         upload.AddValue(RepositoryConstants.HashField, Convert.ToBase64String(change.UploadHashValue));
  76
  77                         // send byte range
  78                         // TODO: handle files to large to fit in a single POST
  79                         upload.AddValue(RepositoryConstants.RangeField,
  80                                                                                         String.Format("bytes=0-{0}/{1}", len-1, len));
  81
  82                         upload.AddFile(change.LocalItem);
  83
  84                         WebResponse response;
  85
  86                         try
  87                                 {
  88                                         response = upload.Send();
  89                                 }
  90                         catch (WebException ex)
  91                                 {
  92                                         response = ex.Response;
  93                                         HttpWebResponse http_response = response as HttpWebResponse;
  94                                         if (http_response == null || http_response.StatusCode != HttpStatusCode.InternalServerError)
  95                                                 throw ex;
  96                                 }
  97
  98                         // Get the stream associated with the response.
  99                         //Stream receiveStream = response.GetResponseStream ();
 100                         //StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
 101                         //Console.WriteLine (readStream.ReadToEnd ());
 102
 103                         response.Close();
 104                         //readStream.Close();
 105                 }
 106
 107                 protected HttpWebResponse Invoke (Message message)
 108                 {
 109                         message.End();
 110                         HttpWebResponse response = GetWebResponse(message.Request) as HttpWebResponse;
 111
 112                         if (response == null)
 113                                 {
 114                                         throw new TeamFoundationServerException("No response from server");
 115                                 }
 116
 117                         if (response.StatusCode == HttpStatusCode.Unauthorized)
 118                                 {
 119                                         string msg = String.Format("TF30063: You are not authorized to access {0} ({1}).\n--> Did you supply the correct username, password, and domain?",
 120                                                                                                                                                  (new Uri(this.Url)).Host, message.MethodName);
 121
 122                                         //StreamReader readStream = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
 123                                         //                                      Console.Error.WriteLine (readStream.ReadToEnd ());
 124                                         //readStream.Close();
 125
 126                                         throw new TeamFoundationServerException(msg);
 127                                 }
 128
 129                         if (response.StatusCode == HttpStatusCode.InternalServerError)
 130                                 {
 131                                         throw new VersionControlException(GetExceptionMessage(response));
 132                                 }
 133
 134                         return response;
 135                 }
 136
 137                 public string GetExceptionMessage(HttpWebResponse response)
 138                 {
 139                         StreamReader sr = new StreamReader(response.GetResponseStream(), new UTF8Encoding (false), false);
 140                         XmlReader reader = new XmlTextReader(sr);
 141                         string msg = String.Empty;
 142                         while (reader.Read())
 143                                 {
 144                                         if (reader.NodeType == XmlNodeType.Element && reader.Name == "faultstring")
 145                                                 {
 146                                                         msg = reader.ReadElementContentAsString();
 147                                                         break;
 148                                                 }
 149                                 }
 150
 151                         response.Close();
 152                         return msg;
 153                 }
 154
 155                 public int CheckIn(Workspace workspace, string[] serverItems, string comment)
 156                 {
 157                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CheckIn");
 158
 159                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 160                         msg.Body.WriteElementString("ownerName", workspace.OwnerName);
 161
 162                         msg.Body.WriteStartElement("serverItems");
 163                         foreach (string serverItem in serverItems)
 164                                 {
 165                                         msg.Body.WriteElementString("string", serverItem);
 166                                 }
 167                         msg.Body.WriteEndElement();
 168
 169                         // write info subtree
 170                         msg.Body.WriteStartElement("info");
 171                         msg.Body.WriteAttributeString("date", DateTime.Now.ToString("s"));
 172                         msg.Body.WriteAttributeString("cset", "0");
 173                         msg.Body.WriteAttributeString("owner", workspace.OwnerName);
 174                         msg.Body.WriteElementString("Comment", comment);
 175                         msg.Body.WriteElementString("CheckinNote", "");
 176                         msg.Body.WriteElementString("PolicyOverride", "");
 177                         msg.Body.WriteElementString("CheckinOptions", "ValidateCheckinOwner");
 178                         msg.Body.WriteEndElement();
 179
 180                         int cset = 0;
 181                         using (HttpWebResponse response = Invoke(msg))
 182                                 {
 183                                         XmlReader results = msg.ResponseReader(response);
 184                                         cset = Convert.ToInt32(results.GetAttribute("cset"));
 185
 186                                         List<Failure> failures = new List<Failure>();
 187
 188                                         //TODO: read <UndoneServerItems /> and <ImplicitItems />
 189                                         //<CheckInResponse xmlns="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03"><CheckInResult cset="11486"><UndoneServerItems /><ImplicitItems /></CheckInResult><failures /></CheckInResponse>
 190                                         while (results.Read())
 191                                                 {
 192                                                         if (results.NodeType == XmlNodeType.Element)
 193                                                                 {
 194                                                                         switch (results.Name)
 195                                                                                 {
 196                                                                                 case "Failure":
 197                                                                                         failures.Add(Failure.FromXml(this, results));
 198                                                                                         break;
 199                                                                                 }
 200                                                                 }
 201                                                 }
 202
 203                                         foreach (Failure failure in failures)
 204                                                 {
 205                                                         versionControlServer.OnNonFatalError(workspace, failure);
 206                                                 }
 207                                 }
 208
 209                         return cset;
 210                 }
 211
 212                 public void CreateTeamProjectFolder(TeamProjectFolderOptions teamProjectOptions)
 213                 {
 214                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CreateTeamProjectFolder");
 215                         teamProjectOptions.ToXml(msg.Body, "");
 216                         HttpWebResponse response = Invoke(msg);
 217                         response.Close();
 218                 }
 219
 220                 public Workspace CreateWorkspace(Workspace workspace)
 221                 {
 222                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CreateWorkspace");
 223                         workspace.ToXml(msg.Body, "workspace");
 224
 225                         Workspace newWorkspace;
 226                         using (HttpWebResponse response = Invoke(msg))
 227                                 {
 228                                         XmlReader results = msg.ResponseReader(response);
 229                                         newWorkspace = Workspace.FromXml(this, results);
 230                                 }
 231
 232                         return newWorkspace;
 233                 }
 234
 235                 [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03/DeleteWorkspace", RequestNamespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03", ResponseNamespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03", ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped, Use=System.Web.Services.Description.SoapBindingUse.Literal)]
 236                         public void DeleteWorkspace(string workspaceName, string ownerName)
 237                         {
 238                                 this.Invoke("DeleteWorkspace", new object[] { workspaceName, ownerName});
 239                         }
 240
 241                 public LabelResult[] LabelItem(Workspace workspace, VersionControlLabel label,
 242                                                                                                                                          LabelItemSpec[] labelSpecs, LabelChildOption children)
 243                 {
 244                         Message msg = new Message(GetWebRequest (new Uri(Url)), "LabelItem");
 245
 246                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 247                         msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName);
 248                         label.ToXml(msg.Body, "label");
 249
 250                         msg.Body.WriteStartElement("labelSpecs");
 251                         foreach (LabelItemSpec labelSpec in labelSpecs)
 252                                 {
 253                                         labelSpec.ToXml(msg.Body, "LabelItemSpec");
 254                                 }
 255                         msg.Body.WriteEndElement();
 256
 257                         msg.Body.WriteElementString("children", children.ToString());
 258
 259                         List<LabelResult> labelResults = new List<LabelResult>();
 260                         List<Failure> faillist = new List<Failure>();
 261
 262                         using (HttpWebResponse response = Invoke(msg))
 263                                 {
 264                                         XmlReader results = msg.ResponseReader(response);
 265
 266                                         while (results.Read())
 267                                                 {
 268                                                         if (results.NodeType == XmlNodeType.Element)
 269                                                                 {
 270                                                                         switch (results.Name)
 271                                                                                 {
 272                                                                                 case "LabelResult":
 273                                                                                         labelResults.Add(LabelResult.FromXml(this, results));
 274                                                                                         break;
 275                                                                                 case "Failure":
 276                                                                                         faillist.Add(Failure.FromXml(this, results));
 277                                                                                         break;
 278                                                                                 }
 279                                                                 }
 280                                                 }
 281                                 }
 282
 283                         foreach (Failure failure in faillist)
 284                                 {
 285                                         versionControlServer.OnNonFatalError(workspace, failure);
 286                                 }
 287
 288                         return labelResults.ToArray();
 289                 }
 290
 291                 public GetOperation[] Get(string workspaceName, string ownerName,
 292                                                                                                                         GetRequest[] requests, bool force, bool noGet) {
 293
 294                         Message msg = new Message(GetWebRequest (new Uri(Url)), "Get");
 295                         msg.Body.WriteElementString("workspaceName", workspaceName);
 296                         msg.Body.WriteElementString("ownerName", ownerName);
 297
 298                         msg.Body.WriteStartElement("requests");
 299                         foreach (GetRequest request in requests)
 300                                 {
 301                                         request.ToXml(msg.Body, "");
 302                                 }
 303                         msg.Body.WriteEndElement();
 304
 305                         msg.Body.WriteElementString("force", force.ToString().ToLower());
 306                         msg.Body.WriteElementString("noGet", noGet.ToString().ToLower());
 307
 308                         List<GetOperation> operations = new List<GetOperation>();
 309                         using (HttpWebResponse response = Invoke(msg))
 310                                 {
 311                                         XmlReader results = msg.ResponseReader(response);
 312
 313                                         while (results.Read())
 314                                                 {
 315                                                         if (results.NodeType == XmlNodeType.Element &&
 316                                                                         results.Name == "GetOperation")
 317                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 318                                                 }
 319                                 }
 320
 321                         return operations.ToArray();
 322                 }
 323
 324                 public RepositoryProperties GetRepositoryProperties()
 325                 {
 326                         Message msg = new Message(GetWebRequest (new Uri(Url)), "GetRepositoryProperties");
 327                         RepositoryProperties properties;
 328                         using (HttpWebResponse response = Invoke(msg))
 329                                 {
 330                                         XmlReader results = msg.ResponseReader(response);
 331                                         properties = RepositoryProperties.FromXml(this, results);
 332                                 }
 333
 334                         return properties;
 335                 }
 336
 337                 public GetOperation[] PendChanges(Workspace workspace, ChangeRequest[] changes)
 338                 {
 339                         Message msg = new Message(GetWebRequest (new Uri(Url)), "PendChanges");
 340
 341                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 342                         msg.Body.WriteElementString("ownerName", workspace.OwnerName);
 343                         msg.Body.WriteStartElement("changes");
 344                         foreach (ChangeRequest change in changes)
 345                                 {
 346                                         change.ToXml(msg.Body, "");
 347                                 }
 348                         msg.Body.WriteEndElement();
 349
 350                         List<GetOperation> operations = new List<GetOperation>();
 351                         List<Failure> faillist = new List<Failure>();
 352
 353                         using (HttpWebResponse response = Invoke(msg))
 354                                 {
 355                                         XmlReader results = msg.ResponseReader(response);
 356
 357                                         while (results.Read())
 358                                                 {
 359                                                         if (results.NodeType == XmlNodeType.Element)
 360                                                                 {
 361                                                                         switch (results.Name)
 362                                                                                 {
 363                                                                                 case "GetOperation":
 364                                                                                         operations.Add(GetOperation.FromXml(ItemUrl, results));
 365                                                                                         break;
 366                                                                                 case "Failure":
 367                                                                                         faillist.Add(Failure.FromXml(this, results));
 368                                                                                         break;
 369                                                                                 }
 370                                                                 }
 371                                                 }
 372                                 }
 373
 374                         foreach (Failure failure in faillist)
 375                                 {
 376                                         versionControlServer.OnNonFatalError(workspace, failure);
 377                                 }
 378
 379                         return operations.ToArray();
 380                 }
 381
 382                 public Annotation[] QueryAnnotation(string annotationName, string annotatedItem, int version)
 383                 {
 384                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryAnnotation");
 385
 386                         msg.Body.WriteElementString("annotationName", annotationName);
 387                         msg.Body.WriteElementString("annotatedItem", annotatedItem);
 388                         msg.Body.WriteElementString("version", Convert.ToString(version));
 389
 390                         List<Annotation> labels = new List<Annotation>();
 391                         using (HttpWebResponse response = Invoke(msg))
 392                                 {
 393                                         XmlReader results = msg.ResponseReader(response);
 394
 395                                         while (results.Read())
 396                                                 {
 397                                                         if (results.NodeType == XmlNodeType.Element &&
 398                                                                         results.Name == "Annotation")
 399                                                                 labels.Add(Annotation.FromXml(this, results));
 400                                                 }
 401                                 }
 402
 403                         return labels.ToArray();
 404                 }
 405
 406                 public Changeset QueryChangeset(int changesetId, bool includeChanges,
 407                                                                                                                                                 bool generateDownloadUrls)
 408                 {
 409                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryChangeset");
 410
 411                         msg.Body.WriteElementString("changesetId", Convert.ToString(changesetId));
 412                         msg.Body.WriteElementString("includeChanges", Convert.ToString(includeChanges).ToLower());
 413                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 414
 415                         Changeset changeset = null;
 416
 417                         using (HttpWebResponse response = Invoke(msg))
 418                                 {
 419                                         XmlReader results = msg.ResponseReader(response);
 420                                         changeset = Changeset.FromXml(this, results);
 421                                 }
 422
 423                         return changeset;
 424                 }
 425
 426                 public Changeset[] QueryHistory (string workspaceName, string workspaceOwner,
 427                                                                                                                                                  ItemSpec itemSpec, VersionSpec version,
 428                                                                                                                                                  string user, VersionSpec versionFrom,
 429                                                                                                                                                  VersionSpec versionTo, int maxCount,
 430                                                                                                                                                  bool includeFiles, bool slotMode,
 431                                                                                                                                                  bool generateDownloadUrls)
 432                 {
 433                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryHistory");
 434
 435                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 436                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 437
 438                         itemSpec.ToXml(msg.Body, "itemSpec");
 439                         if (version != null) version.ToXml(msg.Body, "versionItem");
 440                         if (versionFrom != null) versionFrom.ToXml(msg.Body, "versionFrom");
 441                         if (versionTo != null) versionTo.ToXml(msg.Body, "versionTo");
 442
 443                         if (!String.IsNullOrEmpty(user)) msg.Body.WriteElementString("user", user);
 444                         msg.Body.WriteElementString("maxCount", Convert.ToString(maxCount));
 445                         msg.Body.WriteElementString("includeFiles", Convert.ToString(includeFiles).ToLower());
 446                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 447                         msg.Body.WriteElementString("slotMode", Convert.ToString(slotMode).ToLower());
 448
 449                         List<Changeset> changes = new List<Changeset>();
 450                         using (HttpWebResponse response = Invoke(msg))
 451                                 {
 452                                         XmlReader results = msg.ResponseReader(response);
 453
 454                                         while (results.Read())
 455                                                 {
 456                                                         if (results.NodeType == XmlNodeType.Element &&
 457                                                                         results.Name == "Changeset")
 458                                                                 changes.Add(Changeset.FromXml(this, results));
 459                                                 }
 460                                 }
 461
 462                         return changes.ToArray();
 463                 }
 464
 465                 public ItemSet QueryItems(string workspaceName, string workspaceOwner,
 466                                                                                                                         ItemSpec itemSpec, VersionSpec versionSpec,
 467                                                                                                                         DeletedState deletedState, ItemType itemType,
 468                                                                                                                         bool generateDownloadUrls)
 469                 {
 470                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItems");
 471
 472                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 473                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 474                         msg.Body.WriteStartElement("items");
 475                         itemSpec.ToXml(msg.Body, "ItemSpec");
 476                         msg.Body.WriteEndElement();
 477
 478                         versionSpec.ToXml(msg.Body, "version");
 479
 480                         msg.Body.WriteElementString("deletedState",
 481                                                                                                                                         deletedState.ToString());
 482                         msg.Body.WriteElementString("itemType",
 483                                                                                                                                         itemType.ToString());
 484                         msg.Body.WriteElementString("generateDownloadUrls",
 485                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 486
 487                         ItemSet itemSet;
 488                         using (HttpWebResponse response = Invoke(msg))
 489                                 {
 490                                         XmlReader results = msg.ResponseReader(response);
 491                                         itemSet = ItemSet.FromXml(this, results);
 492                                 }
 493
 494                         return itemSet;
 495                 }
 496
 497                 public ExtendedItem[][] QueryItemsExtended(string workspaceName, string workspaceOwner,
 498                                                                                                                                                                                          ItemSpec[] itemSpecs,
 499                                                                                                                                                                                          DeletedState deletedState, ItemType itemType)
 500                 {
 501                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsExtended");
 502
 503                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 504                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 505
 506                         msg.Body.WriteStartElement("items");
 507                         foreach (ItemSpec itemSpec in itemSpecs)
 508                                 {
 509                                         itemSpec.ToXml(msg.Body, "ItemSpec");
 510                                 }
 511                         msg.Body.WriteEndElement();
 512
 513                         msg.Body.WriteElementString("deletedState",
 514                                                                                                                                         deletedState.ToString());
 515                         msg.Body.WriteElementString("itemType",
 516                                                                                                                                         itemType.ToString());
 517
 518                         List< ExtendedItem[] > listOfItemArrays = new List<ExtendedItem[] >();
 519                         using (HttpWebResponse response = Invoke(msg))
 520                                 {
 521                                         XmlReader results = msg.ResponseReader(response);
 522                                         while (results.Read())
 523                                                 {
 524                                                         //                                                      Console.WriteLine(results.Name + ":" + results.NodeType);
 525                                                         if (results.NodeType == XmlNodeType.Element &&
 526                                                                         results.Name == "ArrayOfExtendedItem")
 527                                                                 {
 528                                                                         List<ExtendedItem> items = new List<ExtendedItem>();
 529                                                                         while (results.Read())
 530                                                                                 {
 531                                                                                         //Console.WriteLine("    " + results.Name + ":" + results.NodeType);
 532                                                                                         if (results.NodeType == XmlNodeType.EndElement &&
 533                                                                                                         results.Name == "ArrayOfExtendedItem") break;
 534                                                                                         if (results.NodeType == XmlNodeType.Element &&
 535                                                                                                         results.Name == "ExtendedItem")
 536                                                                                                 items.Add(ExtendedItem.FromXml(this, results));
 537                                                                                 }
 538                                                                         listOfItemArrays.Add(items.ToArray());
 539                                                                 }
 540                                                 }
 541                                 }
 542
 543                         return listOfItemArrays.ToArray();
 544                 }
 545
 546                 public VersionControlLabel[] QueryLabels(string workspaceName, string workspaceOwner,
 547                                                                                                                                                                                  string labelName, string labelScope,
 548                                                                                                                                                                                  string owner, string filterItem,
 549                                                                                                                                                                                  VersionSpec versionFilterItem,
 550                                                                                                                                                                                  bool includeItems, bool generateDownloadUrls)
 551                 {
 552                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryLabels");
 553
 554                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 555                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 556                         if (!String.IsNullOrEmpty(labelName)) msg.Body.WriteElementString("labelName", labelName);
 557                         if (!String.IsNullOrEmpty(labelScope)) msg.Body.WriteElementString("labelScope", labelScope);
 558                         if (!String.IsNullOrEmpty(owner)) msg.Body.WriteElementString("owner", owner);
 559                         if (!String.IsNullOrEmpty(filterItem)) msg.Body.WriteElementString("filterItem", filterItem);
 560
 561                         if (null != versionFilterItem) versionFilterItem.ToXml(msg.Body, "versionFilterItem");
 562                         msg.Body.WriteElementString("includeItems", includeItems.ToString().ToLower());
 563                         msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower());
 564
 565                         List<VersionControlLabel> labels = new List<VersionControlLabel>();
 566                         using (HttpWebResponse response = Invoke(msg))
 567                                 {
 568                                         XmlReader results = msg.ResponseReader(response);
 569
 570                                         while (results.Read())
 571                                                 {
 572                                                         if (results.NodeType == XmlNodeType.Element &&
 573                                                                         results.Name == "VersionControlLabel")
 574                                                                 labels.Add(VersionControlLabel.FromXml(this, results));
 575                                                 }
 576                                 }
 577
 578                         return labels.ToArray();
 579                 }
 580
 581                 public Item[] QueryItemsById(int[] ids, int changeSet,
 582                                                                                                                                  bool generateDownloadUrls)
 583                 {
 584                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsById");
 585
 586                         msg.Body.WriteStartElement("itemIds");
 587                         foreach (int id in ids)
 588                                 {
 589                                         msg.Body.WriteElementString("int", Convert.ToString(id));
 590                                 }
 591                         msg.Body.WriteEndElement();
 592
 593                         msg.Body.WriteElementString("changeSet", Convert.ToString(changeSet));
 594                         msg.Body.WriteElementString("generateDownloadUrls",
 595                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 596
 597                         List<Item> items = new List<Item>();
 598                         using (HttpWebResponse response = Invoke(msg))
 599                                 {
 600                                         XmlReader results = msg.ResponseReader(response);
 601
 602                                         while (results.Read())
 603                                                 {
 604                                                         if (results.NodeType == XmlNodeType.Element &&
 605                                                                         results.Name == "Item")
 606                                                                 items.Add(Item.FromXml(this, results));
 607                                                 }
 608                                 }
 609
 610                         return items.ToArray();
 611                 }
 612
 613                 public ItemSecurity[] QueryItemPermissions(string[] identityNames, string[] items,
 614                                                                                                                                                                                          RecursionType recursion)
 615                 {
 616                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemPermissions");
 617
 618                         msg.Body.WriteStartElement("itemSpecs");
 619                         foreach (string item in items)
 620                                 {
 621                                         ItemSpec spec = new ItemSpec(item, recursion);
 622                                         spec.ToXml(msg.Body, "ItemSpec");
 623                                 }
 624                         msg.Body.WriteEndElement();
 625
 626                         List<ItemSecurity> itemSecurities = new List<ItemSecurity>();
 627                         using (HttpWebResponse response = Invoke(msg))
 628                                 {
 629                                         XmlReader results = msg.ResponseReader(response);
 630
 631                                         while (results.Read())
 632                                                 {
 633                                                         if (results.NodeType == XmlNodeType.Element &&
 634                                                                         results.Name == "ItemSecurity")
 635                                                                 itemSecurities.Add(ItemSecurity.FromXml(this, results));
 636                                                 }
 637                                 }
 638
 639                         return itemSecurities.ToArray();
 640                 }
 641
 642                 public PendingChange[] QueryPendingSets(string localWorkspaceName, string localWorkspaceOwner,
 643                                                                                                                                                                                 string queryWorkspaceName, string ownerName,
 644                                                                                                                                                                                 ItemSpec[] itemSpecs, bool generateDownloadUrls,
 645                                                                                                                                                                                 out Failure[] failures)
 646                 {
 647                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryPendingSets");
 648                         msg.Body.WriteElementString("localWorkspaceName", localWorkspaceName);
 649                         msg.Body.WriteElementString("localWorkspaceOwner", localWorkspaceOwner);
 650                         msg.Body.WriteElementString("queryWorkspaceName", queryWorkspaceName);
 651                         msg.Body.WriteElementString("ownerName", ownerName);
 652
 653                         msg.Body.WriteStartElement("itemSpecs");
 654                         foreach (ItemSpec item in itemSpecs)
 655                                 {
 656                                         item.ToXml(msg.Body, "ItemSpec");
 657                                 }
 658                         msg.Body.WriteEndElement();
 659
 660                         msg.Body.WriteElementString("generateDownloadUrls",
 661                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 662
 663                         List<PendingChange> changes = new List<PendingChange>();
 664                         List<Failure> faillist = new List<Failure>();
 665
 666                         using (HttpWebResponse response = Invoke(msg))
 667                                 {
 668                                         XmlReader results = msg.ResponseReader(response);
 669
 670                                         while (results.Read())
 671                                                 {
 672                                                         if (results.NodeType == XmlNodeType.Element)
 673                                                                 {
 674                                                                         switch (results.Name)
 675                                                                                 {
 676                                                                                 case "PendingChange":
 677                                                                                         changes.Add(PendingChange.FromXml(this, results));
 678                                                                                         break;
 679                                                                                 case "Failure":
 680                                                                                         faillist.Add(Failure.FromXml(this, results));
 681                                                                                         break;
 682                                                                                 }
 683                                                                 }
 684                                                 }
 685                                 }
 686
 687                         failures = faillist.ToArray();
 688                         return changes.ToArray();
 689                 }
 690
 691                 public Workspace QueryWorkspace(string workspaceName, string ownerName)
 692                 {
 693                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspace");
 694                         msg.Body.WriteElementString("workspaceName", workspaceName);
 695                         msg.Body.WriteElementString("ownerName", ownerName);
 696
 697                         Workspace workspace;
 698                         using (HttpWebResponse response = Invoke(msg))
 699                                 {
 700                                         XmlReader results = msg.ResponseReader(response);
 701                                         workspace = Workspace.FromXml(this, results);
 702                                 }
 703
 704                         return workspace;
 705                 }
 706
 707                 public Workspace[] QueryWorkspaces(string workspaceName, string ownerName,
 708                                                                                                                                                          string computer)
 709                 {
 710                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspaces");
 711                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 712                         if (!String.IsNullOrEmpty(ownerName)) msg.Body.WriteElementString("ownerName", ownerName);
 713                         if (!String.IsNullOrEmpty(computer)) msg.Body.WriteElementString("computer", computer);
 714
 715                         List<Workspace> workspaces = new List<Workspace>();
 716                         using (HttpWebResponse response = Invoke(msg))
 717                                 {
 718                                         XmlReader results = msg.ResponseReader(response);
 719
 720                                         while (results.Read())
 721                                                 {
 722                                                         if (results.NodeType == XmlNodeType.Element &&
 723                                                                         results.Name == "Workspace")
 724                                                                 workspaces.Add(Workspace.FromXml(this, results));
 725                                                 }
 726                                 }
 727
 728                         workspaces.Sort();
 729                         return workspaces.ToArray();
 730                 }
 731
 732                 //              <?xml version=_T("1.0") encoding=_T("utf-8")?><soap:Envelope xmlns:xsi=_T("http://www.w3.org/2001/XMLSchema-instance") xmlns=_T("http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03") xmlns:soap=_T("http://www.w3.org/2003/05/soap-envelope")><soap:Body><UpdateWorkspace><oldWorkspaceName>neo</oldWorkspaceName><ownerName>DDI\JREED</ownerName><newWorkspace computer=_T("neo") name=_T("neo") owner=_T("DDI\JREED")><Comment /><LastAccessDate>0001-01-01T00:00:00</LastAccessDate><Folders><WorkingFolder local=_T("C:\MSOCache") item=_T("$/LSG-1.0") /></Folders></newWorkspace></UpdateWorkspace></soap:Body></soap:Envelope
 733                 public Workspace UpdateWorkspace(string oldWorkspaceName, string ownerName,
 734                                                                                                                                                  Workspace newWorkspace)
 735                 {
 736                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateWorkspace");
 737                         msg.Body.WriteElementString("oldWorkspaceName", oldWorkspaceName);
 738                         msg.Body.WriteElementString("ownerName", ownerName);
 739                         newWorkspace.ToXml(msg.Body, "newWorkspace");
 740
 741                         Workspace workspace;
 742                         using (HttpWebResponse response = Invoke(msg))
 743                                 {
 744                                         XmlReader results = msg.ResponseReader(response);
 745                                         workspace = Workspace.FromXml(this, results);
 746                                 }
 747
 748                         return workspace;
 749                 }
 750
 751                 public GetOperation[] UndoPendingChanges(string workspaceName, string ownerName,
 752                                                                                                                                                                                  ItemSpec[] itemSpecs)
 753                 {
 754                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UndoPendingChanges");
 755                         msg.Body.WriteElementString("workspaceName", workspaceName);
 756                         msg.Body.WriteElementString("ownerName", ownerName);
 757
 758                         msg.Body.WriteStartElement("items");
 759                         foreach (ItemSpec item in itemSpecs)
 760                                 {
 761                                         item.ToXml(msg.Body, "ItemSpec");
 762                                 }
 763                         msg.Body.WriteEndElement();
 764
 765                         List<GetOperation> operations = new List<GetOperation>();
 766                         using (HttpWebResponse response = Invoke(msg))
 767                                 {
 768                                         XmlReader results = msg.ResponseReader(response);
 769
 770                                         while (results.Read())
 771                                                 {
 772                                                         if (results.NodeType == XmlNodeType.Element &&
 773                                                                         results.Name == "GetOperation")
 774                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 775                                                 }
 776                                 }
 777
 778                         return operations.ToArray();
 779                 }
 780
 781                 public void UpdateLocalVersion(UpdateLocalVersionQueue queue)
 782                 {
 783                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateLocalVersion");
 784                         queue.ToXml(msg.Body, "UpdateLocalVersion");
 785
 786                         HttpWebResponse response = Invoke(msg);
 787                         response.Close();
 788                 }
 789
 790                 public VersionControlServer VersionControlServer
 791                 {
 792                         get { return versionControlServer; }
 793                 }
 794
 795                 public string ItemUrl
 796                 {
 797                         get { return itemUrl; }
 798                 }
 799
 800         }
 801
 802         class TfsPath
 803         {
 804                 private static bool runningOnUnix = true;
 805
 806                 static TfsPath()
 807                 {
 808                         int p = (int) Environment.OSVersion.Platform;
 809                         if (!((p == 4) || (p == 128))) runningOnUnix = false;
 810                 }
 811
 812                 public static string ToPlatformPath(string path)
 813                 {
 814                         if (String.IsNullOrEmpty(path)) return path;
 815
 816                         // TFS servers corrupt *nix type paths
 817                         if (!runningOnUnix) return path;
 818                         return path.Remove(0, 2).Replace('\\', '/');
 819                 }
 820
 821                 public static string FromPlatformPath(string path)
 822                 {
 823                         if (String.IsNullOrEmpty(path)) return path;
 824
 825                         // TFS servers corrupt *nix type paths
 826                         if (!runningOnUnix) return path;
 827                         return "C:" + path.Replace('/', '\\');
 828                 }
 829         }
 830 }