/// <summary>
/// Downloads the source for the specified changeset.
/// </summary>
/// <param name="projectSourcePath">The project source path.</param>
/// <param name="changesetID">The ID of the changeset to be downloaded.</param>
/// <param name="workspaceName">The name of the local workspace.</param>
/// <param name="localWorkspacePath">The local workspace path.</param>
public void DownloadSource(string projectSourcePath, int changesetID, string workspaceName, string localWorkspacePath)
{
if (string.IsNullOrEmpty(projectSourcePath))
{
throw new ArgumentNullException(projectSourcePath);
}
Workspace workspace = null;
try
{
workspace = SourceControl.GetWorkspace(workspaceName,
SourceControl.AuthorizedUser);
}
catch (WorkspaceNotFoundException)
{
workspace = SourceControl.CreateWorkspace(workspaceName,
SourceControl.AuthorizedUser);
}
var serverFolder = String.Format(CultureInfo.InvariantCulture, "$/{0}/", projectSourcePath.TrimEnd('/'));
var workingFolder = new WorkingFolder(serverFolder, localWorkspacePath);
// Create a workspace mapping
workspace.CreateMapping(workingFolder);
if (!workspace.HasReadPermission)
{
throw new SecurityException(
String.Format(CultureInfo.InvariantCulture, Resources.ReadPermissionException,
SourceControl.AuthorizedUser, serverFolder));
}
workspace.Get(new ChangesetVersionSpec(changesetID), GetOptions.GetAll);
}
private static void Go(Repository repository, Commit commit)
{
Workspace workspace = null;
WorkingFolder folder = null;
string tempPath = null;
try
{
workspace = CreateWorkspace();
tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(tempPath);
Console.WriteLine("Creating scratch TFS enlistment");
folder = AddMapping(workspace, tempPath);
Console.WriteLine("Building Git Tree");
var workspaceTree = GitUtils.CreateTreeFromWorkspace(workspace, tempPath, repository.ObjectDatabase);
Console.WriteLine("Calculating diff");
var treeChanges = repository.Diff.Compare <TreeChanges>(workspaceTree, commit.Tree, compareOptions: new LibGit2Sharp.CompareOptions()
{
Similarity = SimilarityOptions.Renames
});
Console.WriteLine("Applying commit to workspace");
var commitPortUtil = new CommitPortUtil(repository, workspace, tempPath);
commitPortUtil.ApplyGitChangeToWorkspace(treeChanges);
var shelvesetName = string.Format("shelve-commit-{0}", commit.Sha);
Console.WriteLine("Shelving to {0}", shelvesetName);
ShelveChanges(workspace, shelvesetName, commit);
}
finally
{
if (workspace != null)
{
Console.WriteLine("Cleaning up TFS enlistment");
if (folder != null)
{
workspace.DeleteMapping(folder);
}
workspace.Delete();
}
if (tempPath != null && Directory.Exists(tempPath))
{
Console.WriteLine("Cleaning up temp files");
try
{
Directory.Delete(tempPath, recursive: true);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
}
}
}
}
/// <summary>
/// 获取工作区
/// </summary>
/// <param name="vsPath"></param>
/// <returns></returns>
private WorkingFolder GetWorkspace(string vsPath)
{
WorkingFolder workingFolder = null;
//获取工作区
Workspace[] workspaces = version.QueryWorkspaces(null, version.AuthenticatedUser,
Environment.MachineName); //查询工作区
foreach (var workspace in workspaces)
{
if (workspace.Folders.Count() > 0)
{
foreach (var folder in workspace.Folders)
{
if (vsPath.IndexOf(folder.LocalItem) == 0)
{
ws = workspace;
workingFolder = folder;
break;
}
}
}
else
{
throw new Exception("请确认解决方案连接了TFS！");
}
}
if (workingFolder == null || ws == null)
{
throw new Exception("请确认TFS工作区的正确性！");
}
return(workingFolder);
}
public void Save()
{
if (!HasNoFileContents())
{
string filePath = Path.Combine(Settings.Default.ConfigurationsPath, _filename);
if (Settings.Default.ConfigurationsPath.StartsWith("$"))
{
VersionControlServer versionControlServer = Connection.GetConnection().TfsTeamProjectCollection.GetService <VersionControlServer>();
Workspace ws = versionControlServer.QueryWorkspaces(null, versionControlServer.AuthorizedUser, Environment.MachineName, WorkspacePermissions.CheckIn).FirstOrDefault();
if (ws == null) // Create Temp Workspace
{
ws = versionControlServer.CreateWorkspace(Resources.WorkspaceName, versionControlServer.AuthorizedUser, Resources.AutomaticWorkspaceToManageWorkItemFieldMappings,
new WorkingFolder[] { new WorkingFolder(Settings.Default.ConfigurationsPath, Settings.SettingsFolderPath, WorkingFolderType.Map, RecursionType.OneLevel) });
}
GetStatus gs = ws.Get(new string[] { Settings.Default.ConfigurationsPath }, VersionSpec.Latest, RecursionType.OneLevel, GetOptions.None);
if (gs.NoActionNeeded)
{
WorkingFolder wf = ws.GetWorkingFolderForServerItem(filePath);
SaveFile(wf.LocalItem);
int pendingStatus = versionControlServer.ServerItemExists(wf.ServerItem, ItemType.File) ? ws.PendEdit(wf.ServerItem) : ws.PendAdd(wf.ServerItem);
int checkInStatus = ws.CheckIn(ws.GetPendingChanges(wf.ServerItem), Resources.SettingsFileCheckInComment);
}
else
{
} // TODO Error Saving
}
else
{
SaveFile(filePath);
}
}
IsDirty = false;
}
//public static Version GetBranchVersion(this WorkingFolder workingFolder)
//{
// Version result = null;
// var name = workingFolder.BranchName();
// if (name.Contains("Release_"))
// name = name.Replace("Release_", "");
// if (name != "Head" && Version.TryParse(name, out result))
// return result;
// string lastBranch = CheckoutAndBuildLogic.Instance.GetOldCPReleaseBranchNames().OrderBy(s => s).LastOrDefault();
// if (!string.IsNullOrEmpty(lastBranch))
// {
// string releasename = lastBranch.Split('/').LastOrDefault(s => !s.ToLower().EndsWith("solution"));
// if (!string.IsNullOrEmpty(releasename))
// {
// if (releasename.Contains("Release"))
// releasename = releasename.Replace("Release_", "");
// if (Version.TryParse(releasename, out result))
// {
// return new Version(result.Major, result.Minor + 1);
// }
// }
// }
// return null;
//}
public static string BranchName(this WorkingFolder workingFolder)
{
if (workingFolder.ServerItem.ToLower().Contains("/features/"))
{ // FB Branch
string name = workingFolder.ServerItem.Split('/')[3];
return(name);
}
else
{
string name = workingFolder.ServerItem.Split('/').LastOrDefault(s => !s.ToLower().EndsWith("solution"));
if (!string.IsNullOrEmpty(name))
{
if (name.ToUpper() == "MSDTC")
{
return(name);
}
if (name.Contains("Release"))
{
return(name);
}
return("Head");
}
}
return("Head");
}
private async Task <GetStatus> GetLatestVersionAsync(WorkingFolder workFolder, IServiceSettings settings, VersionSpec versionSpec,
CancellationToken cancellationToken = default(CancellationToken))
{
ItemSpec itemSpec = new ItemSpec(workFolder.ServerItem, RecursionType.Full);
return(await GetLatestVersionAsync(itemSpec, versionSpec, settings, null, cancellationToken));
}
public void UnmapWorkfolder(Workspace workspace, string item)
{
if (!VersionControlPath.IsServerItem(item))
{
item = Path.GetFullPath(item);
}
List <WorkingFolder> folders = new List <WorkingFolder>(workspace.Folders);
string msg = String.Empty;
for (int i = 0; i < folders.Count; ++i)
{
WorkingFolder folder = folders[i];
if (item == folder.ServerItem || item == folder.LocalItem)
{
msg = String.Format("Removed: {0} => {1}",
folder.ServerItem, folder.LocalItem);
folders.RemoveAt(i);
break;
}
}
workspace.Update(workspace.Name, workspace.Comment, folders.ToArray());
if (!String.IsNullOrEmpty(msg))
{
Console.WriteLine(msg);
}
}
public static bool ChangeMapping(Workspace workspace, TfsContext tfs, WorkingFolder folder)
{
if (workspace == null)
{
return(false);
}
var dlg = new CreateMappingDialog(tfs, workspace, folder.ServerItem, folder.LocalItem)
{
Text = "Change Mapping",
ServerItem = folder.ServerItem,
LocalItem = folder.LocalItem
};
if (dlg.ShowDialog() == DialogResult.OK)
{
string serverItem = dlg.ServerItem;
string localItem = dlg.LocalItem;
if (serverItem.StartsWith("$"))
{
try
{
workspace.DeleteMapping(folder);
workspace.Map(serverItem, localItem);
return(true);
}
catch (Exception)
{
return(false);
}
}
return(false);
}
return(false);
}
internal MainWindowViewModel(
WorkingFolder workingFolder,
WindowOwner owner,
IRepositoryCommands repositoryCommands,
IRemoteService remoteService,
ICommitsService commitsService,
ILatestVersionService latestVersionService,
IStartInstanceService startInstanceService,
IRecentReposService recentReposService,
IGitInfoService gitInfoService,
IMessage message,
IMainWindowService mainWindowService,
MainWindowIpcService mainWindowIpcService,
RepositoryViewModel repositoryViewModel)
{
this.workingFolder = workingFolder;
this.owner = owner;
this.repositoryCommands = repositoryCommands;
this.remoteService = remoteService;
this.commitsService = commitsService;
this.startInstanceService = startInstanceService;
this.recentReposService = recentReposService;
this.gitInfoService = gitInfoService;
this.message = message;
this.mainWindowService = mainWindowService;
this.mainWindowIpcService = mainWindowIpcService;
RepositoryViewModel = repositoryViewModel;
workingFolder.OnChange += (s, e) => Notify(nameof(WorkingFolder));
latestVersionService.OnNewVersionAvailable += (s, e) => IsNewVersionVisible = true;
latestVersionService.StartCheckForLatestVersion();
IsRepoView = true;
}
private void Reset()
{
backgroundWorker.CancelAsync();
m_toExpand.Clear();
treeView.BeginUpdate();
treeView.Nodes.Clear();
TreeNodeLocalItem root = AttachTreeNode(null, m_workspace != null ? m_workspace.Name : "wat?", new TempItemSet.TempItem());
treeView.SelectedNode = root;
if (m_workspace != null)
{
var roots = WorkingFolder.GetWorkspaceRoots(m_workspace.Folders);
List <ItemSpec> specs = new List <ItemSpec>();
foreach (string s in roots)
{
specs.Add(new ItemSpec(s, RecursionType.None));
}
var items = m_workspace.GetExtendedItems(specs.ToArray(), DeletedState.Any, ItemType.Folder);
foreach (var i in items)
{
foreach (var j in i)
{
AttachTreeNode(root, j.LocalItem, new TempItemSet.TempItem {
LocalPath = j.LocalItem, ServerItem = j
});
}
}
}
treeView.EndUpdate();
}
public static void UnCloak(Workspace workspace, string serverItem)
{
string localItem = null;
WorkingFolder mapping = null;
foreach (WorkingFolder workingFolder in workspace.Folders)
{
if (workingFolder.Type == WorkingFolderType.Cloak)
{
if (serverItem != null && (VersionControlPath.Equals(workingFolder.ServerItem, serverItem) || VersionControlPath.Equals(workingFolder.DisplayServerItem, serverItem)))
{
localItem = workingFolder.LocalItem;
mapping = workingFolder;
break;
}
if (localItem != null && Microsoft.TeamFoundation.Common.FileSpec.Equals(workingFolder.LocalItem, localItem))
{
serverItem = workingFolder.ServerItem;
mapping = workingFolder;
break;
}
}
}
if (mapping != null)
{
workspace.DeleteMapping(mapping);
}
}
private static WorkingFolder AddMapping(Workspace workspace, string tempPath)
{
var folder = new WorkingFolder("$/Roslyn/Main/Open", tempPath);
workspace.CreateMapping(folder);
workspace.Get();
return(folder);
}
public LinkService(
WorkingFolder workingFolder,
IMessageService messageService)
{
this.workingFolder = workingFolder;
this.messageService = messageService;
workingFolder.OnChange += (s, e) => initialized = false;
}
public override bool Read()
{
bool read;
if (this.first)
{
this.first = false;
var parameters = this.command.Parameters;
string workspace = Database.GetValueOrDefault <string>(parameters["workspace"].Value);
string owner = Database.GetValueOrDefault <string>(parameters["owner"].Value);
string computer = Database.GetValueOrDefault <string>(parameters["computer"].Value);
this.workspaces = this.command.Connection.VersionControlServer.QueryWorkspaces(workspace, owner, computer);
this.enumerator = AsEnumerable(this.workspaces).GetEnumerator();
}
var moveNext = this.enumerator.MoveNext();
if (moveNext)
{
var pair = this.enumerator.Current;
Workspace workspace = this.workspaces[pair.Item1];
var folderIndex = pair.Item2;
var values = new object[]
{
workspace.Computer,
workspace.OwnerName,
workspace.Name,
workspace.Comment,
workspace.DisplayName,
null,
null,
null,
null
};
if (folderIndex >= 0)
{
WorkingFolder folder = workspace.Folders[folderIndex];
values[5] = folder.Type.ToString();
values[6] = folder.IsCloaked;
values[7] = folder.ServerItem;
values[8] = folder.LocalItem;
}
this.Values = values;
read = true;
this.index++;
}
else
{
read = false;
}
return(read);
}
public void getLatest()
{
if (skipGetLatest)
{
log("get latest ignored");
return;
}
if (!System.IO.Directory.Exists(workingDirectory + branch))
{
System.IO.Directory.CreateDirectory(workingDirectory + branch);
}
this.clearFolder(workingDirectory + branch);
using (TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(collectionUrl)))
{
var vsStore = tpc.GetService <VersionControlServer>();
string workingFolder = workingDirectory + branch;
Workspace wsp = vsStore.TryGetWorkspace(workingFolder);
string tfsPath = tfsRoot + (branch == "trunc" || branch == "trunk" ? branch : "branches/" + branch);
if (wsp == null)
{
WorkingFolder wrkFolder = new WorkingFolder(tfsPath,
workingFolder, WorkingFolderType.Map, RecursionType.Full);
wsp = vsStore.CreateWorkspace(workspaceName + branch,
userid,
description,
new WorkingFolder[] { wrkFolder });
}
ItemSet items = vsStore.GetItems(workingFolder, VersionSpec.Latest, RecursionType.Full);
foreach (Item item in items.Items)
{
string relativePath = item.ServerItem.Replace(tfsPath, workingFolder);
if (item.ItemType == ItemType.Folder)
{
Directory.CreateDirectory(relativePath);
}
else
{
item.DownloadFile(relativePath);
log(relativePath);
}
}
}
}
protected override void Execute(CodeActivityContext context)
{
#region Workflow Arguments
// The TFS source location of the file to get
var fileToGet = context.GetValue(FileToGet);
// The current workspace - used to create a new workspace for the get
var workspace = context.GetValue(Workspace);
// The local build directory
var buildDirectory = context.GetValue(BuildDirectory);
var destinationSubfolderName = context.GetValue(DestinationSubfolderName);
#endregion
// File and path
var versionFileDirectory = string.Format("{0}\\{1}", buildDirectory, destinationSubfolderName);
var filename = Path.GetFileName(fileToGet);
if (filename == null)
{
throw new ArgumentException("Filename must not be null");
}
var fullPathToFile = Path.Combine(versionFileDirectory, filename);
// Write to the log
context.WriteBuildMessage(string.Format("Getting file from Source: {0}", fileToGet), BuildMessageImportance.High);
// Create workspace and working folder
var tempWorkspace = workspace.VersionControlServer.CreateWorkspace("NuGetterTemp");
var workingFolder = new WorkingFolder(fileToGet, fullPathToFile);
// Map the workspace
tempWorkspace.CreateMapping(workingFolder);
// Get the file
var request = new GetRequest(new ItemSpec(fileToGet, RecursionType.None), VersionSpec.Latest);
var status = tempWorkspace.Get(request, GetOptions.GetAll | GetOptions.Overwrite);
if (!status.NoActionNeeded)
{
foreach (var failure in status.GetFailures())
{
context.WriteBuildMessage(string.Format("Failed to get file from source: {0} - {1}", fileToGet, failure.GetFormattedMessage()), BuildMessageImportance.High);
}
}
// Return the value back to the workflow
context.SetValue(FullPathToFile, fullPathToFile);
// Get rid of the workspace
tempWorkspace.Delete();
}
public static bool ShowCheckinDialog(Workspace workspace = null, WorkingFolder workFolder = null, int selectedTabIndex = 0)
{
if (workspace == null)
{
workspace = TfsContext.SelectedWorkspace;
}
var checkIndialog = new CheckInDialog(TfsContext.VersionControlServer, workFolder);
return(checkIndialog.ShowDialog(workspace, selectedTabIndex));
}
/// <summary>
/// Gets the working folder.
/// </summary>
/// <param name="path">The path.</param>
/// <returns></returns>
/// <remarks>Documented by CFI, 2011-01-05</remarks>
internal WorkingFolder GetWorkingFolder(string path)
{
if (workingFolders.ContainsKey(path))
{
return(workingFolders[path]);
}
WorkingFolder wf = GetWorkspace(path).Folders.FirstOrDefault(f => f.LocalItem != null && path.StartsWith(f.LocalItem));
workingFolders[path] = wf;
return(wf);
}
internal static void OpenSolutionWithWorkspace(Workspace workspace, string serverItem, VersionSpec spec)
{
serverItem = VersionControlPath.GetFullPath(serverItem);
WorkingFolder folderForServerItem1;
try
{
folderForServerItem1 = workspace.TryGetWorkingFolderForServerItem(serverItem);
}
catch (Exception ex)
{
Output.Exception(ex);
return;
}
if (folderForServerItem1 != null)
{
if (folderForServerItem1.IsCloaked)
{
int num1 = (int)Error(UIHost.DefaultParentWindow, GuiResources.Format("SolutionIsCloaked", (object)VersionControlPath.GetFileName(serverItem)), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
else
{
try
{
VssProvider.OpenFromSCC(serverItem, FileSpec.GetDirectoryName(folderForServerItem1.LocalItem), spec.DisplayString, VersionControlOpenFromSccOverwrite.openscc_open_local_version);
}
catch (Exception ex)
{
Output.Exception(ex);
}
}
}
else
{
string folderName = VersionControlPath.GetFolderName(serverItem);
using (var dialogSetLocalFolder = (Form)TeamControlFactory.CreateDialogSetLocalFolder(workspace, folderName))
{
if (UIHost.ShowModalDialog((Form)dialogSetLocalFolder) != DialogResult.OK)
{
return;
}
}
try
{
WorkingFolder folderForServerItem2 = workspace.GetWorkingFolderForServerItem(serverItem);
VssProvider.OpenFromSCC(serverItem, FileSpec.GetDirectoryName(folderForServerItem2.LocalItem), spec.DisplayString, VersionControlOpenFromSccOverwrite.openscc_open_local_version);
}
catch (Exception ex)
{
Output.Exception(ex);
}
}
}
public ThemeService(
WorkingFolder workingFolder)
{
this.workingFolder = workingFolder;
LoadTheme();
customBranchBrushes = new Lazy <IDictionary <string, Brush> >(GetCustomBranchColors);
workingFolder.OnChange += (s, e) =>
customBranchBrushes = new Lazy <IDictionary <string, Brush> >(GetCustomBranchColors);
}
public DiffService(
WorkingFolder workingFolder,
IGitDiffService gitDiffService,
IGitStatusService gitStatusService,
IGitDiffParser diffParser,
ICmd cmd)
{
this.workingFolder = workingFolder;
this.gitDiffService = gitDiffService;
this.gitStatusService = gitStatusService;
this.diffParser = diffParser;
this.cmd = cmd;
}
public GitCommitBranchNameService(
WorkingFolder workingFolder,
Lazy <IRepositoryMgr> repositoryMgr,
IGitFetchService gitFetchService,
IGitNotesService gitNotesService,
IGitPushService gitPushService)
{
this.workingFolder = workingFolder;
this.repositoryMgr = repositoryMgr;
this.gitFetchService = gitFetchService;
this.gitNotesService = gitNotesService;
this.gitPushService = gitPushService;
}
internal App(
ICommandLine commandLine,
IDiffService diffService,
IThemeService themeService,
IInstaller installer,
Lazy <MainWindow> mainWindow,
WorkingFolder workingFolder)
{
this.commandLine = commandLine;
this.diffService = diffService;
this.themeService = themeService;
this.installer = installer;
this.mainWindow = mainWindow;
this.workingFolder = workingFolder;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public WorkingFolderViewModel(WorkingFolder workingFolder, IServiceProvider serviceProvider)
: base(serviceProvider)
{
IncludeToggleCommand = new DelegateCommand <object>("Include/Exclude", ToggleSelectedProjects, o => SelectedProjects.Any())
{
IconImage = Images.arrow_Reorder_16xSM.ToImageSource()
};
AddSolutionCommand = new DelegateCommand <object>("Add Project/Solution...", AddSolution)
{
IconImage = Images.Solution_8308.ToImageSource()
};
WorkingFolder = workingFolder;
selectedProjects = new ObservableCollection <ProjectViewModel>();
selectedProjects.CollectionChanged += SelectionChanged;
}
private string GetTargetBranchName()
{
string retVal;
WorkingFolder folder = m_TagetBranchComboBox.SelectedItem as WorkingFolder;
if (folder != null)
{
retVal = folder.ServerItem;
}
else
{
retVal = m_ShelveComboBox.Text;
}
return(retVal);
}
private bool ShouldDeleteTypeLibs(WorkingFolder folder)
{
foreach (var libId in typeLibIds)
{
string path;
var regpath = "TypeLib\\{" + libId + "}\\4.5\\0\\win32";
if (RegistryHelper.TryReadValue <string>(RegistryHive.ClassesRoot, regpath, "", RegistryValueKind.String, out path))
{
if (folder == null || !CPFileHelper.IsSubPathOf(path, folder.LocalItem))
{
return(true);
}
}
}
return(false);
}
private string GetIntegrationName(WorkingFolder workingFolder, string prefix = "_last-")
{
string res = "Head";
var splits = workingFolder.ServerItem.Split(new[] { "Features" }, StringSplitOptions.None);
if (splits.Length == 2)
{
var items = splits[1].Split('/').Where(s => !string.IsNullOrEmpty(s));
res = items.FirstOrDefault();
}
if (!string.IsNullOrEmpty(res))
{
return($"{prefix}{res}");
}
return(null);
}
public static bool IsFolderCloaked(Workspace workspace, string serverItem)
{
if (workspace != null)
{
WorkingFolder folder = workspace.TryGetWorkingFolderForServerItem(serverItem);
if (folder == null)
{
return(false);
}
if (folder.IsCloaked)
{
return(true);
}
}
return(false);
}
protected override void EndProcessing()
{
//make sure it exists
var newPath = WorkingFolder.Combine(Path);
try
{
new CmisNavigation(CmisSession).GetFolder(newPath);
}
catch (CmisBaseException ex)
{
ThrowTerminatingError(new ErrorRecord(ex, "InvalidCmisDirectory",
ErrorCategory.ObjectNotFound, newPath));
}
SetWorkingFolder(newPath);
WriteObject(newPath.ToString());
}
/// <summary>
/// Tfs初始化
/// </summary>
/// <param name="vsPath"></param>
/// <param name="fileName"></param>
public TFSHelper(string vsPath, string fileName)
{
//读取VS中的tfs地址
string tpcURL = GetTfsUrl(vsPath, fileName);
//登录服务器指定tfs项目
pjc = new TfsTeamProjectCollection(new Uri(tpcURL));
//登录服务前，如果没有登录过会弹出提示框登录，登录过会直接跳过
pjc.EnsureAuthenticated();
version = pjc.GetService <VersionControlServer>();
this.vsPath = vsPath;
//获取工作区
wf = GetWorkspace(vsPath);
}