void IAssetMenuOperations.ShowHistory()
{
if (LaunchTool.ShowDownloadPlasticExeWindow(
mWkInfo,
mIsGluonMode,
TrackFeatureUseEvent.Features.InstallPlasticCloudFromShowHistory,
TrackFeatureUseEvent.Features.InstallPlasticEnterpriseFromShowHistory,
TrackFeatureUseEvent.Features.CancelPlasticInstallationFromShowHistory))
{
return;
}
AssetList assetList = mAssetSelection.GetSelectedAssets();
Asset selectedAsset = AssetsSelection.GetSelectedAsset(
assetList);
string selectedPath = AssetsSelection.GetSelectedPath(
assetList);
WorkspaceTreeNode node = PlasticGui.Plastic.API.
GetWorkspaceTreeNode(selectedPath);
mHistoryViewLauncher.ShowHistoryView(
node.RepSpec,
node.RevInfo.ItemId,
selectedPath,
selectedAsset.isFolder);
}
public void TestIsNotControlledSelection()
{
try
{
PlasticApiMock apiMock = new PlasticApiMock();
Plastic.InitializeAPIForTesting(apiMock);
string fooPath = Path.Combine(Path.GetTempPath(), "foo.c");
string barPath = Path.Combine(Path.GetTempPath(), "bar.c");
Asset fooAsset = new Asset(fooPath);
Asset barAsset = new Asset(barPath);
WorkspaceTreeNode fooNode = BuildWorkspaceTreeNode.Controlled();
apiMock.SetupGetWorkspaceTreeNode(fooPath, fooNode);
apiMock.SetupGetWorkingBranch(new BranchInfo());
AssetList assetList = new AssetList();
assetList.Add(fooAsset);
assetList.Add(barAsset);
SelectedAssetGroupInfo groupInfo =
SelectedAssetGroupInfo.BuildFromAssetList(
assetList,
new AssetStatusCacheMock());
Assert.IsFalse(groupInfo.IsControlledSelection);
}
finally
{
Plastic.InitializeAPIForTesting(new PlasticAPI());
}
}
static AssetStatus CalculateStatus(
string fullPath,
string wkPath,
IgnoredFilesFilter ignoredFilter)
{
if (!IsOnWorkspace(fullPath, wkPath))
{
return(AssetStatus.None);
}
WorkspaceTreeNode treeNode = Plastic.API.GetWorkspaceTreeNode(fullPath);
if (CheckWorkspaceTreeNodeStatus.IsPrivate(treeNode))
{
return(ignoredFilter.IsIgnored(fullPath) ?
AssetStatus.Ignored : AssetStatus.Private);
}
if (CheckWorkspaceTreeNodeStatus.IsAdded(treeNode))
{
return(AssetStatus.Added);
}
AssetStatus result = AssetStatus.Controlled;
if (CheckWorkspaceTreeNodeStatus.IsCheckedOut(treeNode) &&
!CheckWorkspaceTreeNodeStatus.IsDirectory(treeNode))
{
result |= AssetStatus.Checkout;
}
return(result);
}
static void ForChildren(
WorkspaceTreeNode directoryNode,
Queue <WorkspaceTreeNode> pendingDirectories,
Dictionary <RepositorySpec, List <WorkspaceTreeNode> > lockCandidates)
{
if (!directoryNode.HasChildren)
{
return;
}
foreach (WorkspaceTreeNode child in directoryNode.Children)
{
if (CheckWorkspaceTreeNodeStatus.IsDirectory(child))
{
pendingDirectories.Enqueue(child);
continue;
}
if (CheckWorkspaceTreeNodeStatus.IsAdded(child))
{
continue;
}
List <WorkspaceTreeNode> nodes = null;
if (!lockCandidates.TryGetValue(child.RepSpec, out nodes))
{
nodes = new List <WorkspaceTreeNode>();
lockCandidates.Add(child.RepSpec, nodes);
}
nodes.Add(child);
}
}
internal static bool IsCheckedOut(WorkspaceTreeNode node)
{
if (node == null)
{
return(false);
}
return(node.RevInfo.CheckedOut);
}
internal static bool IsAdded(WorkspaceTreeNode node)
{
if (node == null)
{
return(false);
}
return(node.RevInfo.CheckedOut &&
node.RevInfo.ParentId == -1);
}
public ClassBrowserTreeView()
{
WorkspaceTreeNode root = new WorkspaceTreeNode();
ClassBrowserTreeView instance = this;
SD.ClassBrowser.CurrentWorkspace.AssemblyLists.CollectionChanged += delegate {
instance.ShowRoot = SD.ClassBrowser.CurrentWorkspace.AssemblyLists.Count > 0;
};
root.PropertyChanged += delegate {
instance.ShowRoot = SD.ClassBrowser.CurrentWorkspace.AssemblyLists.Count > 0;
};
this.Root = root;
}
static LockStatusData BuildLockStatusData(
WorkspaceTreeNode node,
LockInfo lockInfo,
LockOwnerNameResolver nameResolver)
{
AssetStatus status = CheckWorkspaceTreeNodeStatus.IsCheckedOut(node) ?
AssetStatus.Locked : AssetStatus.LockedRemote;
return(new LockStatusData(
status,
nameResolver.GetSeidName(lockInfo.SEIDData),
LockWkInfo.GetWkCleanName(lockInfo)));
}
internal static void ForTree(
WorkspaceInfo wkInfo,
Dictionary <RepositorySpec, List <WorkspaceTreeNode> > lockCandidates)
{
WorkspaceTreeNode rootNode = CmConnection.Get().GetWorkspaceTreeHandler().
GetWorkspaceTree(wkInfo, wkInfo.ClientPath, true);
Queue <WorkspaceTreeNode> pendingDirectories = new Queue <WorkspaceTreeNode>();
pendingDirectories.Enqueue(rootNode);
while (pendingDirectories.Count > 0)
{
WorkspaceTreeNode directoryNode = pendingDirectories.Dequeue();
ForChildren(directoryNode, pendingDirectories, lockCandidates);
}
}
void IAssetMenuOperations.ShowHistory()
{
AssetList assetList = mAssetSelection.GetSelectedAssets();
Asset selectedAsset = AssetsSelection.GetSelectedAsset(
assetList);
string selectedPath = AssetsSelection.GetSelectedPath(
assetList);
WorkspaceTreeNode node = Plastic.API.
GetWorkspaceTreeNode(selectedPath);
mHistoryViewLauncher.ShowHistoryView(
node.RepSpec,
node.RevInfo.ItemId,
selectedPath,
selectedAsset.isFolder);
}
internal static void AsFullyChecked(WorkspaceInfo wkInfo)
{
string rootPath = WorkspacePath.GetWorkspacePathFromCmPath(
wkInfo.ClientPath, "/", Path.DirectorySeparatorChar);
WorkspaceTreeNode rootWkNode = CmConnection.Get().GetWorkspaceTreeHandler().
WkGetWorkspaceTreeNode(rootPath);
FullyCheckedDirectory rootDirectory = new FullyCheckedDirectory();
rootDirectory.MountId = MountPointId.WORKSPACE_ROOT;
rootDirectory.ItemId = rootWkNode.RevInfo.ItemId;
List <FullyCheckedDirectory> directoryList = new List <FullyCheckedDirectory>();
directoryList.Add(rootDirectory);
FullyCheckedDirectoriesStorage.Save(wkInfo, directoryList);
}
public void TestIsNotFileSelection()
{
string barPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
try
{
PlasticApiMock apiMock = new PlasticApiMock();
Plastic.InitializeAPIForTesting(apiMock);
string fooPath = Path.Combine(Path.GetTempPath(), "foo.c");
Directory.CreateDirectory(barPath);
Asset fooAsset = new Asset(fooPath);
Asset barAsset = new Asset(barPath);
WorkspaceTreeNode fooNode = BuildWorkspaceTreeNode.Controlled();
apiMock.SetupGetWorkspaceTreeNode(fooPath, fooNode);
apiMock.SetupGetWorkingBranch(new BranchInfo());
AssetList assetList = new AssetList();
assetList.Add(fooAsset);
assetList.Add(barAsset);
SelectedAssetGroupInfo groupInfo =
SelectedAssetGroupInfo.BuildFromAssetList(
assetList,
new AssetStatusCacheMock());
Assert.IsFalse(groupInfo.IsFileSelection);
}
finally
{
Plastic.InitializeAPIForTesting(new PlasticAPI());
if (Directory.Exists(barPath))
{
Directory.Delete(barPath);
}
}
}
public void TestHasAnyLockedRemoteInSelection()
{
try
{
PlasticApiMock apiMock = new PlasticApiMock();
PlasticGui.Plastic.InitializeAPIForTesting(apiMock);
string fooPath = Path.Combine(Path.GetTempPath(), "foo.c");
string barPath = Path.Combine(Path.GetTempPath(), "bar.c");
Asset fooAsset = new Asset(fooPath);
Asset barAsset = new Asset(barPath);
WorkspaceTreeNode fooNode = BuildWorkspaceTreeNode.Controlled();
WorkspaceTreeNode barNode = BuildWorkspaceTreeNode.Controlled();
apiMock.SetupGetWorkspaceTreeNode(fooPath, fooNode);
apiMock.SetupGetWorkspaceTreeNode(barPath, barNode);
apiMock.SetupGetWorkingBranch(new BranchInfo());
AssetList assetList = new AssetList();
assetList.Add(fooAsset);
assetList.Add(barAsset);
AssetStatusCacheMock assetStatusCache = new AssetStatusCacheMock();
assetStatusCache.SetStatus(fooPath, AssetStatus.LockedRemote);
SelectedAssetGroupInfo groupInfo =
SelectedAssetGroupInfo.BuildFromAssetList(
assetList,
assetStatusCache);
Assert.IsTrue(groupInfo.HasAnyRemoteLockedInSelection);
}
finally
{
PlasticGui.Plastic.InitializeAPIForTesting(new PlasticAPI());
}
}
static string GetSymbolicName(string selectedPath)
{
WorkspaceTreeNode node = Plastic.API.
GetWorkspaceTreeNode(selectedPath);
string branchName = string.Empty;
BranchInfoCache.TryGetBranchName(
node.RepSpec, node.RevInfo.BranchId, out branchName);
string userName = Plastic.API.GetUserName(
node.RepSpec.Server, node.RevInfo.Owner);
string symbolicName = string.Format(
"cs:{0}@{1} {2} {3}",
node.RevInfo.Changeset,
string.Format("br:{0}", branchName),
userName,
"Workspace Revision");
return(symbolicName);
}
void IAssetMenuOperations.ShowHistory()
{
if (LaunchTool.ShowDownloadPlasticExeWindow(mIsGluonMode))
{
return;
}
AssetList assetList = mAssetSelection.GetSelectedAssets();
Asset selectedAsset = AssetsSelection.GetSelectedAsset(
assetList);
string selectedPath = AssetsSelection.GetSelectedPath(
assetList);
WorkspaceTreeNode node = Plastic.API.
GetWorkspaceTreeNode(selectedPath);
mHistoryViewLauncher.ShowHistoryView(
node.RepSpec,
node.RevInfo.ItemId,
selectedPath,
selectedAsset.isFolder);
}
static void CheckoutIfControlledAndChanged(string[] paths, IPlasticAPI api)
{
List <string> fullPaths = new List <string>();
foreach (string path in paths)
{
string fullPath = Path.GetFullPath(path);
string fullPathMeta = MetaPath.GetMetaPath(fullPath);
WorkspaceTreeNode node =
api.GetWorkspaceTreeNode(fullPath);
WorkspaceTreeNode nodeMeta =
api.GetWorkspaceTreeNode(fullPathMeta);
if (node != null && ChangedFileChecker.IsChanged(
node.LocalInfo, fullPath, false))
{
fullPaths.Add(fullPath);
}
if (nodeMeta != null && ChangedFileChecker.IsChanged(
nodeMeta.LocalInfo, fullPathMeta, false))
{
fullPaths.Add(fullPathMeta);
}
}
if (fullPaths.Count == 0)
{
return;
}
api.Checkout(
fullPaths.ToArray(),
CheckoutModifiers.None);
}
internal static bool IsPrivate(WorkspaceTreeNode node)
{
return(node == null);
}
internal static bool IsDirectory(WorkspaceTreeNode node)
{
return(node.RevInfo.Type == EnumRevisionType.enDirectory);
}
internal static SelectedAssetGroupInfo BuildFromSingleFile(
string path,
bool isDirectory,
IAssetStatusCache statusCache)
{
bool isCheckedInSelection = true;
bool isControlledSelection = true;
bool isCheckedOutSelection = true;
bool isPrivateSelection = true;
bool isAddedSelection = true;
bool isFileSelection = true;
bool hasAnyAddedInSelection = false;
bool hasAnyRemoteLockedInSelection = false;
string assetPath = Path.GetFullPath(path);
WorkspaceTreeNode wkTreeNode =
PlasticGui.Plastic.API.GetWorkspaceTreeNode(assetPath);
if (isDirectory)
{
isFileSelection = false;
}
if (CheckWorkspaceTreeNodeStatus.IsPrivate(wkTreeNode))
{
isControlledSelection = false;
}
else
{
isPrivateSelection = false;
}
if (CheckWorkspaceTreeNodeStatus.IsCheckedOut(wkTreeNode))
{
isCheckedInSelection = false;
}
else
{
isCheckedOutSelection = false;
}
if (CheckWorkspaceTreeNodeStatus.IsAdded(wkTreeNode))
{
hasAnyAddedInSelection = true;
}
else
{
isAddedSelection = false;
}
AssetsOverlays.AssetStatus assetStatus = statusCache.GetStatusForPath(assetPath);
if (ClassifyAssetStatus.IsLockedRemote(assetStatus))
{
hasAnyRemoteLockedInSelection = true;
}
return(new SelectedAssetGroupInfo()
{
IsCheckedInSelection = isCheckedInSelection,
IsCheckedOutSelection = isCheckedOutSelection,
IsControlledSelection = isControlledSelection,
IsPrivateSelection = isPrivateSelection,
IsAddedSelection = isAddedSelection,
IsFileSelection = isFileSelection,
HasAnyAddedInSelection = hasAnyAddedInSelection,
HasAnyRemoteLockedInSelection = hasAnyRemoteLockedInSelection,
SelectedCount = 1,
});
}
void IPlasticAPI.RevertToClientDiffRevisions(WorkspaceInfo wkInfo, ClientDiffInfo clientDiff, WorkspaceTreeNode wkNode, string workspacePath)
{
throw new NotImplementedException();
}
internal void SetupGetWorkspaceTreeNode(string path, WorkspaceTreeNode wkTreeNode)
{
mWorkspaceTreeNodes.Add(path, wkTreeNode);
}
