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);
}
