void MonitorCheckins() { int lastestChangesetId = AppSettings.LatestChangesetId; while (true) { ChangesetVersionSpec versionFrom = new ChangesetVersionSpec(lastestChangesetId.ToString()); IEnumerable changeSets = VersionControlServer.QueryHistory(VersionControlPath.RootFolder, VersionSpec.Latest, 0, RecursionType.Full, null, versionFrom, null, 100, false, false, false); Stack<string> msgStack = new Stack<string>(); foreach (Changeset changeSet in changeSets) { if (changeSet.ChangesetId > lastestChangesetId) { lastestChangesetId = changeSet.ChangesetId; //StringBuilder sb = new StringBuilder(); //foreach (Change change in changeSet.Changes) // { // if (sb.Length != 0) sb.Append(", "); // sb.Append(change.Item.ServerItem); // } // msgStack.Push("Files: " + sb.ToString()); string msg0 = String.Format("Url: {0}/VersionControl/Changeset.aspx?artifactMoniker={1}&webView=true", AppSettings.TfsUrl, changeSet.ChangesetId); msgStack.Push(msg0); if (!String.IsNullOrEmpty(changeSet.Comment)) { string msg1 = String.Format("Comment: {0}", changeSet.Comment); msgStack.Push(msg1); } string msg2 = String.Format("Changset: {0} by {1} on {2}", changeSet.ChangesetId, changeSet.Committer, changeSet.CreationDate.ToString()); msgStack.Push(msg2); } } bool fnd = msgStack.Count > 0; while (msgStack.Count > 0) { string msg = msgStack.Pop(); irc.SendMessage(SendType.Message, AppSettings.Channel, msg); } if (fnd) UpdateLatestChangset(lastestChangesetId); Thread.Sleep(1000*300); } }
public QueryModel() { RevisionFrom = new ChangesetVersionSpec(1); RevisionTo = VersionSpec.Latest; MaxRevisions = int.MaxValue; Author = new Author(); IncludeChanges = true; DeletionId = 0; SlotMode = false; RecursionType = RecursionType.Full; }
public BranchFactory(string sourceBranch, string sourceFolder, ChangesetVersionSpec changesetVersion, BranchValidator branchValidator, IEventAggregator eventAggregator) { _sourceBranch = sourceBranch; _sourceFolder = sourceFolder; _changesetVersion = changesetVersion; _branchValidator = branchValidator; _eventAggregator = eventAggregator; }
public override void CreateBranch(string sourcePath, string targetPath, int changesetId, string comment = null) { var changesetToBranch = new ChangesetVersionSpec(changesetId); int branchChangesetId = VersionControl.CreateBranch(sourcePath, targetPath, changesetToBranch); if (comment != null) { Changeset changeset = VersionControl.GetChangeset(branchChangesetId); changeset.Comment = comment; changeset.Update(); } }
public string GetBranchParentPath(string path, int changesetId) { var itemSpec = new[] { new tfs.ItemSpec(path, tfs.RecursionType.None) }; var versionSpec = new tfs.ChangesetVersionSpec(changesetId); var branchHistoryTree = _versionControlServer.GetBranchHistory(itemSpec, versionSpec); if (branchHistoryTree.Count() > 0 && branchHistoryTree[0].Count() > 0) { return(branchHistoryTree[0][0].Relative.BranchToItem.ServerItem); } return(null); }
private int GetPreviousChangesetId(string serverItem, int changesetId) { VersionSpec version = new ChangesetVersionSpec(changesetId); var itemChangesetHistory = versionControlServer.QueryHistory(serverItem, version, 0, RecursionType.Full, null, null, version, 2, false, false); int previousVersionId = changesetId; foreach (Changeset changeset in itemChangesetHistory) { previousVersionId = changeset.ChangesetId; } return previousVersionId; }
public void ShowChangeset(VersionControlServer vcs, int cid) { ChangesetVersionSpec versionSpec = new ChangesetVersionSpec(cid); string tname = System.IO.Path.GetTempFileName(); using (StreamWriter sw = new StreamWriter(tname)) { DiffHelper.ShowChangeset(vcs, versionSpec, false, GetDiffOptions(sw)); } using (StreamReader sr = new StreamReader(tname)) { textView.Update("temp.diff", sr.ReadToEnd()); } File.Delete(tname); }
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()); }
private static IEnumerable GetMergeHistory(VersionControlServer vcs, MergeSource ms) { var changesetVersionSpec = new ChangesetVersionSpec(ms.VersionFrom); var versionTo = new ChangesetVersionSpec(ms.VersionTo); return(vcs.QueryHistory( ms.ServerItem, changesetVersionSpec, 0, RecursionType.Full, null, changesetVersionSpec, versionTo, 2147483647, true, true)); }
public string DiffFileVersions(string filePath, int firstVersion, int secondVersion) { var server = this.versionControl; var firstChangeset = new ChangesetVersionSpec(firstVersion); var secondChangeset = new ChangesetVersionSpec(secondVersion); var item1 = Difference.CreateTargetDiffItem(server, filePath, firstChangeset, 0, firstChangeset); var item2 = Difference.CreateTargetDiffItem(server, filePath, secondChangeset, 0, secondChangeset); var memoryStream = new MemoryStream(); var writer = new StreamWriter(memoryStream); Difference.DiffFiles(server, item1, item2, new DiffOptions() { OutputType = DiffOutputType.Unified, StreamWriter = writer }, "TEST", true); writer.Flush(); memoryStream.Position = 0; var reader = new StreamReader(memoryStream); var result = reader.ReadToEnd(); return result; }
public void UpdateCid(int cid) { ChangesetVersionSpec versionSpec = new ChangesetVersionSpec(cid); Toplevel.GdkWindow.Cursor = new Gdk.Cursor(Gdk.CursorType.Watch); string tname = System.IO.Path.GetTempFileName(); using (StreamWriter sw = new StreamWriter(tname)) { DiffHelper.ShowChangeset(driver.VersionControlServer, versionSpec, false, GetDiffOptions(sw)); } using (StreamReader sr = new StreamReader(tname)) { textView.Update("temp.diff", sr.ReadToEnd()); } Toplevel.GdkWindow.Cursor = new Gdk.Cursor(Gdk.CursorType.LeftPtr); File.Delete(tname); }
protected IEnumerable<MSChangeset> QueryAllChangesetsFromRevision(int revisionId) { var tfsClient = new TeamFoundationServer(repositoryUrl, credentials); tfsClient.Authenticate(); var vcs = (VersionControlServer) tfsClient.GetService(typeof (VersionControlServer)); var version = VersionSpec.Latest; var versionTo = VersionSpec.Latest; var versionFrom = new ChangesetVersionSpec(revisionId); const int deletionId = 0; const string user = null; IEnumerable changesets = vcs.QueryHistory(repositoryPath, version, deletionId, RecursionType.Full, user, versionFrom, versionTo, int.MaxValue, true, false); var retvalue = new List<MSChangeset>(); foreach (object item in changesets) retvalue.Add(item as MSChangeset); return retvalue; }
private IEnumerable<int> GetChangesetIds() { SortedList sortedChangesets = new SortedList(); List<int> changesetsIds = new List<int>(); try { ChangesetVersionSpec versionFrom = new ChangesetVersionSpec(_startingChangeset); IEnumerable changesets = this._versionControlServer.QueryHistory(this._remotePath, VersionSpec.Latest, 0, RecursionType.Full, null, versionFrom, VersionSpec.Latest, int.MaxValue, false, false); foreach (Changeset changeset in changesets) { changesetsIds.Add(changeset.ChangesetId); //sortedChangesets.Add(changeset.ChangesetId, changeset); } changesetsIds.Sort(); if (this.ChangeSetsFound != null) this.ChangeSetsFound(changesetsIds.Count); //notify the number of found changesets (used in progressbar) } catch (Exception ex) { throw new Exception("Error while executing TFS QueryHistory", ex); } return changesetsIds; }
/// <summary> /// Does the main merge operation for selected items and checks-in every changeset. /// </summary> /// <param name="mfrm">The UserControl.</param> /// <param name="lvcoll">The Collection of ListViewItems.</param> /// <param name="trg">The target path.</param> internal static void DoMerge(UserControl mfrm, IEnumerable<ListViewItem> lvcoll, string trg) { Workspace wrkspc = Utilities.vcext.Explorer.Workspace; if (!ServerItemExists(trg)) { MessageBox.Show("Target server path is cloacked or doesn't exist.", Utilities.AppTitle); return; } if (wrkspc.GetPendingChanges().Length > 0) { MessageBox.Show("Please resolve all pending changes before going on.", Utilities.AppTitle); return; } //object prgmerge = CreateProgressMerge(vcsrv); //ShowProgressMerge(prgmerge, mfrm); int idx = 0; bool bcanceled = false; int icanceled; var dlg = Utilities.CreateThreadedWaitDialog("Merging changesets", "Stating changesets merge...", "status", 100); ErrorHandler.ThrowOnFailure(dlg.UpdateProgress("Merging changesets", "Stating changesets merge...", "status", idx++, 100, false, out bcanceled)); if (bcanceled) return; foreach (var lvItem in lvcoll) { string MergeTypeText = lvItem.SubItems[MergeTypeIndex].Text; if (MergeTypeText == "none") continue; Changeset ch = Utilities.vcsrv.GetChangeset((lvItem.Tag as ListViewItemTag).ChangesetID); Utilities.OutputCommandString("Preparing for merge changeset: " + ch.ChangesetId); if (LinkWorkItems) { foreach (var workItm in ch.WorkItems) Utilities.OutputCommandString("Associated WorkItem: " + workItm.Id); } ErrorHandler.ThrowOnFailure(dlg.UpdateProgress("Merging changesets", "Merging changeset: " + ch.ChangesetId, "status", idx++, 100, false, out bcanceled)); if (bcanceled) return; var chverspc = new ChangesetVersionSpec(ch.ChangesetId); Utilities.OutputCommandString("Changeset Version: " + chverspc.DisplayString); MergeOptionsEx mergeType = (MergeTypeText == "baseless" ? MergeOptionsEx.Baseless : MergeTypeText == "force" ? MergeOptionsEx.ForceMerge : MergeOptionsEx.None); mergeType |= mergeOptions; GetStatus sts = wrkspc.Merge((lvItem.Tag as ListViewItemTag).sourcePath, trg, chverspc, chverspc, LockLevel.Unchanged, RecursionType.Full, mergeType); Utilities.OutputCommandString("Merge summary: MergeOptionsEx=" + mergeType + ", NoActionNeeded=" + sts.NoActionNeeded + ", NumFailures=" + sts.NumFailures + ", NumOperations=" + sts.NumOperations + ", NumUpdated=" + sts.NumUpdated + ", NumWarnings=" + sts.NumWarnings); if (mergeOptions != MergeOptionsEx.NoMerge) { while (wrkspc.QueryConflicts(ch.Changes.Select(x => x.Item.ServerItem).ToArray(), true).Length > 0) { //foreach (var conflict in conflicts) wrkspc.ResolveConflict(conflict); DialogResult res = MessageBox.Show("Merge conflicts where found. Resolve them or click Cancel to break merge operaton.", "Merge conflicts", MessageBoxButtons.OKCancel); if (res == DialogResult.Cancel) { ErrorHandler.ThrowOnFailure(dlg.EndWaitDialog(out icanceled)); return; } if (mfrm.InvokeRequired) { var asynchres = mfrm.BeginInvoke(new MethodInvoker(Utilities.ShowResolveConflictsDlg)); mfrm.EndInvoke(asynchres); } else { Utilities.ShowResolveConflictsDlg(); } } var pendingCh = wrkspc.GetPendingChanges();//ch.Changes.Select(x => new ItemSpec(x.Item.ServerItem, RecursionType.Full, x.Item.DeletionId)).ToArray(), true).ToArray(); if (pendingCh.Length == 0) { Utilities.OutputCommandString("No pending changes found."); continue; } var wrkitmch = (LinkWorkItems ? ch.WorkItems.Select(x => new WorkItemCheckinInfo(x, WorkItemCheckinAction.Associate)).ToArray() : null); foreach (var pendChItem in pendingCh) Utilities.OutputCommandString("Found pending change " + pendChItem.ChangeTypeName + ": " + pendChItem.SourceServerItem); int newchid = wrkspc.CheckIn(pendingCh, ch.Committer, ch.Comment, ch.CheckinNote, wrkitmch, null, CheckinOptions.SuppressEvent); Utilities.OutputCommandString("Created new changeset: " + newchid); } if (idx == 100) idx = 0; } ErrorHandler.ThrowOnFailure(dlg.EndWaitDialog(out icanceled)); //CloseProgressMerge(prgmerge); }
private async void GetHistory() { if (SelectedSourceControlItem == null) return; Working = true; SelectedItemHistory.Clear(); await Task.Run(() => { string serverItem = SelectedSourceControlItem.ServerItem; List<Changeset> changesets = new List<Changeset>(); ItemSpec spec = new ItemSpec(serverItem, RecursionType.None); ChangesetVersionSpec version = new ChangesetVersionSpec(SelectedSourceControlItem.Item.ChangesetId); ChangesetVersionSpec versionFrom = new ChangesetVersionSpec(1); changesets = TfsShared.Instance.Vcs.QueryHistory(serverItem, version, 0, RecursionType.None, null, versionFrom, VersionSpec.Latest, int.MaxValue, true, false).Cast<Changeset>().OrderByDescending(d => d.CreationDate).ToList(); foreach (var change in changesets) SelectedItemHistory.AddOnUi(change); }); Working = false; }
public void ChangesetVersionSpec() { VersionSpec spec = new ChangesetVersionSpec(1); Assert.AreEqual("C1", spec.DisplayString); }
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(); }
void MyShowChangesetEventHandler(object sender, ShowChangesetEventArgs args) { int changesetId = args.ChangesetId; VersionControlServer vcs = args.VersionControlServer; ChangesetVersionSpec versionSpec = new ChangesetVersionSpec(changesetId); string tname = System.IO.Path.GetTempFileName(); using (StreamWriter sw = new StreamWriter(tname)) { DiffOptions options = new DiffOptions(); options.UseThirdPartyTool = false; options.Flags = DiffOptionFlags.EnablePreambleHandling; options.OutputType = DiffOutputType.Unified; options.TargetEncoding = Encoding.UTF8; options.SourceEncoding = Encoding.UTF8; options.StreamWriter = sw; options.StreamWriter.AutoFlush = true; DiffHelper.ShowChangeset(vcs, versionSpec, false, options); } Document d = MonoDevelop.Ide.Gui.IdeApp.Workbench.OpenDocument (tname, true); d.FileName = "Changeset " + changesetId.ToString(); File.Delete(tname); }
private ObservableCollection<MergeInfoViewModel> GetBranches(ITeamFoundationContext context, ChangesetViewModel changesetViewModel) { if (context == null) return new ObservableCollection<MergeInfoViewModel>(); var tfs = context.TeamProjectCollection; var versionControl = tfs.GetService<VersionControlServer>(); var result = new ObservableCollection<MergeInfoViewModel>(); var workspace = _workspace; var changesetService = _changesetService; var changes = changesetService.GetChanges(changesetViewModel.ChangesetId); var sourceTopFolder = CalculateTopFolder(changes); var mergesRelationships = GetMergesRelationships(sourceTopFolder, versionControl); if (mergesRelationships.Count > 0) { var sourceBranchIdentifier = changesetViewModel.Branches.Select(b => new ItemIdentifier(b)).First(); var sourceBranch = sourceBranchIdentifier.Item; var trackMerges = versionControl.TrackMerges(new[] { changesetViewModel.ChangesetId }, new ItemIdentifier(sourceTopFolder), mergesRelationships.ToArray(), null); var changesetVersionSpec = new ChangesetVersionSpec(changesetViewModel.ChangesetId); var branchValidator = new BranchValidator(workspace, trackMerges); var branchFactory = new BranchFactory(sourceBranch, sourceTopFolder, changesetVersionSpec, branchValidator, _eventAggregator, _settings); var sourceBranchInfo = versionControl.QueryBranchObjects(sourceBranchIdentifier, RecursionType.None)[0]; if (sourceBranchInfo.Properties != null && sourceBranchInfo.Properties.ParentBranch != null && !sourceBranchInfo.Properties.ParentBranch.IsDeleted) { var targetBranch = sourceBranchInfo.Properties.ParentBranch; var targetPath = GetTargetPath(mergesRelationships, targetBranch); if (targetPath != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, targetPath); mergeInfo._checked = mergeInfo.ValidationResult == BranchValidationResult.Success; result.Add(mergeInfo); } } var currentBranchInfo = branchFactory.CreateSourceBranch(); result.Add(currentBranchInfo); if (sourceBranchInfo.ChildBranches != null) { var childBranches = sourceBranchInfo.ChildBranches.Where(b => !b.IsDeleted) .Reverse(); foreach (var childBranch in childBranches) { var targetBranch = childBranch; var targetPath = GetTargetPath(mergesRelationships, targetBranch); if (targetPath != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, targetPath); result.Add(mergeInfo); } } } // Feature branch if (mergesRelationships.Count > 0) { var changetIds = mergesRelationships.Select(r => r.Version).Cast<ChangesetVersionSpec>().Select(c => c.ChangesetId) .Distinct() .ToArray(); var branches = _changesetService.GetAssociatedBranches(changetIds); foreach (var mergesRelationship in mergesRelationships) { var targetBranch = branches.FirstOrDefault(b => IsTargetPath(mergesRelationship, b)); if (targetBranch != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, mergesRelationship); result.Add(mergeInfo); } } } } return result; }
public void VisualDiff(Item item1, Item item2) { if (item1.ItemType != ItemType.File) return; var sourceVersion = new ChangesetVersionSpec(item1.ChangesetId); var targetVersion = new ChangesetVersionSpec(item2.ChangesetId); try { Difference.VisualDiffItems( item1.VersionControlServer, Difference.CreateTargetDiffItem(item1.VersionControlServer, item2.ServerItem, targetVersion, 0, targetVersion), Difference.CreateTargetDiffItem(item1.VersionControlServer, item1.ServerItem, sourceVersion, 0, sourceVersion), true); } catch (Exception exception) { } }
public bool DiffWithPreviousVersion(Change theChange, int changesetId) { var changeId = (theChange.Item.DeletionId != 0) ? theChange.Item.ChangesetId - 1 : theChange.Item.ChangesetId; var version = new ChangesetVersionSpec(changeId); var versionFrom = new ChangesetVersionSpec(1); var changesets = _versionControlServer.QueryHistory(theChange.Item.ServerItem, version, 0, RecursionType.None, null, versionFrom, VersionSpec.Latest, int.MaxValue, true, false, true); var historyChangeset = changesets.Cast<Changeset>().Skip(1).FirstOrDefault(); if (historyChangeset != null) { var previousItem = historyChangeset.Changes.Single(c => c.Item.ServerItem == theChange.Item.ServerItem).Item; return DiffFiles(theChange.Item, previousItem); } return false; }
public static void ShowChangeset(VersionControlServer vcs, ChangesetVersionSpec versionSpec, bool brief, DiffOptions diffOpts) { int changesetId = versionSpec.ChangesetId; Changeset changeset = vcs.GetChangeset(changesetId, true, true); // fetch all items in one fell swoop List<int> ids = new List<int>(); foreach (Change change in changeset.Changes) ids.Add(change.Item.ItemId); // find items in prior changeset Item[] items = vcs.GetItems(ids.ToArray(), changesetId-1, true); SortedList<int, Item> itemList = new SortedList<int, Item>(); foreach (Item item in items) { // itemId of 0 means a null item, IOW file was added in this changeset // and missing in prior changeset if (item.ItemId == 0) continue; itemList.Add(item.ItemId, item); } foreach (Change change in changeset.Changes) { // skip folders if (change.Item.ItemType == ItemType.Folder) continue; string p = change.Item.ServerItem.Substring(2); if (brief) { Console.WriteLine(p); continue; } IDiffItem a = new DiffItemNull(); IDiffItem b = new DiffItemNull(); string tnameA = null; string tnameB = null; if (((change.ChangeType & ChangeType.Add) != ChangeType.Add) && (itemList.ContainsKey(change.Item.ItemId))) { Item itemA = itemList[change.Item.ItemId]; tnameA = Path.GetTempFileName(); itemA.DownloadFile(tnameA); a = new DiffItemLocalFile(tnameA, itemA.Encoding, changeset.CreationDate, true); } if ((change.ChangeType & ChangeType.Delete) != ChangeType.Delete) { tnameB = Path.GetTempFileName(); change.Item.DownloadFile(tnameB); b = new DiffItemLocalFile(tnameB, change.Item.Encoding, changeset.CreationDate, true); } diffOpts.TargetLabel = versionSpec.DisplayString; Difference.DiffFiles(vcs, a, b, diffOpts, p, true); if (!String.IsNullOrEmpty(tnameA)) File.Delete(tnameA); if (!String.IsNullOrEmpty(tnameB)) File.Delete(tnameB); } }
void GetChangesets(TfsTeamProjectCollection tfs) { //why the freak is this not working var dtpFrom = DateTime.Parse("2/17/1016"); var dtpTo = DateTime.Parse("3/3/2016"); //search by date range VersionSpec fromDateVersion = new DateVersionSpec(dtpFrom); VersionSpec toDateVersion = new DateVersionSpec(dtpTo); //this works but by date does not work ChangesetVersionSpec versionFrom = new ChangesetVersionSpec(221192); ChangesetVersionSpec versionTo = new ChangesetVersionSpec(225981); //this gets that most recent 100 change sets var history = tfs .GetService<VersionControlServer>() .QueryHistory( path: "$/eLeadCRM Project/Evolution2", version: VersionSpec.Latest, deletionId: 0, recursion: RecursionType.Full, user: String.Empty, versionFrom: versionFrom, versionTo: versionTo, //VersionSpec.Latest, maxCount: 5555, includeChanges: true, slotMode: true); List<string> asyncFiles = new List<string>(); foreach (Changeset changeset in history) { foreach (var w in changeset.Changes) { try { //where are there items that aren't files that can't be downloaded if (!w.Item.ServerItem.Contains(".cs")) continue; var stream = w.Item.DownloadFile(); StreamReader reader = new StreamReader(stream); string text = reader.ReadToEnd().ToLower(); if (text.Contains("async") &&! w.Item.ServerItem.Contains(".js")) { asyncFiles.Add(w.Item.ServerItem); } } catch { } finally { } Console.WriteLine("Type:" + w.ChangeType); Console.WriteLine("Comment:" + changeset.Comment); Console.WriteLine("Date:" + changeset.CreationDate); foreach (var y in changeset.WorkItems) { Console.WriteLine("Name:" + y.Title + y.Type); } } } }
private static IEnumerable GetMergeHistory(VersionControlServer vcs, MergeSource ms) { var changesetVersionSpec = new ChangesetVersionSpec(ms.VersionFrom); var versionTo = new ChangesetVersionSpec(ms.VersionTo); return vcs.QueryHistory( ms.ServerItem, changesetVersionSpec, 0, RecursionType.Full, null, changesetVersionSpec, versionTo, 2147483647, true, true); }
public override IEnumerable<ITfsChangeset> GetChangesets(string path, long startVersion, IGitTfsRemote remote) { const int batchCount = 100; var start = (int)startVersion; Changeset[] changesets; do { var startChangeset = new ChangesetVersionSpec(start); changesets = Retry.Do(() => VersionControl.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, null, startChangeset, null, batchCount, true, true, true, true) .Cast<Changeset>().ToArray()); if (changesets.Length > 0) start = changesets[changesets.Length - 1].ChangesetId + 1; // don't take the enumerator produced by a foreach statement or a yield statement, as there are references // to the old (iterated) elements and thus the referenced changesets won't be disposed until all elements were iterated. for (int i = 0; i < changesets.Length; i++) { yield return BuildTfsChangeset(changesets[i], remote); changesets[i] = null; } } while (changesets.Length == batchCount); }