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 LabelResult[] UnlabelItem(Workspace workspace, string labelName,
 292                                                                                                                                                  string labelScope, ItemSpec[] itemSpecs,
 293                                                                                                                                                  VersionSpec version)
 294                 {
 295                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UnlabelItem");
 296
 297                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 298                         msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName);
 299                         msg.Body.WriteElementString("labelName", labelName);
 300
 301                         if (!String.IsNullOrEmpty(labelScope))
 302                                 msg.Body.WriteElementString("labelScope", labelScope);
 303
 304                         msg.Body.WriteStartElement("items");
 305                         foreach (ItemSpec itemSpec in itemSpecs)
 306                                 {
 307                                         itemSpec.ToXml(msg.Body, "ItemSpec");
 308                                 }
 309                         msg.Body.WriteEndElement();
 310
 311                         version.ToXml(msg.Body, "version");
 312
 313                         List<LabelResult> labelResults = new List<LabelResult>();
 314                         List<Failure> faillist = new List<Failure>();
 315
 316                         using (HttpWebResponse response = Invoke(msg))
 317                                 {
 318                                         XmlReader results = msg.ResponseReader(response);
 319
 320                                         while (results.Read())
 321                                                 {
 322                                                         if (results.NodeType == XmlNodeType.Element)
 323                                                                 {
 324                                                                         switch (results.Name)
 325                                                                                 {
 326                                                                                 case "LabelResult":
 327                                                                                         labelResults.Add(LabelResult.FromXml(this, results));
 328                                                                                         break;
 329                                                                                 case "Failure":
 330                                                                                         faillist.Add(Failure.FromXml(this, results));
 331                                                                                         break;
 332                                                                                 }
 333                                                                 }
 334                                                 }
 335                                 }
 336
 337                         foreach (Failure failure in faillist)
 338                                 {
 339                                         versionControlServer.OnNonFatalError(workspace, failure);
 340                                 }
 341
 342                         return labelResults.ToArray();
 343                 }
 344
 345                 public GetOperation[] Get(string workspaceName, string ownerName,
 346                                                                                                                         GetRequest[] requests, bool force, bool noGet) {
 347
 348                         Message msg = new Message(GetWebRequest (new Uri(Url)), "Get");
 349                         msg.Body.WriteElementString("workspaceName", workspaceName);
 350                         msg.Body.WriteElementString("ownerName", ownerName);
 351
 352                         msg.Body.WriteStartElement("requests");
 353                         foreach (GetRequest request in requests)
 354                                 {
 355                                         request.ToXml(msg.Body, "");
 356                                 }
 357                         msg.Body.WriteEndElement();
 358
 359                         msg.Body.WriteElementString("force", force.ToString().ToLower());
 360                         msg.Body.WriteElementString("noGet", noGet.ToString().ToLower());
 361
 362                         List<GetOperation> operations = new List<GetOperation>();
 363                         using (HttpWebResponse response = Invoke(msg))
 364                                 {
 365                                         XmlReader results = msg.ResponseReader(response);
 366
 367                                         while (results.Read())
 368                                                 {
 369                                                         if (results.NodeType == XmlNodeType.Element &&
 370                                                                         results.Name == "GetOperation")
 371                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 372                                                 }
 373                                 }
 374
 375                         return operations.ToArray();
 376                 }
 377
 378                 public RepositoryProperties GetRepositoryProperties()
 379                 {
 380                         Message msg = new Message(GetWebRequest (new Uri(Url)), "GetRepositoryProperties");
 381                         RepositoryProperties properties;
 382                         using (HttpWebResponse response = Invoke(msg))
 383                                 {
 384                                         XmlReader results = msg.ResponseReader(response);
 385                                         properties = RepositoryProperties.FromXml(this, results);
 386                                 }
 387
 388                         return properties;
 389                 }
 390
 391                 public GetOperation[] PendChanges(Workspace workspace, ChangeRequest[] changes)
 392                 {
 393                         Message msg = new Message(GetWebRequest (new Uri(Url)), "PendChanges");
 394
 395                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 396                         msg.Body.WriteElementString("ownerName", workspace.OwnerName);
 397                         msg.Body.WriteStartElement("changes");
 398                         foreach (ChangeRequest change in changes)
 399                                 {
 400                                         change.ToXml(msg.Body, "");
 401                                 }
 402                         msg.Body.WriteEndElement();
 403
 404                         List<GetOperation> operations = new List<GetOperation>();
 405                         List<Failure> faillist = new List<Failure>();
 406
 407                         using (HttpWebResponse response = Invoke(msg))
 408                                 {
 409                                         XmlReader results = msg.ResponseReader(response);
 410
 411                                         while (results.Read())
 412                                                 {
 413                                                         if (results.NodeType == XmlNodeType.Element)
 414                                                                 {
 415                                                                         switch (results.Name)
 416                                                                                 {
 417                                                                                 case "GetOperation":
 418                                                                                         operations.Add(GetOperation.FromXml(ItemUrl, results));
 419                                                                                         break;
 420                                                                                 case "Failure":
 421                                                                                         faillist.Add(Failure.FromXml(this, results));
 422                                                                                         break;
 423                                                                                 }
 424                                                                 }
 425                                                 }
 426                                 }
 427
 428                         foreach (Failure failure in faillist)
 429                                 {
 430                                         versionControlServer.OnNonFatalError(workspace, failure);
 431                                 }
 432
 433                         return operations.ToArray();
 434                 }
 435
 436                 public Annotation[] QueryAnnotation(string annotationName, string annotatedItem, int version)
 437                 {
 438                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryAnnotation");
 439
 440                         msg.Body.WriteElementString("annotationName", annotationName);
 441                         msg.Body.WriteElementString("annotatedItem", annotatedItem);
 442                         msg.Body.WriteElementString("version", Convert.ToString(version));
 443
 444                         List<Annotation> labels = new List<Annotation>();
 445                         using (HttpWebResponse response = Invoke(msg))
 446                                 {
 447                                         XmlReader results = msg.ResponseReader(response);
 448
 449                                         while (results.Read())
 450                                                 {
 451                                                         if (results.NodeType == XmlNodeType.Element &&
 452                                                                         results.Name == "Annotation")
 453                                                                 labels.Add(Annotation.FromXml(this, results));
 454                                                 }
 455                                 }
 456
 457                         return labels.ToArray();
 458                 }
 459
 460                 public Changeset QueryChangeset(int changesetId, bool includeChanges,
 461                                                                                                                                                 bool generateDownloadUrls)
 462                 {
 463                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryChangeset");
 464
 465                         msg.Body.WriteElementString("changesetId", Convert.ToString(changesetId));
 466                         msg.Body.WriteElementString("includeChanges", Convert.ToString(includeChanges).ToLower());
 467                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 468
 469                         Changeset changeset = null;
 470
 471                         using (HttpWebResponse response = Invoke(msg))
 472                                 {
 473                                         XmlReader results = msg.ResponseReader(response);
 474                                         changeset = Changeset.FromXml(this, results);
 475                                 }
 476
 477                         return changeset;
 478                 }
 479
 480                 public Changeset[] QueryHistory (string workspaceName, string workspaceOwner,
 481                                                                                                                                                  ItemSpec itemSpec, VersionSpec version,
 482                                                                                                                                                  string user, VersionSpec versionFrom,
 483                                                                                                                                                  VersionSpec versionTo, int maxCount,
 484                                                                                                                                                  bool includeFiles, bool slotMode,
 485                                                                                                                                                  bool generateDownloadUrls)
 486                 {
 487                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryHistory");
 488
 489                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 490                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 491
 492                         itemSpec.ToXml(msg.Body, "itemSpec");
 493                         if (version != null) version.ToXml(msg.Body, "versionItem");
 494                         if (versionFrom != null) versionFrom.ToXml(msg.Body, "versionFrom");
 495                         if (versionTo != null) versionTo.ToXml(msg.Body, "versionTo");
 496
 497                         if (!String.IsNullOrEmpty(user)) msg.Body.WriteElementString("user", user);
 498                         msg.Body.WriteElementString("maxCount", Convert.ToString(maxCount));
 499                         msg.Body.WriteElementString("includeFiles", Convert.ToString(includeFiles).ToLower());
 500                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 501                         msg.Body.WriteElementString("slotMode", Convert.ToString(slotMode).ToLower());
 502
 503                         List<Changeset> changes = new List<Changeset>();
 504                         using (HttpWebResponse response = Invoke(msg))
 505                                 {
 506                                         XmlReader results = msg.ResponseReader(response);
 507
 508                                         while (results.Read())
 509                                                 {
 510                                                         if (results.NodeType == XmlNodeType.Element &&
 511                                                                         results.Name == "Changeset")
 512                                                                 changes.Add(Changeset.FromXml(this, results));
 513                                                 }
 514                                 }
 515
 516                         return changes.ToArray();
 517                 }
 518
 519                 public ItemSet QueryItems(string workspaceName, string workspaceOwner,
 520                                                                                                                         ItemSpec[] itemSpecs, VersionSpec versionSpec,
 521                                                                                                                         DeletedState deletedState, ItemType itemType,
 522                                                                                                                         bool generateDownloadUrls)
 523                 {
 524                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItems");
 525
 526                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 527                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 528                         msg.Body.WriteStartElement("items");
 529                         foreach (ItemSpec itemSpec in itemSpecs)
 530                                 itemSpec.ToXml(msg.Body, "ItemSpec");
 531                         msg.Body.WriteEndElement();
 532
 533                         versionSpec.ToXml(msg.Body, "version");
 534
 535                         msg.Body.WriteElementString("deletedState",
 536                                                                                                                                         deletedState.ToString());
 537                         msg.Body.WriteElementString("itemType",
 538                                                                                                                                         itemType.ToString());
 539                         msg.Body.WriteElementString("generateDownloadUrls",
 540                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 541
 542                         ItemSet itemSet;
 543                         using (HttpWebResponse response = Invoke(msg))
 544                                 {
 545                                         XmlReader results = msg.ResponseReader(response);
 546                                         itemSet = ItemSet.FromXml(this, results);
 547                                 }
 548
 549                         return itemSet;
 550                 }
 551
 552                 public ExtendedItem[][] QueryItemsExtended(string workspaceName, string workspaceOwner,
 553                                                                                                                                                                                          ItemSpec[] itemSpecs,
 554                                                                                                                                                                                          DeletedState deletedState, ItemType itemType)
 555                 {
 556                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsExtended");
 557
 558                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 559                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 560
 561                         msg.Body.WriteStartElement("items");
 562                         foreach (ItemSpec itemSpec in itemSpecs)
 563                                 {
 564                                         itemSpec.ToXml(msg.Body, "ItemSpec");
 565                                 }
 566                         msg.Body.WriteEndElement();
 567
 568                         msg.Body.WriteElementString("deletedState",
 569                                                                                                                                         deletedState.ToString());
 570                         msg.Body.WriteElementString("itemType",
 571                                                                                                                                         itemType.ToString());
 572
 573                         List< ExtendedItem[] > listOfItemArrays = new List<ExtendedItem[] >();
 574                         using (HttpWebResponse response = Invoke(msg))
 575                                 {
 576                                         XmlReader results = msg.ResponseReader(response);
 577                                         while (results.Read())
 578                                                 {
 579                                                         //                                                      Console.WriteLine(results.Name + ":" + results.NodeType);
 580                                                         if (results.NodeType == XmlNodeType.Element &&
 581                                                                         results.Name == "ArrayOfExtendedItem")
 582                                                                 {
 583                                                                         List<ExtendedItem> items = new List<ExtendedItem>();
 584                                                                         while (results.Read())
 585                                                                                 {
 586                                                                                         //Console.WriteLine("    " + results.Name + ":" + results.NodeType);
 587                                                                                         if (results.NodeType == XmlNodeType.EndElement &&
 588                                                                                                         results.Name == "ArrayOfExtendedItem") break;
 589                                                                                         if (results.NodeType == XmlNodeType.Element &&
 590                                                                                                         results.Name == "ExtendedItem")
 591                                                                                                 items.Add(ExtendedItem.FromXml(this, results));
 592                                                                                 }
 593                                                                         listOfItemArrays.Add(items.ToArray());
 594                                                                 }
 595                                                 }
 596                                 }
 597
 598                         return listOfItemArrays.ToArray();
 599                 }
 600
 601                 public VersionControlLabel[] QueryLabels(string workspaceName, string workspaceOwner,
 602                                                                                                                                                                                  string labelName, string labelScope,
 603                                                                                                                                                                                  string owner, string filterItem,
 604                                                                                                                                                                                  VersionSpec versionFilterItem,
 605                                                                                                                                                                                  bool includeItems, bool generateDownloadUrls)
 606                 {
 607                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryLabels");
 608
 609                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 610                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 611                         if (!String.IsNullOrEmpty(labelName)) msg.Body.WriteElementString("labelName", labelName);
 612                         if (!String.IsNullOrEmpty(labelScope)) msg.Body.WriteElementString("labelScope", labelScope);
 613                         if (!String.IsNullOrEmpty(owner)) msg.Body.WriteElementString("owner", owner);
 614                         if (!String.IsNullOrEmpty(filterItem)) msg.Body.WriteElementString("filterItem", filterItem);
 615
 616                         if (null != versionFilterItem) versionFilterItem.ToXml(msg.Body, "versionFilterItem");
 617                         msg.Body.WriteElementString("includeItems", includeItems.ToString().ToLower());
 618                         msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower());
 619
 620                         List<VersionControlLabel> labels = new List<VersionControlLabel>();
 621                         using (HttpWebResponse response = Invoke(msg))
 622                                 {
 623                                         XmlReader results = msg.ResponseReader(response);
 624
 625                                         while (results.Read())
 626                                                 {
 627                                                         if (results.NodeType == XmlNodeType.Element &&
 628                                                                         results.Name == "VersionControlLabel")
 629                                                                 labels.Add(VersionControlLabel.FromXml(this, results));
 630                                                 }
 631                                 }
 632
 633                         return labels.ToArray();
 634                 }
 635
 636                 public Item[] QueryItemsById(int[] ids, int changeSet,
 637                                                                                                                                  bool generateDownloadUrls)
 638                 {
 639                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsById");
 640
 641                         msg.Body.WriteStartElement("itemIds");
 642                         foreach (int id in ids)
 643                                 {
 644                                         msg.Body.WriteElementString("int", Convert.ToString(id));
 645                                 }
 646                         msg.Body.WriteEndElement();
 647
 648                         msg.Body.WriteElementString("changeSet", Convert.ToString(changeSet));
 649                         msg.Body.WriteElementString("generateDownloadUrls",
 650                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 651
 652                         List<Item> items = new List<Item>();
 653                         using (HttpWebResponse response = Invoke(msg))
 654                                 {
 655                                         XmlReader results = msg.ResponseReader(response);
 656
 657                                         while (results.Read())
 658                                                 {
 659                                                         if (results.NodeType == XmlNodeType.Element &&
 660                                                                         results.Name == "Item")
 661                                                                 items.Add(Item.FromXml(this, results));
 662                                                 }
 663                                 }
 664
 665                         return items.ToArray();
 666                 }
 667
 668                 public ItemSecurity[] QueryItemPermissions(string[] identityNames, string[] items,
 669                                                                                                                                                                                          RecursionType recursion)
 670                 {
 671                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemPermissions");
 672
 673                         msg.Body.WriteStartElement("itemSpecs");
 674                         foreach (string item in items)
 675                                 {
 676                                         ItemSpec spec = new ItemSpec(item, recursion);
 677                                         spec.ToXml(msg.Body, "ItemSpec");
 678                                 }
 679                         msg.Body.WriteEndElement();
 680
 681                         List<ItemSecurity> itemSecurities = new List<ItemSecurity>();
 682                         using (HttpWebResponse response = Invoke(msg))
 683                                 {
 684                                         XmlReader results = msg.ResponseReader(response);
 685
 686                                         while (results.Read())
 687                                                 {
 688                                                         if (results.NodeType == XmlNodeType.Element &&
 689                                                                         results.Name == "ItemSecurity")
 690                                                                 itemSecurities.Add(ItemSecurity.FromXml(this, results));
 691                                                 }
 692                                 }
 693
 694                         return itemSecurities.ToArray();
 695                 }
 696
 697                 public PendingChange[] QueryPendingSets(string localWorkspaceName, string localWorkspaceOwner,
 698                                                                                                                                                                                 string queryWorkspaceName, string ownerName,
 699                                                                                                                                                                                 ItemSpec[] itemSpecs, bool generateDownloadUrls,
 700                                                                                                                                                                                 out Failure[] failures)
 701                 {
 702                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryPendingSets");
 703                         msg.Body.WriteElementString("localWorkspaceName", localWorkspaceName);
 704                         msg.Body.WriteElementString("localWorkspaceOwner", localWorkspaceOwner);
 705                         msg.Body.WriteElementString("queryWorkspaceName", queryWorkspaceName);
 706                         msg.Body.WriteElementString("ownerName", ownerName);
 707
 708                         msg.Body.WriteStartElement("itemSpecs");
 709                         foreach (ItemSpec item in itemSpecs)
 710                                 {
 711                                         item.ToXml(msg.Body, "ItemSpec");
 712                                 }
 713                         msg.Body.WriteEndElement();
 714
 715                         msg.Body.WriteElementString("generateDownloadUrls",
 716                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 717
 718                         List<PendingChange> changes = new List<PendingChange>();
 719                         List<Failure> faillist = new List<Failure>();
 720
 721                         using (HttpWebResponse response = Invoke(msg))
 722                                 {
 723                                         XmlReader results = msg.ResponseReader(response);
 724
 725                                         while (results.Read())
 726                                                 {
 727                                                         if (results.NodeType == XmlNodeType.Element)
 728                                                                 {
 729                                                                         switch (results.Name)
 730                                                                                 {
 731                                                                                 case "PendingChange":
 732                                                                                         changes.Add(PendingChange.FromXml(this, results));
 733                                                                                         break;
 734                                                                                 case "Failure":
 735                                                                                         faillist.Add(Failure.FromXml(this, results));
 736                                                                                         break;
 737                                                                                 }
 738                                                                 }
 739                                                 }
 740                                 }
 741
 742                         failures = faillist.ToArray();
 743                         return changes.ToArray();
 744                 }
 745
 746                 public Workspace QueryWorkspace(string workspaceName, string ownerName)
 747                 {
 748                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspace");
 749                         msg.Body.WriteElementString("workspaceName", workspaceName);
 750                         msg.Body.WriteElementString("ownerName", ownerName);
 751
 752                         Workspace workspace;
 753                         using (HttpWebResponse response = Invoke(msg))
 754                                 {
 755                                         XmlReader results = msg.ResponseReader(response);
 756                                         workspace = Workspace.FromXml(this, results);
 757                                 }
 758
 759                         return workspace;
 760                 }
 761
 762                 public Workspace[] QueryWorkspaces(string workspaceName, string ownerName,
 763                                                                                                                                                          string computer)
 764                 {
 765                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspaces");
 766                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 767                         if (!String.IsNullOrEmpty(ownerName)) msg.Body.WriteElementString("ownerName", ownerName);
 768                         if (!String.IsNullOrEmpty(computer)) msg.Body.WriteElementString("computer", computer);
 769
 770                         List<Workspace> workspaces = new List<Workspace>();
 771                         using (HttpWebResponse response = Invoke(msg))
 772                                 {
 773                                         XmlReader results = msg.ResponseReader(response);
 774
 775                                         while (results.Read())
 776                                                 {
 777                                                         if (results.NodeType == XmlNodeType.Element &&
 778                                                                         results.Name == "Workspace")
 779                                                                 workspaces.Add(Workspace.FromXml(this, results));
 780                                                 }
 781                                 }
 782
 783                         workspaces.Sort();
 784                         return workspaces.ToArray();
 785                 }
 786
 787                 //              <?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
 788                 public Workspace UpdateWorkspace(string oldWorkspaceName, string ownerName,
 789                                                                                                                                                  Workspace newWorkspace)
 790                 {
 791                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateWorkspace");
 792                         msg.Body.WriteElementString("oldWorkspaceName", oldWorkspaceName);
 793                         msg.Body.WriteElementString("ownerName", ownerName);
 794                         newWorkspace.ToXml(msg.Body, "newWorkspace");
 795
 796                         Workspace workspace;
 797                         using (HttpWebResponse response = Invoke(msg))
 798                                 {
 799                                         XmlReader results = msg.ResponseReader(response);
 800                                         workspace = Workspace.FromXml(this, results);
 801                                 }
 802
 803                         return workspace;
 804                 }
 805
 806                 public GetOperation[] UndoPendingChanges(string workspaceName, string ownerName,
 807                                                                                                                                                                                  ItemSpec[] itemSpecs)
 808                 {
 809                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UndoPendingChanges");
 810                         msg.Body.WriteElementString("workspaceName", workspaceName);
 811                         msg.Body.WriteElementString("ownerName", ownerName);
 812
 813                         msg.Body.WriteStartElement("items");
 814                         foreach (ItemSpec item in itemSpecs)
 815                                 {
 816                                         item.ToXml(msg.Body, "ItemSpec");
 817                                 }
 818                         msg.Body.WriteEndElement();
 819
 820                         List<GetOperation> operations = new List<GetOperation>();
 821                         using (HttpWebResponse response = Invoke(msg))
 822                                 {
 823                                         XmlReader results = msg.ResponseReader(response);
 824
 825                                         while (results.Read())
 826                                                 {
 827                                                         if (results.NodeType == XmlNodeType.Element &&
 828                                                                         results.Name == "GetOperation")
 829                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 830                                                 }
 831                                 }
 832
 833                         return operations.ToArray();
 834                 }
 835
 836                 public void UpdateLocalVersion(UpdateLocalVersionQueue queue)
 837                 {
 838                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateLocalVersion");
 839                         queue.ToXml(msg.Body, "UpdateLocalVersion");
 840
 841                         HttpWebResponse response = Invoke(msg);
 842                         response.Close();
 843                 }
 844
 845                 public VersionControlServer VersionControlServer
 846                 {
 847                         get { return versionControlServer; }
 848                 }
 849
 850                 public string ItemUrl
 851                 {
 852                         get { return itemUrl; }
 853                 }
 854
 855         }
 856
 857         class TfsPath
 858         {
 859                 private static bool runningOnUnix = true;
 860
 861                 static TfsPath()
 862                 {
 863                         int p = (int) Environment.OSVersion.Platform;
 864                         if (!((p == 4) || (p == 128))) runningOnUnix = false;
 865                 }
 866
 867                 public static string ToPlatformPath(string path)
 868                 {
 869                         if (String.IsNullOrEmpty(path)) return path;
 870
 871                         // TFS servers corrupt *nix type paths
 872                         if (!runningOnUnix) return path;
 873                         return path.Remove(0, 2).Replace('\\', '/');
 874                 }
 875
 876                 public static string FromPlatformPath(string path)
 877                 {
 878                         if (String.IsNullOrEmpty(path)) return path;
 879
 880                         // TFS servers corrupt *nix type paths
 881                         if (!runningOnUnix) return path;
 882                         return "C:" + path.Replace('/', '\\');
 883                 }
 884         }
 885 }