/// <summary>
/// 'Pends' a delete of a folder and its contents that was previously
/// checked-in and then commits that deletion to the repository.
/// </summary>
/// <param name="workspace">Version control workspace to use when
/// deleting the folder and its contents.</param>
/// <param name="newFilename">Full path to the folder to delete</param>
/// <exception cref="SecurityException">If the user doesn't have
/// check-in permission for the specified <paramref name="workspace"/>.</exception>
/// <exception cref="IOException">If there's a problem creating the file.</exception>
/// <exception cref="VersionControlException">If </exception>
private static void DeleteFolder(Workspace workspace, String newFolder)
{
Debug.Assert(workspace != null);
Debug.Assert(!String.IsNullOrEmpty(newFolder));
try
{
// Delete the items
workspace.PendDelete(workspace.GetServerItemForLocalItem(newFolder), RecursionType.Full);
var pendingDeletes = workspace.GetPendingChanges();
if (pendingDeletes.Length > 0)
{
workspace.CheckIn(pendingDeletes, "Clean up!");
}
}
catch (VersionControlException ex)
{
Console.Error.WriteLine("Error deleting file: {0}", ex.Message);
throw;
}
}
public bool AddToTFVC(string[] _files, WorkItem _wi, Workspace _ws)
{
try
{
_ws.Get();
// Now add everything.
_ws.PendAdd(_files, false);
WorkItemCheckinInfo[] _wici = new WorkItemCheckinInfo[1];
_wici[0] = new WorkItemCheckinInfo(_wi, WorkItemCheckinAction.Associate);
if (_ws.CheckIn(_ws.GetPendingChanges(), null, null, _wici, null) > 0)
{
_ws.Delete();
return true;
}
else
{
return false;
}
}
catch
{
return false;
}
}
public void Execute(TeamFoundationWorkspace ws)
{
if (ws == null)
{
AppOutput.ConsoleWriteLine("---- Invalide ws config");
}
var files = GetLocalFiles();
AppOutput.ConsoleWriteLine("Tfs inclider: filesFound: " + files.Count());
var paddingChanges = ws.GetPendingChanges().Select(p => p.LocalItem);
foreach (var file in files)
{
var serverPath = ws.TryGetServerItemForLocalItem(file);
var serverItemExists = ws.VersionControlServer.ServerItemExists(serverPath, ItemType.File);
if (!serverItemExists && !paddingChanges.Contains(file))
{
ws.PendAdd(file);
AppOutput.ConsoleWriteLine(" Exluded file: " + file);
}
}
AppOutput.ConsoleWriteLine("Finished");
}
private void FillStore(List <ExtendedItem> items, Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
fileStore.Clear();
List <ItemSpec> itemSpecs = new List <ItemSpec>();
foreach (var item in items)
{
itemSpecs.Add(new ItemSpec(item.ServerPath, item.ItemType == ItemType.File ? RecursionType.None : RecursionType.Full));
}
var pendingChanges = workspace.GetPendingChanges(itemSpecs);
foreach (var pendingChange in pendingChanges)
{
var row = fileStore.AddRow();
fileStore.SetValue(row, isCheckedField, true);
var path = (VersionControlPath)pendingChange.ServerItem;
fileStore.SetValue(row, nameField, path.ItemName);
fileStore.SetValue(row, changesField, pendingChange.ChangeType.ToString());
fileStore.SetValue(row, folderField, path.ParentPath);
fileStore.SetValue(row, changeField, pendingChange);
}
}
/// <summary>
/// 'Pends' a change to a file that was previously checked-in and then checks
/// that change into the repository.
/// </summary>
/// <param name="workspace">Version control workspace to use when
/// changing the folder and file.</param>
/// <param name="newFilename">Full path to the file to change</param>
/// <exception cref="SecurityException">If the user doesn't have
/// check-in permission for the specified <paramref name="workspace"/>.</exception>
/// <exception cref="IOException">If there's a problem creating the file.</exception>
/// <exception cref="VersionControlException">If </exception>
private static void ModifyFile(Workspace workspace, String newFilename)
{
Debug.Assert(workspace != null);
Debug.Assert(!String.IsNullOrEmpty(newFilename));
try
{
// Checkout and modify the file
workspace.PendEdit(newFilename);
using (var streamWriter = new StreamWriter(newFilename))
{
streamWriter.WriteLine("Revision 2");
}
// Get the pending change and check in the new revision.
var pendingChanges = workspace.GetPendingChanges();
int changesetForChange = workspace.CheckIn(pendingChanges, "Modified file contents");
Console.WriteLine("Checked in changeset {0}", changesetForChange);
}
catch (IOException ex)
{
Console.Error.WriteLine("Error writing {1}: {0}", ex.Message, newFilename);
throw;
}
catch (VersionControlException ex)
{
Console.Error.WriteLine("Error modifying file: {0}", ex.Message);
throw;
}
}
/// <summary>
/// 'Pends' a branch of a file that was previously checked-in and then checks
/// that branch into the repository.
/// </summary>
/// <param name="workspace">Version control workspace to use when
/// branching the folder and file.</param>
/// <param name="newFilename">Full path to the file to branch</param>
/// <exception cref="VersionControlException">If there's a problem performing
/// the branch operation.</exception>
private static void BranchFile(Workspace workspace, String newFilename)
{
Debug.Assert(workspace != null);
Debug.Assert(!String.IsNullOrEmpty(newFilename));
String branchedFilename = Path.Combine(Path.GetDirectoryName(newFilename),
Path.GetFileNameWithoutExtension(newFilename)) + "-branch" +
Path.GetExtension(newFilename);
workspace.PendBranch(newFilename, branchedFilename, VersionSpec.Latest,
LockLevel.Checkin, true);
var pendingChanges = workspace.GetPendingChanges();
int changesetForBranch = workspace.CheckIn(pendingChanges, "Branched file");
Console.WriteLine("Branched {0} to {1} in changeset {2}", newFilename,
branchedFilename, changesetForBranch);
}
/// <summary>
/// 'Pends' the add of a new folder and file and then checks it into the
/// repository.
/// </summary>
/// <param name="workspace">Version control workspace to use when
/// adding the folder and file.</param>
/// <param name="newFilename">Full path to the file to add (the path
/// of the folder will be derived from the file's path.</param>
/// <exception cref="SecurityException">If the user doesn't have
/// check-in permission for the specified <paramref name="workspace"/>.</exception>
/// <exception cref="IOException">If there's a problem creating the file.</exception>
/// <exception cref="VersionControlException">If </exception>
private static void AddNewFile(Workspace workspace, String newFilename)
{
Debug.Assert(workspace != null);
Debug.Assert(!String.IsNullOrEmpty(newFilename));
Debug.Assert(!File.Exists(newFilename));
if (!workspace.HasCheckInPermission)
{
throw new SecurityException(
String.Format("{0} does not have check-in permission for workspace: {1}",
workspace.VersionControlServer.AuthenticatedUser,
workspace.DisplayName));
}
try
{
// create the new file
using (var streamWriter = new StreamWriter(newFilename))
{
streamWriter.WriteLine("Revision 1");
}
// Now pend the add of our new folder and file
workspace.PendAdd(Path.GetDirectoryName(newFilename), true);
// Show our pending changes
var pendingAdds = new List<PendingChange>((IEnumerable<PendingChange>)
workspace.GetPendingChanges());
pendingAdds.ForEach(delegate(PendingChange add)
{
Console.WriteLine("\t{1}: {0}",
add.LocalItem, PendingChange.GetLocalizedStringForChangeType(add.ChangeType));
});
// Checkin the items we added
int changesetForAdd = workspace.CheckIn(pendingAdds.ToArray(), "Initial check-in");
Console.WriteLine("Checked in changeset {0}", changesetForAdd);
}
catch (IOException ex)
{
Console.Error.WriteLine("Error writing {1}: {0}", ex.Message, newFilename);
throw;
}
catch (VersionControlException ex)
{
Console.Error.WriteLine("Error adding file: {0}", ex.Message);
throw;
}
}
public bool TryGetPendingChanges(out PendingChange[] pendingChanges, Workspace workspace, string[] items)
{
try
{
pendingChanges = workspace.GetPendingChanges(items);
return true;
}
catch (Exception ex)
{
this.Logger().DebugException(ex);
LastException = ex;
}
pendingChanges = null;
return false;
}
/// <summary>
///
/// </summary>
/// <param name="service"></param>
/// <param name="workspace"></param>
/// <param name="force">True when the user manually initiates a ShelveSet via the Team menu or mapped shortcut key.</param>
private void CreateShelveset(VersionControlServer service, Workspace workspace, bool force)
{
// Build event args for notification create shelveset result
var autoShelveEventArg = new ShelvesetCreatedEventArgs();
try
{
// If there are no pending changes that have changed since the last shelveset then there is nothing to do
bool isDelta = false;
var pendingChanges = workspace.GetPendingChanges();
int numPending = pendingChanges.Count();
if (!force && numPending > 0)
{
// Compare numPending to numItemsShelved; Force shelveset if they differ
// Otherwise, resort to comparing file HashValues
var lastShelveset = GetPastShelvesets(service, workspace).FirstOrDefault();
var shelvedChanges = service.QueryShelvedChanges(lastShelveset)[0].PendingChanges;
int numItemsShelved = lastShelveset == null ? 0 : shelvedChanges.Count();
isDelta = (numPending != numItemsShelved) || pendingChanges.DifferFrom(shelvedChanges);
}
autoShelveEventArg.ShelvesetChangeCount = (force || isDelta) ? numPending : 0;
if (force || isDelta)
{
// Build a new, valid shelve set name
var setname = string.Format(ShelvesetName, workspace.Name, workspace.OwnerName, DateTime.Now, workspace.OwnerName.GetDomain(), workspace.OwnerName.GetLogin());
setname = CleanShelvesetName(setname);
// Actually create a new Shelveset
var shelveset = new Shelveset(service, setname, workspace.OwnerName);
autoShelveEventArg.ShelvesetName = setname;
shelveset.Comment = string.Format("Shelved by {0}. {1} items", _extensionName, numPending);
workspace.Shelve(shelveset, pendingChanges, ShelvingOptions.Replace);
// Clean up past Shelvesets
if (MaximumShelvesets > 0)
{
foreach (var set in GetPastShelvesets(service, workspace).Skip(MaximumShelvesets))
{
service.DeleteShelveset(set);
autoShelveEventArg.ShelvesetsPurgeCount++;
}
}
}
}
catch (Exception ex)
{
_tfsExt = null; // Force re-init on next attempt
autoShelveEventArg.ExecutionException = ex;
}
// Fire event for each VS instance to report results
if (OnShelvesetCreated != null)
{
OnShelvesetCreated(this, autoShelveEventArg);
}
}
/// <summary>
/// Check In all pending changes within the workspace
/// </summary>
/// <param name="_ws">
/// workspace with pending changes
/// </param>
/// <returns>
/// true if check-in is successful
/// </returns>
public bool CheckIn(Workspace _ws)
{
try
{
_ws.CheckIn(_ws.GetPendingChanges(), null);
return true;
}
catch
{
return false;
}
}
private static List<PendingChange> GetPendingChangesByFile(List<MergeRelation> mergeRelationships, string targetBranch, Workspace workspace)
{
var itemSpecs = new List<ItemSpec>();
foreach (var mergeRelationship in mergeRelationships)
{
if (mergeRelationship.Target.StartsWith(targetBranch))
{
var recursionType = CalculateRecursionType(mergeRelationship);
itemSpecs.Add(new ItemSpec(mergeRelationship.Target, recursionType));
}
}
return workspace.GetPendingChanges(itemSpecs.ToArray()).ToList();
}
public bool HasPendingChanges(Workspace workspace, string localItem)
{
return workspace.GetPendingChanges(localItem).Length != 0;
}
public bool HasPendingChanges(Workspace workspace)
{
return workspace.GetPendingChanges().Length != 0;
}
public static bool IsCheckedOut(Workspace workspace, string path)
{
if (workspace == null)
{
return false;
}
try
{
foreach (PendingChange change in workspace.GetPendingChanges(path))
{
if ((change.ChangeType & (ChangeType.Edit | ChangeType.Add)) > 0)
{
return true;
}
}
}
catch
{
}
return false;
}
