public GettingDialog(VersionControlServer vcs, Workspace workspace, GetRequest[] requests)
: base("Progress")
{
VBox.Spacing = 10;
VBox.Add(new Label("Getting files from the server..."));
progressBar = new ProgressBar();
VBox.Add(progressBar);
fileLabel = new Label("");
VBox.Add(fileLabel);
AddCloseButton("Cancel");
DefaultResponse = ResponseType.Cancel;
ShowAll();
getLatestList.Clear();
vcs.Getting += MyGettingEventHandler;
GetStatus status = workspace.Get(requests, GetOptions.GetAll|GetOptions.Overwrite);
foreach (string file in getLatestList)
{
Console.WriteLine(file);
Pulse("Setting permissions: " + file);
if (! FileTypeDatabase.ShouldBeExecutable(file)) continue;
FileType.MakeExecutable(file);
}
}
public ShelveWindow(ObservableCollection<changeItem> changeCollection, Workspace activeWorkspace)
{
InitializeComponent();
this.DataContext = this;
shelveCollection = changeCollection;
this.activeWorkspace = activeWorkspace;
}
public ChangesetVisitEventArgs(Changeset changeset, IEnumerable<string> localizedServerItems, Workspace workspace)
{
LocalizedServerItems = localizedServerItems;
Workspace = workspace;
Changeset = changeset;
Committer = changeset.Committer;
}
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");
}
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;
}
}
internal ConflictEventArgs(Workspace workspace, string message,
string serverItem)
{
this.workspace = workspace;
this.message = message;
this.serverItem = serverItem;
}
public void FixtureSetUp()
{
tfsUrl = Environment.GetEnvironmentVariable("TFS_URL");
if (String.IsNullOrEmpty(tfsUrl))
{
Console.WriteLine("Warning: Environment variable TFS_URL not set.");
Console.WriteLine(" Some tests cannot be executed without TFS_URL.");
return;
}
string username = Environment.GetEnvironmentVariable("TFS_USERNAME");
if (String.IsNullOrEmpty(username))
{
Console.WriteLine("Warning: No TFS user credentials specified.");
return;
}
credentials = new NetworkCredential(username,
Environment.GetEnvironmentVariable("TFS_PASSWORD"),
Environment.GetEnvironmentVariable("TFS_DOMAIN"));
// need TFS_ envvars for this test
if (String.IsNullOrEmpty(tfsUrl)) return;
TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
versionControlServer = (VersionControlServer) tfs.GetService(typeof(VersionControlServer));
workspace = versionControlServer.CreateWorkspace("WorkspaceTest",
Environment.GetEnvironmentVariable("TFS_USERNAME"));
}
public TfsWorkspace(Workspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote)
{
_workspace = workspace;
_contextVersion = contextVersion;
_remote = remote;
_localDirectory = localDirectory;
_stdout = stdout;
}
public void Dispose()
{
if (_workspace != null)
{
_workspace.Delete();
_workspace = null;
}
}
internal GettingEventArgs(Workspace workspace, GetOperation operation)
{
this.workspace = workspace;
this.operation = operation;
if (operation.ChangeType == ChangeType.Delete)
status = OperationStatus.Deleting;
else status = OperationStatus.Getting;
}
public WorkspaceServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, ProjectCollectionServiceModel projectCollectionServiceModel, Workspace workspace)
: base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
{
_projectCollectionServiceModel = projectCollectionServiceModel;
Workspace = workspace;
var versionControlServer = _projectCollectionServiceModel.TfsTeamProjectCollection.GetVersionControlServer();
this.Logger().Debug("VersionControlServer - WebServiceLevel: {0}, SupportedFeatures: {1}", versionControlServer.WebServiceLevel, versionControlServer.SupportedFeatures);
versionControlServer.PendingChangesChanged += VersionControlServerOnPendingChangesChanged;
checkinNotesCacheWrapper = new CheckinNotesCacheWrapper(versionControlServer);
ShelveCommand = new RelayCommand(Shelve, CanShelve);
UnshelveCommand = new RelayCommand(Unshelve, CanUnshelve);
CheckInCommand = new RelayCommand(CheckIn, CanCheckIn);
RefreshPendingChangesCommand = new RelayCommand(RefreshPendingChanges, CanRefreshPendingChanges);
RefreshSelectedDefinitionWorkItemsCommand = new RelayCommand(RefreshSelectedDefinitionWorkItems, CanRefreshSelectedDefinitionWorkItems);
ShowSelectWorkItemQueryCommand = new RelayCommand(ShowSelectWorkItemQuery, CanShowSelectWorkItemQuery);
EvaluateCheckInCommand = new RelayCommand(EvaluateCheckIn, CanEvaluateCheckIn);
SelectPendingChangesCommand = new RelayCommand<SelectPendingChangesCommandArgument>(SelectPendingChanges, CanSelectPendingChanges);
SelectWorkItemsCommand = new RelayCommand<SelectWorkItemsCommandArgument>(SelectWorkItems, CanSelectWorkItems);
ViewWorkItemCommand = new RelayCommand<ObservableCollection<object>>(ViewWorkItem, CanViewWorkItem);
ViewPendingChangeCommand = new RelayCommand<ObservableCollection<object>>(ViewPendingChange, CanViewPendingChange);
CompareWithLatestCommand = new RelayCommand<ObservableCollection<object>>(CompareWithLatest, CanCompareWithLatest);
CompareWithWorkspaceCommand = new RelayCommand<ObservableCollection<object>>(CompareWithWorkspace, CanCompareWithWorkspace);
UndoPendingChangeCommand = new RelayCommand<ObservableCollection<object>>(UndoPendingChange, CanUndoPendingChange);
PendingChangePropertiesCommand = new RelayCommand<ObservableCollection<object>>(PendingChangeProperties, CanPendingChangeProperties);
CheckinNotes = new ObservableCollection<CheckinNoteModel>();
PendingChanges = new ObservableCollection<PendingChangeModel>();
_backgroundFunctionPreventDataUpdate = true;
PendingChanges.CollectionChanged += PendingChangesOnCollectionChanged;
_populatePendingChangedBackgroundWorker = new BackgroundWorker();
_populatePendingChangedBackgroundWorker.DoWork += PopulatePendingChangedBackgroundWorkerOnDoWork;
_populatePendingChangedBackgroundWorker.RunWorkerAsync();
SolutionIsOpen = teamPilgrimVsService.Solution.IsOpen && !string.IsNullOrEmpty(teamPilgrimVsService.Solution.FileName);
teamPilgrimVsService.SolutionStateChanged += () =>
{
FilterSolution = false;
SolutionIsOpen = teamPilgrimVsService.Solution.IsOpen && !string.IsNullOrEmpty(teamPilgrimVsService.Solution.FileName);
};
WorkItems = new ObservableCollection<WorkItemModel>();
WorkItems.CollectionChanged += WorkItemsOnCollectionChanged;
PopulatePreviouslySelectedWorkItemQueryModels();
_backgroundFunctionPreventDataUpdate = false;
}
public TfsWorkspaceWrapper(Workspace workspace)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
_workspace = workspace;
}
public InternalServerInfo(string uri, Guid repositoryGuid, Workspace workspace)
{
this.uri = new Uri(uri);
this.repositoryGuid = repositoryGuid;
List<WorkspaceInfo> infos = new List<WorkspaceInfo>();
infos.Add(new WorkspaceInfo(this, workspace));
Workspaces = infos.ToArray();
}
public ChangesetVisitor(WorkItemStore store, VersionControlServer versionControlServer, IVisualStudioAdapter visualStudioAdapter)
{
this.versionControlServer = versionControlServer;
this.visualStudioAdapter = visualStudioAdapter;
workItemVisitor = new WorkItemVisitor(store);
workItemVisitor.WorkItemVisit += OnWorkItemVisit;
workspace = visualStudioAdapter.GetCurrentWorkSpace();
}
public ElPackager(string root, TfsChangesets changesets)
{
_root = root;
var tpc = new TfsTeamProjectCollection(new Uri(TfsUrl));
var vc = tpc.GetService<VersionControlServer>();
_workspace = vc.GetWorkspace(root);
var serverFolder = _workspace.GetServerItemForLocalItem(root);
changesets.LoadChangesets(vc, serverFolder);
_changesets = changesets;
}
public string GetBranchNameForItem(string localFullPath, out Workspace workspace, out BranchObject branchObject)
{
workspace = null;
branchObject = null;
return GetBranchNameForItem(
localFullPath,
waitForConnection: true,
timeout: TimeSpan.FromSeconds(5),
workspace: out workspace,
branchObject: out branchObject);
}
public bool TryCheckin(Workspace workspace, PendingChange[] changes, string comment, CheckinNote checkinNote = null, WorkItemCheckinInfo[] workItemChanges = null, PolicyOverrideInfo policyOverride = null)
{
try
{
_teamPilgrimTfsService.WorkspaceCheckin(workspace, changes, comment, checkinNote, workItemChanges, policyOverride);
return true;
}
catch (Exception ex)
{
this.Logger().DebugException(ex);
LastException = ex;
}
return false;
}
public WorkspaceAddEditDialog(Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace, Microsoft.TeamFoundation.Client.ProjectCollection projectCollection)
{
this.projectCollection = projectCollection;
if (workspace == null)
{
_action = DialogAction.Create;
}
else
{
this._workspace = workspace;
_action = DialogAction.Edit;
}
_workingFoldersStore = new ListStore(_tfsFolder, _localFolder);
BuildGui();
}
public WorkspaceAddEditDialog(Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace, Microsoft.TeamFoundation.Client.ProjectCollection projectCollection)
{
this.projectCollection = projectCollection;
if (workspace == null)
{
_action = DialogAction.Create;
}
else
{
this._workspace = workspace;
_action = DialogAction.Edit;
}
_workingFoldersStore = new ListStore(_tfsFolder, _localFolder);
BuildGui();
}
public TfsSourceControlProvider()
{
var info = Workstation.Current.GetLocalWorkspaceInfo(Vs.Helper.SolutionFolder);
if (info == null)
{
Console.WriteLine("Cannot Find Tfs Workspace at " + Vs.Helper.SolutionFolder);
return;
}
var uri = info.ServerUri;
var projectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri);
var cssService = projectCollection.GetService<ICommonStructureService4>();
workspace = info.GetWorkspace(projectCollection);
IsActive = true;
}
private void ShowDialog(DialogAction action)
{
Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace = null;
if (action == DialogAction.Edit)
{
string workspaceName = _listStore.GetValue(_listView.SelectedRow, _name);
workspace = WorkspaceHelper.GetWorkspace(this.projectCollection, workspaceName);
}
using (var dialog = new WorkspaceAddEditDialog(workspace, this.projectCollection))
{
if (dialog.Run(this) == Command.Ok)
{
FillWorkspaces();
}
}
}
public CachedWorkspace(string solutionFilePath)
{
WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(solutionFilePath);
var server = new TfsTeamProjectCollection(workspaceInfo.ServerUri);
this.workspace = workspaceInfo.GetWorkspace(server);
this.changedFilePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (PendingChange pendingChange in this.workspace.GetPendingChangesEnumerable())
{
if (!String.IsNullOrEmpty(pendingChange.LocalItem) &&
(pendingChange.IsAdd || pendingChange.IsEdit))
{
this.changedFilePaths.Add(Path.GetFullPath(pendingChange.LocalItem));
}
}
}
internal WorkspaceInfo(InternalServerInfo server, Workspace workspace)
{
this.server = server;
comment = workspace.Comment;
computer = workspace.Computer;
name = workspace.Name;
ownerName = workspace.OwnerName;
List<string> paths = new List<string>();
foreach (WorkingFolder folder in workspace.Folders)
{
paths.Add(folder.LocalItem);
}
mappedPaths = paths.ToArray();
}
public string GetBranchNameForItem(
string localFullPath,
bool waitForConnection,
TimeSpan timeout,
out Workspace workspace,
out BranchObject branchObject)
{
CancellationTokenSource cts = new CancellationTokenSource(timeout);
return GetBranchNameForItem(
localFullPath,
waitForConnection,
cts.Token,
out workspace,
out branchObject);
}
public RepositoryDialog(Workspace workspace)
: base((workspace == null)? "Add Repository" : "Edit Repository")
{
Table table = new Table(3, 2, false);
table.RowSpacing = ((uint)(6));
table.ColumnSpacing = ((uint)(6));
table.BorderWidth = ((uint)(12));
name = AddLabeledEntry(table, "_Name:", 1, 2);
server = AddLabeledEntry(table, "_Server:", 2, 3);
table.Attach(new Gtk.HSeparator(), 0, 2, 3, 4);
username = AddLabeledEntry(table, "_Username:"******"_Password:"******"OK", ResponseType.Ok) as Button;
AddCloseButton("Cancel");
DefaultResponse = ResponseType.Ok;
if (workspace != null)
{
name.Text = workspace.Name;
Uri uri = workspace.VersionControlServer.TeamFoundationServer.Uri;
server.Text = uri.Host.ToString();
string creds = Keyring.GetCredentials(uri.ToString());
int comma = creds.IndexOf(",");
if (comma != -1)
{
username.Text = creds.Substring(0, comma);
password.Text = creds.Substring(comma+1);
}
else username.Text = creds;
}
else
{
name.Text = "CodePlex";
server.Text = "https://tfs01.codeplex.com";
username.Text = "snd\\";
}
ShowAll();
}
internal static void Open(List <ExtendedItem> items, Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
using (var dialog = new CheckOutDialog())
{
dialog.FillStore(items);
if (dialog.Run(Xwt.Toolkit.CurrentEngine.WrapWindow(MessageService.RootWindow)) == Command.Ok)
{
var itemsToCheckOut = dialog.SelectedItems;
using (var progress = VersionControlService.GetProgressMonitor("Check Out", VersionControlOperationType.Pull))
{
progress.BeginTask("Check Out", itemsToCheckOut.Count);
foreach (var item in itemsToCheckOut)
{
var path = item.IsInWorkspace ? item.LocalItem : workspace.GetLocalPathForServerPath(item.ServerPath);
workspace.Get(new GetRequest(item.ServerPath, RecursionType.Full, VersionSpec.Latest), GetOptions.None, progress);
progress.Log.WriteLine("Check out item: " + item.ServerPath);
var failures = workspace.PendEdit(new List <FilePath> {
path
}, RecursionType.Full, dialog.LockLevel);
if (failures != null && failures.Any())
{
if (failures.Any(f => f.SeverityType == SeverityType.Error))
{
foreach (var failure in failures.Where(f => f.SeverityType == SeverityType.Error))
{
progress.ReportError(failure.Code, new Exception(failure.Message));
}
break;
}
foreach (var failure in failures.Where(f => f.SeverityType == SeverityType.Warning))
{
progress.ReportWarning(failure.Message);
}
}
}
progress.EndTask();
progress.ReportSuccess("Finish Check Out.");
}
}
}
}
internal static void Open(List <ExtendedItem> items, Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
using (var dialog = new CheckInDialog())
{
dialog.FillStore(items, workspace);
if (dialog.Run(Toolkit.CurrentEngine.WrapWindow(MessageService.RootWindow)) == Command.Ok)
{
using (var progress = VersionControlService.GetProgressMonitor("CheckIn", VersionControlOperationType.Push))
{
progress.BeginTask("Check In", 1);
var result = workspace.CheckIn(dialog.SelectedChanges, dialog.Comment, dialog.SelectedWorkItems);
foreach (var failure in result.Failures.Where(f => f.SeverityType == SeverityType.Error))
{
progress.ReportError(failure.Code, new Exception(failure.Message));
}
progress.EndTask();
progress.ReportSuccess("Finish Check In");
}
}
}
}
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);
}
}
private void OnChangeActiveWorkspaces(object sender, EventArgs ev)
{
TreeIter workspaceIter;
if (_workspaceComboBox.GetActiveIter(out workspaceIter))
{
var workspace = (Microsoft.TeamFoundation.VersionControl.Client.Workspace)_workspaceStore.GetValue(workspaceIter, 0);
_currentWorkspace = workspace;
TFSVersionControlService.Instance.SetActiveWorkspace(projectCollection, workspace.Name);
TreeIter treeIter;
if (_treeView.Selection.GetSelected(out treeIter))
{
var currentItem = (BaseItem)_treeStore.GetValue(treeIter, 0);
ShowMappingPath(currentItem.ServerPath);
FillListView(currentItem.ServerPath);
}
}
else
{
TFSVersionControlService.Instance.SetActiveWorkspace(projectCollection, string.Empty);
}
}
internal static void Open(List <ExtendedItem> items, Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
using (var dialog = new UndoDialog())
{
dialog.FillStore(items, workspace);
if (dialog.Run(Toolkit.CurrentEngine.WrapWindow(MessageService.RootWindow)) == Command.Ok)
{
var changesToUndo = dialog.SelectedItems;
using (var progress = VersionControlService.GetProgressMonitor("Undo", VersionControlOperationType.Pull))
{
progress.BeginTask("Undo", changesToUndo.Count);
var itemSpecs = new List <ItemSpec>();
foreach (var change in changesToUndo)
{
itemSpecs.Add(new ItemSpec(change.LocalItem, change.ItemType == ItemType.File ? RecursionType.None : RecursionType.Full));
}
workspace.Undo(itemSpecs, progress);
progress.EndTask();
progress.ReportSuccess("Finish Undo");
}
}
}
}
internal static void Open(List <ExtendedItem> items, Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
using (var dialog = new LockDialog())
{
dialog.FillStore(items);
if (dialog.Run(Toolkit.CurrentEngine.WrapWindow(MessageService.RootWindow)) == Command.Ok)
{
var itemsToLock = dialog.SelectedItems;
var lockLevel = dialog.LockLevel;
using (var progress = VersionControlService.GetProgressMonitor("Lock Files", VersionControlOperationType.Pull))
{
progress.BeginTask("Lock Files", itemsToLock.Count);
var folders = new List <string>(itemsToLock.Where(i => i.ItemType == ItemType.Folder).Select(i => (string)i.ServerPath));
var files = new List <string>(itemsToLock.Where(i => i.ItemType == ItemType.File).Select(i => (string)i.ServerPath));
workspace.LockFolders(folders, lockLevel);
workspace.LockFiles(files, lockLevel);
progress.EndTask();
progress.ReportSuccess("Finish locking.");
}
}
}
}
public WorkingFolderDialog(Workspace workspace, string serverPath)
: base("Working Folder Mapping")
{
this.serverPath = serverPath;
Table table = new Table(3, 3, false);
table.RowSpacing = ((uint)(6));
table.ColumnSpacing = ((uint)(6));
table.BorderWidth = ((uint)(12));
Label label = new Label("_Server Path: ");
table.Attach(label, 0, 1, 1, 2);
Label labelPath = new Label(serverPath);
labelPath.Xalign = 0;
table.Attach(labelPath, 1, 2, 1, 2);
localPath = AddLabeledEntry(table, "_Local Path:", 2, 3);
localPath.WidthChars = 32;
browseButton = new Button("Browse...");
table.Attach(browseButton, 2, 3, 2, 3);
string lpath = workspace.TryGetLocalItemForServerItem(serverPath);
if (!String.IsNullOrEmpty(lpath))
{
localPath.Text = lpath;
deleteButton = AddButton("Remove Mapping", ResponseType.Reject) as Button;
}
VBox.Add(table);
okButton = AddButton("OK", ResponseType.Ok) as Button;
browseButton.Pressed += OnBrowseButtonPressed;
AddCloseButton("Cancel");
DefaultResponse = ResponseType.Ok;
ShowAll();
}
internal PendingChangeEventArgs(Workspace workspace, PendingChange pendingChange)
{
this.workspace = workspace;
this.pendingChange = pendingChange;
}
internal List<Conflict> QueryConflicts(Workspace workspace, List<ItemSpec> items)
{
var invoker = new SoapInvoker(this);
var msg = invoker.CreateEnvelope("QueryConflicts");
msg.Add(new XElement(MessageNs + "workspaceName", workspace.Name));
msg.Add(new XElement(MessageNs + "ownerName", workspace.OwnerName));
msg.Add(new XElement(MessageNs + "items", items.Select(itemSpec => itemSpec.ToXml(MessageNs + "ItemSpec"))));
var result = invoker.InvokeResult();
return ConflictExtractor(result, workspace);
}
internal CheckInResult CheckIn(Workspace workspace, List<PendingChange> changes, string comment, Dictionary<int, WorkItemCheckinAction> workItems)
{
var invoker = new SoapInvoker(this);
var msg = invoker.CreateEnvelope("CheckIn");
msg.Add(new XElement(MessageNs + "workspaceName", workspace.Name));
msg.Add(new XElement(MessageNs + "ownerName", workspace.OwnerName));
msg.Add(new XElement(MessageNs + "serverItems", changes.Select(x => x.ServerItem).Distinct().Select(s => new XElement(MessageNs + "string", s))));
msg.Add(new XElement(MessageNs + "info",
new XAttribute("date", new DateTime(0).ToString("s")),
new XAttribute("cset", 0),
new XAttribute("owner", workspace.OwnerName),
new XElement(MessageNs + "Comment", comment),
new XElement(MessageNs + "CheckinNote", string.Empty),
new XElement(MessageNs + "PolicyOverride", string.Empty)));
if (workItems != null && workItems.Count > 0)
{
msg.Add(new XElement(MessageNs + "checkinNotificationInfo",
new XElement(MessageNs + "WorkItemInfo",
workItems.Select(wi => new XElement(MessageNs + "CheckinNotificationWorkItemInfo",
new XElement(MessageNs + "Id", wi.Key),
new XElement(MessageNs + "CheckinAction", wi.Value))))));
}
var response = invoker.InvokeResponse();
var resultElement = invoker.MethodResultExtractor(response);
var result = CheckInResult.FromXml(resultElement);
result.Failures = FailuresExtractor(response);
return result;
}
public GetSpecVersionDialog(Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace)
{
this.workspace = workspace;
BuildGui();
}
internal ExceptionEventArgs(Workspace workspace, Failure failure)
{
this.workspace = workspace;
this.failure = failure;
}
internal void AttachWorkspace(Workspace workspace)
{
if (workspace == null)
throw new ArgumentNullException("workspace");
if (workspaces.Contains(workspace))
return;
workspace.RefreshPendingChanges();
workspaces.Add(workspace);
}
public Workspace UpdateWorkspace(string oldWorkspaceName, string ownerName,
Workspace newWorkspace)
{
var invoker = new SoapInvoker(this);
XElement msg = invoker.CreateEnvelope("UpdateWorkspace");
msg.Add(new XElement(MessageNs + "oldWorkspaceName", oldWorkspaceName));
msg.Add(new XElement(MessageNs + "ownerName", ownerName));
msg.Add(newWorkspace.ToXml(MessageNs + "newWorkspace"));
XElement result = invoker.InvokeResult();
return Workspace.FromXml(this, result);
}
private void Deploy()
{
var collection = new TfsTeamProjectCollection(new Uri(ConfigHelper.Instance.FuncTestCollection));
var vcs = collection.GetService<VersionControlServer>();
TeamProject tp = vcs.GetTeamProject(ConfigHelper.Instance.FuncTestsProject);
const string workspaceName = "MyWorkspace";
Workspace[] workspaces = vcs.QueryWorkspaces(workspaceName, vcs.AuthorizedUser, Workstation.Current.Name);
foreach (var workspace in workspaces)
{
foreach (var workingFolder in workspace.Folders)
{
if (Directory.Exists(workingFolder.LocalItem))
{
var files = Directory.GetFiles(workingFolder.LocalItem, "*.*", SearchOption.AllDirectories);
foreach (var file in files)
File.SetAttributes(file, File.GetAttributes(file) & ~FileAttributes.ReadOnly);
Directory.Delete(workingFolder.LocalItem, true);
}
workspace.DeleteMapping(workingFolder);
}
vcs.DeleteWorkspace(workspace.Name, vcs.AuthorizedUser);
}
string projectPath = tp.ServerItem;
string workingDirectory = ClonedRepoFolder;
Directory.CreateDirectory(workingDirectory);
_workspace = vcs.CreateWorkspace(workspaceName, vcs.AuthorizedUser, "Test Workspace");
try
{
_workspace.Map(projectPath, workingDirectory);
GetRequest request = new GetRequest(new ItemSpec(projectPath, RecursionType.Full), VersionSpec.Latest);
GetStatus status = _workspace.Get(request, GetOptions.GetAll | GetOptions.Overwrite);
}
catch
{
throw;
}
}
protected override void OnCheckout(FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor)
{
var ws = WorkspaceHelper.GetLocalWorkspaces(this.VersionControlService.Collection);
if (ws.Count == 0)
{
Workspace newWorkspace = new Workspace(this.VersionControlService,
Environment.MachineName + ".WS", this.VersionControlService.Collection.Server.UserName, "Auto created",
new List<WorkingFolder> { new WorkingFolder(VersionControlPath.RootFolder, targetLocalPath) }, Environment.MachineName);
var workspace = this.VersionControlService.CreateWorkspace(newWorkspace);
workspace.Get(new GetRequest(VersionControlPath.RootFolder, RecursionType.Full, VersionSpec.Latest), GetOptions.None, monitor);
}
else
{
this.workspaces.AddRange(ws);
var workspace = GetWorkspaceByLocalPath(targetLocalPath);
if (workspace == null)
return;
workspace.Get(new GetRequest(workspace.GetServerPathForLocalPath(targetLocalPath), RecursionType.Full, VersionSpec.Latest), GetOptions.None, monitor);
}
}
private static bool AddMissingFile(XDocument xml, FileInfo file, string rootPath, string relativePath, string linkPath, Workspace workspace)
{
var compileName = XName.Get("Compile", ProjectNs);
var newFilePath = Path.Combine(relativePath, file.NewName);
var itemGroup = xml.Descendants(compileName).FirstOrDefault().Parent;
if (itemGroup.Descendants(compileName).Any(x => x.Attributes().Any(a => a.Value.Contains(newFilePath))))
{
return false;
}
if (!string.IsNullOrEmpty(file.OldName))
{
var oldFilePath = Path.Combine(relativePath, file.OldName);
var oldCompileInfo = itemGroup.Descendants(compileName).FirstOrDefault(x => x.Attributes().Any(a => a.Value.Contains(oldFilePath)));
if (oldCompileInfo != null)
{
oldCompileInfo.Remove();
if (workspace != null)
{
workspace.PendDelete(Path.Combine(rootPath, oldFilePath));
}
else
{
var oldFileInfo = new System.IO.FileInfo(Path.Combine(rootPath, oldFilePath));
oldFileInfo.Delete();
}
}
}
var compileInfo = new XElement(compileName);
compileInfo.Add(new XAttribute(XName.Get("Include"), newFilePath));
if (linkPath != null)
{
var fileLinkPath = Path.Combine(linkPath, file.NewName);
compileInfo.Add(new XElement(XName.Get("Link", ProjectNs), fileLinkPath));
}
itemGroup.Add(compileInfo);
if (workspace != null && linkPath == null)
{
workspace.PendAdd(Path.Combine(rootPath, newFilePath));
}
return true;
}
