public BranchHistoryTreeItem[][] GetBranchHistory(ItemSpec[] itemSpecs, VersionSpec version) { if (itemSpecs.Length == 0) { return(null); } string workspaceName = String.Empty; string workspaceOwner = String.Empty; string item = itemSpecs[0].Item; if (!VersionControlPath.IsServerItem(item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } return(repository.QueryBranches(workspaceName, workspaceOwner, itemSpecs, version)); }
public ChangesetMerge[] QueryMerges(string sourcePath, VersionSpec sourceVersion, string targetPath, VersionSpec targetVersion, VersionSpec versionFrom, VersionSpec versionTo, RecursionType recursion) { string workspaceName = String.Empty; string workspaceOwner = String.Empty; if (!VersionControlPath.IsServerItem(targetPath)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(targetPath); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } ItemSpec sourceItem = null; if (!String.IsNullOrEmpty(sourcePath)) { sourceItem = new ItemSpec(sourcePath, recursion); } ItemSpec targetItem = new ItemSpec(targetPath, recursion); ChangesetMerge[] merges = repository.QueryMerges(workspaceName, workspaceOwner, sourceItem, sourceVersion, targetItem, targetVersion, versionFrom, versionTo, Int32.MaxValue); return(merges); }
public ItemSet[] GetItems(ItemSpec[] itemSpecs, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { if (itemSpecs.Length == 0) { return(null); } string workspaceName = String.Empty; string workspaceOwner = String.Empty; string item = itemSpecs[0].Item; if (!VersionControlPath.IsServerItem(item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } return(repository.QueryItems(workspaceName, workspaceOwner, itemSpecs, versionSpec, deletedState, itemType, includeDownloadInfo)); }
public VersionControlLabel[] QueryLabels(string labelName, string labelScope, string owner, bool includeItems, string filterItem, VersionSpec versionFilterItem) { return(repository.QueryLabels(null, null, labelName, labelScope, owner, filterItem, versionFilterItem, includeItems, false)); }
public DiffItemVersionedFile(Item item, VersionSpec versionSpec) { this.versionControlServer = item.VersionControlServer; this.item = item; this.versionSpec = versionSpec; this.label = item.ServerItem; }
public int QueryHistory(string workspaceName, string workspaceOwner, ItemSpec itemSpec, VersionSpec version, string user, VersionSpec versionFrom, VersionSpec versionTo, int maxCount, bool includeFiles, bool slotMode, bool generateDownloadUrls, ref List <Changeset> changes) { Message msg = new Message(GetWebRequest(new Uri(Url)), "QueryHistory"); if (!String.IsNullOrEmpty(workspaceName)) { msg.Body.WriteElementString("workspaceName", workspaceName); } if (!String.IsNullOrEmpty(workspaceOwner)) { msg.Body.WriteElementString("workspaceOwner", workspaceOwner); } itemSpec.ToXml(msg.Body, "itemSpec"); if (version != null) { version.ToXml(msg.Body, "versionItem"); } if (versionFrom != null) { versionFrom.ToXml(msg.Body, "versionFrom"); } if (versionTo != null) { versionTo.ToXml(msg.Body, "versionTo"); } if (!String.IsNullOrEmpty(user)) { msg.Body.WriteElementString("user", user); } msg.Body.WriteElementString("maxCount", Convert.ToString(maxCount)); msg.Body.WriteElementString("includeFiles", Convert.ToString(includeFiles).ToLower()); msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower()); msg.Body.WriteElementString("slotMode", Convert.ToString(slotMode).ToLower()); int cnt = 0; using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "Changeset") { changes.Add(Changeset.FromXml(this, results)); cnt++; } } } return(cnt); }
public DiffItemVersionedFile(Item item, VersionSpec versionSpec) { this.versionControlServer = item.VersionControlServer; this.item = item; this.versionSpec = versionSpec; this.label = item.ServerItem; }
public List <Changeset> QueryHistory(ItemSpec item, VersionSpec versionItem, VersionSpec versionFrom, VersionSpec versionTo, int maxCount = short.MaxValue) { var invoker = new SoapInvoker(this); var msg = invoker.CreateEnvelope("QueryHistory"); msg.Add(item.ToXml(MessageNs + "itemSpec")); msg.Add(versionItem.ToXml(MessageNs + "versionItem")); if (versionFrom != null) { msg.Add(versionFrom.ToXml(MessageNs + "versionFrom")); } if (versionTo != null) { msg.Add(versionTo.ToXml(MessageNs + "versionTo")); } msg.Add(new XElement(MessageNs + "maxCount", maxCount)); msg.Add(new XElement(MessageNs + "includeFiles", false)); msg.Add(new XElement(MessageNs + "generateDownloadUrls", false)); msg.Add(new XElement(MessageNs + "slotMode", false)); msg.Add(new XElement(MessageNs + "sortAscending", false)); var result = invoker.InvokeResult(); return(result.Elements(MessageNs + "Changeset").Select(Changeset.FromXml).ToList()); }
public BranchHistoryTreeItem[][] QueryBranches(string workspaceName, string workspaceOwner, ItemSpec[] itemSpecs, VersionSpec versionSpec) { Message msg = new Message(GetWebRequest(new Uri(Url)), "QueryBranches"); if (!String.IsNullOrEmpty(workspaceName)) { msg.Body.WriteElementString("workspaceName", workspaceName); } if (!String.IsNullOrEmpty(workspaceOwner)) { msg.Body.WriteElementString("workspaceOwner", workspaceOwner); } msg.Body.WriteStartElement("items"); foreach (ItemSpec itemSpec in itemSpecs) { itemSpec.ToXml(msg.Body, "ItemSpec"); } msg.Body.WriteEndElement(); versionSpec.ToXml(msg.Body, "version"); List <BranchHistoryTreeItem[]> tree = new List <BranchHistoryTreeItem[]>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "ArrayOfBranchRelative") { List <BranchRelative> branches = new List <BranchRelative>(); while (results.Read()) { if (results.NodeType == XmlNodeType.EndElement && results.Name == "ArrayOfBranchRelative") { break; } if (results.NodeType == XmlNodeType.Element && results.Name == "BranchRelative") { branches.Add(BranchRelative.FromXml(this, results)); } } if (branches.Count > 0) { List <BranchHistoryTreeItem> items = new List <BranchHistoryTreeItem>(); items.Add(new BranchHistoryTreeItem(branches.ToArray())); tree.Add(items.ToArray()); } } } } return(tree.ToArray()); }
public ItemSet GetItems(string path, VersionSpec versionSpec, RecursionType recursionType) { ItemSpec itemSpec = new ItemSpec(path, recursionType); return(GetItems(itemSpec, versionSpec, DeletedState.NonDeleted, ItemType.Any, false)); }
public FolderDiffWrapper(string assemblyPath, string srcPath, VersionSpec srcSpec, string targetPath, VersionSpec targetSpec, VersionControlServer server, RecursionType recursion) { _vcControlsAssembly = Assembly.LoadFrom(assemblyPath); //internal FolderDiff(string path1, VersionSpec spec1, string path2, VersionSpec spec2, VersionControlServer server, RecursionType recursion); FolderDiff = AccessPrivateWrapper.FromType(_vcControlsAssembly, FolderDiffTypeName, srcPath, srcSpec, targetPath, targetSpec, server, recursion); SetupTypesFromAssembly(); }
public LabelResult[] UnlabelItem(string labelName, string labelScope, ItemSpec[] itemSpecs, VersionSpec version) { Workspace workspace = GetWorkspace(itemSpecs[0].Item); return(repository.UnlabelItem(workspace, labelName, labelScope, itemSpecs, version)); }
public VersionControlLabel[] QueryLabels(string workspaceName, string workspaceOwner, string labelName, string labelScope, string owner, string filterItem, VersionSpec versionFilterItem, bool includeItems, bool generateDownloadUrls) { Message msg = new Message(GetWebRequest(new Uri(Url)), "QueryLabels"); if (!String.IsNullOrEmpty(workspaceName)) { msg.Body.WriteElementString("workspaceName", workspaceName); } if (!String.IsNullOrEmpty(workspaceOwner)) { msg.Body.WriteElementString("workspaceOwner", workspaceOwner); } if (!String.IsNullOrEmpty(labelName)) { msg.Body.WriteElementString("labelName", labelName); } if (!String.IsNullOrEmpty(labelScope)) { msg.Body.WriteElementString("labelScope", labelScope); } if (!String.IsNullOrEmpty(owner)) { msg.Body.WriteElementString("owner", owner); } if (!String.IsNullOrEmpty(filterItem)) { msg.Body.WriteElementString("filterItem", filterItem); } if (null != versionFilterItem) { versionFilterItem.ToXml(msg.Body, "versionFilterItem"); } msg.Body.WriteElementString("includeItems", includeItems.ToString().ToLower()); msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower()); List <VersionControlLabel> labels = new List <VersionControlLabel>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "VersionControlLabel") { labels.Add(VersionControlLabel.FromXml(this, results)); } } } return(labels.ToArray()); }
public ChangeRequest(string path, RequestType requestType, ItemType itemType, RecursionType recursion, LockLevel lockLevel, VersionSpec version) { this.Item = new ItemSpec(path, recursion); this.RequestType = requestType; this.ItemType = itemType; this.LockLevel = lockLevel; this.VersionSpec = version; }
private ParsedQuery( string serverPath, VersionSpec startVersion, VersionSpec endVersion ) { HasVersions = true; WorkItemIds = new WorkItemIdList(); ServerPath = serverPath; StartVersion = startVersion; EndVersion = endVersion; }
public HistoryProvider(VersionControlServer server, string path, VersionSpec version) { FetchChangesets(server, path, version); for (int i = 0; i < PREFETCH_SIZE && i < this.changesets.Count; i++) { Prefetch(i); } }
public LabelResult[] UnlabelItem(Workspace workspace, string labelName, string labelScope, ItemSpec[] itemSpecs, VersionSpec version) { Message msg = new Message(GetWebRequest(new Uri(Url)), "UnlabelItem"); msg.Body.WriteElementString("workspaceName", workspace.Name); msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName); msg.Body.WriteElementString("labelName", labelName); if (!String.IsNullOrEmpty(labelScope)) { msg.Body.WriteElementString("labelScope", labelScope); } msg.Body.WriteStartElement("items"); foreach (ItemSpec itemSpec in itemSpecs) { itemSpec.ToXml(msg.Body, "ItemSpec"); } msg.Body.WriteEndElement(); version.ToXml(msg.Body, "version"); List <LabelResult> labelResults = new List <LabelResult>(); List <Failure> faillist = new List <Failure>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element) { switch (results.Name) { case "LabelResult": labelResults.Add(LabelResult.FromXml(this, results)); break; case "Failure": faillist.Add(Failure.FromXml(this, results)); break; } } } } foreach (Failure failure in faillist) { versionControlServer.OnNonFatalError(workspace, failure); } return(labelResults.ToArray()); }
public List <Item> QueryItems(Workspace workspace, ItemSpec itemSpec, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { if (workspace == null) { return(QueryItems(itemSpec, versionSpec, deletedState, itemType, includeDownloadInfo)); } return(QueryItems(workspace.Name, workspace.OwnerName, new [] { itemSpec }, versionSpec, deletedState, itemType, includeDownloadInfo)); }
public IEnumerable QueryHistory(string path, VersionSpec version, int deletionId, RecursionType recursion, string user, VersionSpec versionFrom, VersionSpec versionTo, int maxCount, bool includeChanges, bool slotMode) { return(QueryHistory(path, version, deletionId, recursion, user, versionFrom, versionTo, maxCount, includeChanges, slotMode, false)); }
public TFVersionSpec(string value) { if (String.IsNullOrWhiteSpace(value)) { this.vs = null; } else { this.vs = VersionSpec.ParseSingleSpec(value, null); } }
public ItemSet GetItems(ItemSpec itemSpec, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { List <ItemSpec> itemSpecs = new List <ItemSpec>(); itemSpecs.Add(itemSpec); ItemSet[] itemSet = GetItems(itemSpecs.ToArray(), versionSpec, deletedState, itemType, includeDownloadInfo); return(itemSet[0]); }
public GetStatus Get(string[] items, VersionSpec version, RecursionType recursion, GetOptions options) { List <GetRequest> requests = new List <GetRequest>(); foreach (string item in items) { requests.Add(new GetRequest(item, recursion, version)); } return(Get(requests.ToArray(), options, null, null)); }
public Item GetItem(string path, VersionSpec versionSpec, int deletionId, bool includeDownloadInfo) { ItemSpec itemSpec = new ItemSpec(path, RecursionType.None); ItemSet itemSet = GetItems(itemSpec, versionSpec, DeletedState.NonDeleted, ItemType.Any, includeDownloadInfo); Item[] items = itemSet.Items; if (items.Length > 0) { return(items[0]); } return(null); }
public ItemSet[] QueryItems(string workspaceName, string workspaceOwner, ItemSpec[] itemSpecs, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool generateDownloadUrls) { Message msg = new Message(GetWebRequest(new Uri(Url)), "QueryItems"); if (!String.IsNullOrEmpty(workspaceName)) { msg.Body.WriteElementString("workspaceName", workspaceName); } if (!String.IsNullOrEmpty(workspaceOwner)) { msg.Body.WriteElementString("workspaceOwner", workspaceOwner); } msg.Body.WriteStartElement("items"); foreach (ItemSpec itemSpec in itemSpecs) { itemSpec.ToXml(msg.Body, "ItemSpec"); } msg.Body.WriteEndElement(); versionSpec.ToXml(msg.Body, "version"); msg.Body.WriteElementString("deletedState", deletedState.ToString()); msg.Body.WriteElementString("itemType", itemType.ToString()); msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower()); List <ItemSet> itemSet = new List <ItemSet>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "ItemSet") { itemSet.Add(ItemSet.FromXml(this, results)); } } } return(itemSet.ToArray()); }
public IEnumerable QueryHistory(string path, VersionSpec version, int deletionId, RecursionType recursion, string user, VersionSpec versionFrom, VersionSpec versionToOrig, int maxCount, bool includeChanges, bool slotMode, bool includeDownloadInfo) { ItemSpec itemSpec = new ItemSpec(path, recursion, deletionId); string workspaceName = String.Empty; string workspaceOwner = String.Empty; if (!VersionControlPath.IsServerItem(itemSpec.Item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(itemSpec.Item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } List <Changeset> changes = new List <Changeset>(); int total = maxCount; VersionSpec versionTo = versionToOrig; while (total > 0) { int batchMax = Math.Min(256, total); int batchCnt = repository.QueryHistory(workspaceName, workspaceOwner, itemSpec, version, user, versionFrom, versionTo, batchMax, includeChanges, slotMode, includeDownloadInfo, ref changes); if (batchCnt < batchMax) { break; } total -= batchCnt; Changeset lastChangeset = changes[changes.Count - 1]; versionTo = new ChangesetVersionSpec(lastChangeset.ChangesetId - 1); } return(changes.ToArray()); }
public LabelItemSpec(ItemSpec itemSpec, VersionSpec version, bool exclude) { this.itemSpec = itemSpec; this.version = version; this.exclude = exclude; }
public ChangesetMerge[] QueryMerges(string workspaceName, string workspaceOwner, ItemSpec source, VersionSpec versionSource, ItemSpec target, VersionSpec versionTarget, VersionSpec versionFrom, VersionSpec versionTo, int maxChangesets) { Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryMerges"); if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName); if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner); if (source != null) source.ToXml(msg.Body, "source"); if (versionSource != null) versionSource.ToXml(msg.Body, "versionSource"); target.ToXml(msg.Body, "target"); versionTarget.ToXml(msg.Body, "versionTarget"); if (versionFrom != null) versionFrom.ToXml(msg.Body, "versionFrom"); if (versionTo != null) versionTo.ToXml(msg.Body, "versionTo"); msg.Body.WriteElementString("maxChangesets", Convert.ToString(maxChangesets)); List<ChangesetMerge> merges = new List<ChangesetMerge>(); Dictionary<int, Changeset> changesets = new Dictionary<int, Changeset>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType != XmlNodeType.Element) continue; if (results.Name == "ChangesetMerge") { merges.Add(ChangesetMerge.FromXml(this, results)); } else if (results.Name == "Changeset") { Changeset changeset = Changeset.FromXml(this, results); changesets.Add(changeset.ChangesetId, changeset); } } } foreach (ChangesetMerge merge in merges) { Changeset changeset; if (changesets.TryGetValue(merge.TargetVersion, out changeset)) merge.TargetChangeset = changeset; } return merges.ToArray(); }
public GetStatus Get(string[] items, VersionSpec version, RecursionType recursion, GetOptions options) { List<GetRequest> requests = new List<GetRequest>(); foreach (string item in items) { requests.Add(new GetRequest(item, recursion, version)); } return Get(requests.ToArray(), options, null, null); }
public GetStatus Get(VersionSpec versionSpec, GetOptions options) { GetRequest request = new GetRequest(versionSpec); return(Get(request, GetOptions.None, null, null)); }
public VersionControlLabel[] QueryLabels(string workspaceName, string workspaceOwner, string labelName, string labelScope, string owner, string filterItem, VersionSpec versionFilterItem, bool includeItems, bool generateDownloadUrls) { Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryLabels"); if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName); if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner); if (!String.IsNullOrEmpty(labelName)) msg.Body.WriteElementString("labelName", labelName); if (!String.IsNullOrEmpty(labelScope)) msg.Body.WriteElementString("labelScope", labelScope); if (!String.IsNullOrEmpty(owner)) msg.Body.WriteElementString("owner", owner); if (!String.IsNullOrEmpty(filterItem)) msg.Body.WriteElementString("filterItem", filterItem); if (null != versionFilterItem) versionFilterItem.ToXml(msg.Body, "versionFilterItem"); msg.Body.WriteElementString("includeItems", includeItems.ToString().ToLower()); msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower()); List<VersionControlLabel> labels = new List<VersionControlLabel>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "VersionControlLabel") labels.Add(VersionControlLabel.FromXml(this, results)); } } return labels.ToArray(); }
public void LatestVersionSpec() { VersionSpec spec = VersionSpec.Latest; Assert.AreEqual("T", spec.DisplayString); }
public Item GetItem(string path, VersionSpec versionSpec, int deletionId, bool includeDownloadInfo) { ItemSpec itemSpec = new ItemSpec(path, RecursionType.None); ItemSet itemSet = GetItems(itemSpec, versionSpec, DeletedState.NonDeleted, ItemType.Any, includeDownloadInfo); Item[] items = itemSet.Items; if (items.Length > 0) return items[0]; return null; }
private List<Changeset> GetChangesets( string path, VersionSpec startVersionSpec, VersionSpec endVersionSpec ) { VersionSpec refinedStartVersion = Refine( path, startVersionSpec, true ); VersionSpec refinedEndVersion = Refine( path, endVersionSpec, false ); List<Changeset> changesets = new List<Changeset>(); foreach( Changeset changeset in clientHelper.VersionControl.QueryHistory( path, VersionSpec.Latest, 0, RecursionType.Full, null, refinedStartVersion, refinedEndVersion, Int32.MaxValue, true, false ) ) { changesets.Add( changeset ); } return changesets; }
public ItemSet GetItems(string path, VersionSpec versionSpec, RecursionType recursionType) { ItemSpec itemSpec = new ItemSpec(path, recursionType); return GetItems(itemSpec, versionSpec, DeletedState.NonDeleted, ItemType.Any, false); }
public TFSRevisionVersion(VersionSpec versionSpec) { VersionSpec = versionSpec; }
public ItemSet GetItems(ItemSpec itemSpec, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { List<ItemSpec> itemSpecs = new List<ItemSpec>(); itemSpecs.Add(itemSpec); ItemSet[] itemSet = GetItems(itemSpecs.ToArray(), versionSpec, deletedState, itemType, includeDownloadInfo); return itemSet[0]; }
public LabelItemSpec(ItemSpec itemSpec, VersionSpec version, bool exclude) { this.itemSpec = itemSpec; this.version = version; this.exclude = exclude; }
public IAnnotatedFile Annotate(string path, VersionSpec version) { var options = new DiffOptions { Flags = DiffOptionFlags.EnablePreambleHandling | DiffOptionFlags.IgnoreLeadingAndTrailingWhiteSpace | DiffOptionFlags.IgnoreEndOfLineDifference }; PendingChange[] pendingChanges = server.GetWorkspace(path).GetPendingChanges(path); if (pendingChanges.Length >= 2) { throw new InvalidOperationException("Expected at most 1 pending change, but got " + pendingChanges.Length); } Changeset currentChangeset = null; AnnotatedFile annotatedFile; string currentPath; int currentEncoding; if (pendingChanges.Length == 1 && (pendingChanges[0].ChangeType & ChangeType.Edit) != 0) { annotatedFile = new AnnotatedFile(path, pendingChanges[0].Encoding); if (annotatedFile.IsBinary()) { return annotatedFile; } currentPath = path; currentEncoding = pendingChanges[0].Encoding; } else { annotatedFile = null; currentPath = null; currentEncoding = 0; } using (var historyProvider = new HistoryProvider(server, path, version)) { bool done = false; while (!done && historyProvider.Next()) { Changeset previousChangeset = historyProvider.Changeset(); string previousPath = historyProvider.Filename(); int previousEncoding = previousChangeset.Changes[0].Item.Encoding; if (annotatedFile == null) { annotatedFile = new AnnotatedFile(previousPath, previousEncoding); if (annotatedFile.IsBinary()) { return annotatedFile; } } else if (previousEncoding == -1) { annotatedFile.Apply(currentChangeset); done = true; } else { var diff = Diff(Difference.DiffFiles(currentPath, currentEncoding, previousPath, previousEncoding, options)); done = annotatedFile.ApplyDiff(currentChangeset, diff); } currentChangeset = previousChangeset; currentEncoding = previousEncoding; currentPath = previousPath; } if (annotatedFile != null) { annotatedFile.Apply(currentChangeset); } } return annotatedFile; }
public ChangesetMerge[] QueryMerges(string sourcePath, VersionSpec sourceVersion, string targetPath, VersionSpec targetVersion, VersionSpec versionFrom, VersionSpec versionTo, RecursionType recursion) { string workspaceName = String.Empty; string workspaceOwner = String.Empty; if (!VersionControlPath.IsServerItem(targetPath)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(targetPath); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } ItemSpec sourceItem = null; if (!String.IsNullOrEmpty(sourcePath)) sourceItem = new ItemSpec(sourcePath, recursion); ItemSpec targetItem = new ItemSpec(targetPath, recursion); ChangesetMerge[] merges = repository.QueryMerges(workspaceName, workspaceOwner, sourceItem, sourceVersion, targetItem, targetVersion, versionFrom, versionTo, Int32.MaxValue); return merges; }
public LabelResult[] UnlabelItem(string labelName, string labelScope, ItemSpec[] itemSpecs, VersionSpec version) { Workspace workspace = GetWorkspace(itemSpecs[0].Item); return repository.UnlabelItem(workspace, labelName, labelScope, itemSpecs, version); }
public TFVersionSpec(int changeset) { this.vs = new ChangesetVersionSpec(changeset); }
public Item GetItem(string path, VersionSpec versionSpec) { return GetItem(path, versionSpec, 0, false); }
private VersionSpec Refine( string path, VersionSpec startVersionSpec, bool isStart ) { if( startVersionSpec is LabelVersionSpec ) { int changesetId = GetMostRecentChangesetId( path, (LabelVersionSpec) startVersionSpec ); return MakeChangesetSpec( changesetId, isStart ); } return startVersionSpec; }
public IEnumerable QueryHistory(string path, VersionSpec version, int deletionId, RecursionType recursion, string user, VersionSpec versionFrom, VersionSpec versionToOrig, int maxCount, bool includeChanges, bool slotMode, bool includeDownloadInfo) { ItemSpec itemSpec = new ItemSpec(path, recursion, deletionId); string workspaceName = String.Empty; string workspaceOwner = String.Empty; if (!VersionControlPath.IsServerItem(itemSpec.Item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(itemSpec.Item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } List<Changeset> changes = new List<Changeset>(); int total = maxCount; VersionSpec versionTo = versionToOrig; while (total > 0) { int batchMax = Math.Min(256, total); int batchCnt = repository.QueryHistory(workspaceName, workspaceOwner, itemSpec, version, user, versionFrom, versionTo, batchMax, includeChanges, slotMode, includeDownloadInfo, ref changes); if (batchCnt < batchMax) break; total -= batchCnt; Changeset lastChangeset = changes[changes.Count - 1]; versionTo = new ChangesetVersionSpec(lastChangeset.ChangesetId - 1); } return changes.ToArray(); }
public ItemSet[] QueryItems(string workspaceName, string workspaceOwner, ItemSpec[] itemSpecs, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool generateDownloadUrls) { Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItems"); if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName); if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner); msg.Body.WriteStartElement("items"); foreach (ItemSpec itemSpec in itemSpecs) itemSpec.ToXml(msg.Body, "ItemSpec"); msg.Body.WriteEndElement(); versionSpec.ToXml(msg.Body, "version"); msg.Body.WriteElementString("deletedState", deletedState.ToString()); msg.Body.WriteElementString("itemType", itemType.ToString()); msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower()); List<ItemSet> itemSet = new List<ItemSet>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element && results.Name == "ItemSet") itemSet.Add(ItemSet.FromXml(this, results)); } } return itemSet.ToArray(); }
// <QueryItems xmlns="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03"> // <workspaceName>string</workspaceName> // <workspaceOwner>string</workspaceOwner> // <items> // <ItemSpec item="string" recurse="None or OneLevel or Full" did="int" /> // <ItemSpec item="string" recurse="None or OneLevel or Full" did="int" /> // </items> // <version /> // <deletedState>NonDeleted or Deleted or Any</deletedState> // <itemType>Any or Folder or File</itemType> // <generateDownloadUrls>boolean</generateDownloadUrls> // <options>int</options> // </QueryItems> public List <Item> QueryItems(string workspaceName, string workspaceOwner, ItemSpec[] itemSpecs, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { var invoker = new SoapInvoker(this); var msg = invoker.CreateEnvelope("QueryItems"); if (!string.IsNullOrEmpty(workspaceName)) { msg.Add(new XElement(MessageNs + "workspaceName", workspaceName)); } if (!string.IsNullOrEmpty(workspaceOwner)) { msg.Add(new XElement(MessageNs + "workspaceOwner", workspaceOwner)); } msg.Add(new XElement(MessageNs + "items", itemSpecs.Select(itemSpec => itemSpec.ToXml(MessageNs + "ItemSpec")))); msg.Add(versionSpec.ToXml(MessageNs + "version")); msg.Add(new XElement(MessageNs + "deletedState", deletedState)); msg.Add(new XElement(MessageNs + "itemType", itemType)); msg.Add(new XElement(MessageNs + "generateDownloadUrls", includeDownloadInfo.ToLowString())); var result = invoker.InvokeResult(); return(result.Descendants(MessageNs + "Item").Select(Item.FromXml).ToList()); }
public GetStatus Get(VersionSpec versionSpec, GetOptions options) { GetRequest request = new GetRequest(versionSpec); return Get(request, GetOptions.None, null, null); }
public VersionControlLabel[] QueryLabels(string labelName, string labelScope, string owner, bool includeItems, string filterItem, VersionSpec versionFilterItem, bool generateDownloadUrls) { return repository.QueryLabels(null, null, labelName, labelScope, owner, filterItem, versionFilterItem, includeItems, generateDownloadUrls); }
public BranchHistoryTreeItem[][] GetBranchHistory(ItemSpec[] itemSpecs, VersionSpec version) { if (itemSpecs.Length == 0) return null; string workspaceName = String.Empty; string workspaceOwner = String.Empty; string item = itemSpecs[0].Item; if (!VersionControlPath.IsServerItem(item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } return repository.QueryBranches(workspaceName, workspaceOwner, itemSpecs, version); }
private IEnumerable<Changeset> GetChangesets(VersionSpec fromChangeset, VersionSpec toChangeset) { List<Changeset> changesets = new List<Changeset>(); foreach (var teamProject in _teamProjects) { changesets.AddRange( _versionControl.QueryHistory( teamProject.ServerItem, VersionSpec.Latest, 0, RecursionType.Full, null, fromChangeset, toChangeset, int.MaxValue, true, true, false, true).Cast<Changeset>()); } return changesets; }
public List <Item> QueryItems(ItemSpec itemSpec, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { return(QueryItems(string.Empty, string.Empty, new [] { itemSpec }, versionSpec, deletedState, itemType, includeDownloadInfo)); }
public LabelResult[] UnlabelItem(Workspace workspace, string labelName, string labelScope, ItemSpec[] itemSpecs, VersionSpec version) { Message msg = new Message(GetWebRequest (new Uri(Url)), "UnlabelItem"); msg.Body.WriteElementString("workspaceName", workspace.Name); msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName); msg.Body.WriteElementString("labelName", labelName); if (!String.IsNullOrEmpty(labelScope)) msg.Body.WriteElementString("labelScope", labelScope); msg.Body.WriteStartElement("items"); foreach (ItemSpec itemSpec in itemSpecs) { itemSpec.ToXml(msg.Body, "ItemSpec"); } msg.Body.WriteEndElement(); version.ToXml(msg.Body, "version"); List<LabelResult> labelResults = new List<LabelResult>(); List<Failure> faillist = new List<Failure>(); using (HttpWebResponse response = Invoke(msg)) { XmlReader results = msg.ResponseReader(response); while (results.Read()) { if (results.NodeType == XmlNodeType.Element) { switch (results.Name) { case "LabelResult": labelResults.Add(LabelResult.FromXml(this, results)); break; case "Failure": faillist.Add(Failure.FromXml(this, results)); break; } } } } foreach (Failure failure in faillist) { versionControlServer.OnNonFatalError(workspace, failure); } return labelResults.ToArray(); }
public IEnumerable QueryHistory(string path, VersionSpec version, int deletionId, RecursionType recursion, string user, VersionSpec versionFrom, VersionSpec versionTo, int maxCount, bool includeChanges, bool slotMode) { return QueryHistory(path, version, deletionId, recursion, user, versionFrom, versionTo, maxCount, includeChanges, slotMode, false); }
public ItemSet[] GetItems(ItemSpec[] itemSpecs, VersionSpec versionSpec, DeletedState deletedState, ItemType itemType, bool includeDownloadInfo) { if (itemSpecs.Length == 0) return null; string workspaceName = String.Empty; string workspaceOwner = String.Empty; string item = itemSpecs[0].Item; if (!VersionControlPath.IsServerItem(item)) { WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(item); if (info != null) { workspaceName = info.Name; workspaceOwner = info.OwnerName; } } return repository.QueryItems(workspaceName, workspaceOwner, itemSpecs, versionSpec, deletedState, itemType, includeDownloadInfo); }
internal GetRequest(VersionSpec versionSpec) { this.versionSpec = versionSpec; }
public Item GetItem(string path, VersionSpec versionSpec) { return(GetItem(path, versionSpec, 0, false)); }
public GetRequest(ItemSpec itemSpec, int changesetId) { this.itemSpec = itemSpec; this.versionSpec = new ChangesetVersionSpec(changesetId); }
public GetRequest(string item, RecursionType recursionType, VersionSpec versionSpec) { this.itemSpec = new ItemSpec(item, recursionType); this.versionSpec = versionSpec; }
public GetRequest(ItemSpec itemSpec, VersionSpec versionSpec) { this.itemSpec = itemSpec; this.versionSpec = versionSpec; }
private MergeResult MergeByFile(Change[] changes, string targetBranch, List<MergeRelation> mergeRelationships, VersionSpec version, MergeOption mergeOption, Workspace workspace) { if (!GetLatest(targetBranch, mergeRelationships, workspace)) { return MergeResult.CanNotGetLatest; } var mergeOptions = ToTfsMergeOptions(mergeOption); var hasConflicts = false; foreach (var change in changes) { var mergeRelation = mergeRelationships.FirstOrDefault( r => r.Item == change.Item.ServerItem && r.Target.StartsWith(targetBranch)); if (mergeRelation != null) { var recursionType = CalculateRecursionType(mergeRelation); var status = workspace.Merge(mergeRelation.Source, mergeRelation.Target, version, version, LockLevel.None, recursionType, mergeOptions); if (!hasConflicts && HasConflicts(status)) { hasConflicts = true; } } else { Logger.Info("File {0} not merged to branch {1}", change.Item.ServerItem, targetBranch); } } if (hasConflicts) { var conflicts = AutoResolveConflicts(workspace, targetBranch, mergeOption); if (!conflicts.IsNullOrEmpty()) { return IsTryRestoreUnexpectedFile(conflicts) ? MergeResult.UnexpectedFileRestored : MergeResult.HasConflicts; } } return MergeResult.Merged; }