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