/// <summary>
/// Called when a node is removed.
/// </summary>
/// <param name="node">The node.</param>
private void OnNodeRemoved(EnterpriseTestMapNode node)
{
if (NodeRemoved != null)
{
NodeRemoved(this, new EnterpriseTestUIEventArgs(node));
}
}
/// <summary>
/// Gets the entity object.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public EntityObject GetEntityObject(Guid id)
{
// Discard our old entity context and create a new one. This seems wasteful,
// but if we maintain the same context it will cache all the data that is ever
// loaded from it. This can cause huge memory growth over time, as well as
// concurrency issues. Creating a new context is cheap and avoids these issues.
if (_context != null)
{
_context.Dispose();
}
_context = new EnterpriseTestContext();
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
return(EnterpriseScenario.Select(_context, id));
case ConfigurationObjectType.VirtualResource:
return(VirtualResource.Select(_context, id));
case ConfigurationObjectType.ResourceMetadata:
return(VirtualResourceMetadata.Select(_context, id));
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
return(ConfigurationTreeFolder.Select(_context, id));
default:
return(null);
}
}
private void HandleObjectChange(EnterpriseTestEntities entities, EntityObject entity)
{
// Get a node that is representative of this item
EnterpriseTestMapNode node = EnterpriseTestMapNode.Create(entity);
if (node != null)
{
switch (entity.EntityState)
{
case EntityState.Added:
_databaseMap.Add(node);
OnNodeAdded(node);
break;
case EntityState.Modified:
_databaseMap.Update(node);
OnNodeModified(node);
break;
case EntityState.Deleted:
_databaseMap.Remove(node);
OnNodeRemoved(node);
break;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseTestUIEventArgs"/> class.
/// </summary>
/// <param name="node">The node.</param>
internal EnterpriseTestUIEventArgs(EnterpriseTestMapNode node)
{
Id = node.Id;
ParentId = node.FolderId ?? node.ParentId;
Name = node.Name;
// Determine the correct image key
switch (node.NodeType)
{
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
ImageKey = "Folder";
break;
case ConfigurationObjectType.EnterpriseScenario:
ImageKey = "Scenario";
break;
case ConfigurationObjectType.VirtualResource:
ImageKey = node.ResourceType;
break;
case ConfigurationObjectType.ResourceMetadata:
ImageKey = node.MetadataType;
break;
}
// If the node is disabled, modify the key
if (!node.Enabled)
{
ImageKey += "Disabled";
}
}
/// <summary>
/// Creates a new folder under the specified parent id.
/// </summary>
/// <param name="parentId">The parent id.</param>
/// <returns>The ID of the created folder.</returns>
public Guid CreateFolder(Guid?parentId)
{
// Create a default folder, which is valid if the parent is null
var folder = new ConfigurationTreeFolder(SequentialGuid.NewGuid(), "New Folder", "ScenarioFolder", parentId);
// Determine the real folder type and parent
if (parentId != null)
{
EnterpriseTestMapNode node = _databaseMap[(Guid)parentId];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
case ConfigurationObjectType.ResourceFolder:
folder.FolderType = "ResourceFolder";
break;
case ConfigurationObjectType.VirtualResource:
case ConfigurationObjectType.MetadataFolder:
folder.FolderType = "MetadataFolder";
break;
}
}
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
context.ConfigurationTreeFolders.AddObject(folder);
HandleObjectChange(context, folder);
context.SaveChanges();
}
return(folder.ConfigurationTreeFolderId);
}
/// <summary>
/// Manages the copying of any of the nodes used. Tries to link the UI structure to the database
/// structure of the trees.
/// </summary>
/// <param name="SourceNodes">List representation of the tree. In couplet format -
/// [0] is parent, [1] is the 'node'. Using List because any node can be parent to multiple
/// other nodes and reversing it to use a dictionary negates the performance benefit of dictioanries</param>
/// <param name="Ndx">Index into the tree representation list.</param>
/// <param name="Mappings">Dictionary. Key is the original node ID, and the Value is the new/copy
/// node Id</param>
/// <returns>Guid / Node ID of the node that was created during the copy.</returns>
public Guid CopyNode(List <Guid?> SourceNodes, int Ndx, Dictionary <Guid?, Guid?> Mappings, ConfigurationObjectType rootMovedType)
{
if (SourceNodes.Count <= (Ndx + 1))
{
throw new Exception("Bad Source List / Index in CopyNode ::" + Ndx.ToString());
}
if (Mappings.ContainsKey(SourceNodes[Ndx + 1]))
{
throw new Exception("Doubly Linked Node in UI Tree: " + SourceNodes[Ndx + 1].ToString());
}
EnterpriseTestMapNode src = _databaseMap[(Guid)SourceNodes[Ndx + 1]];
switch (src.NodeType)
{
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
return(CopyFolder((Guid)SourceNodes[Ndx + 1], Mappings[(Guid?)SourceNodes[Ndx]]));
case ConfigurationObjectType.EnterpriseScenario:
return(CopyScenario((Guid)SourceNodes[Ndx + 1], Mappings[(Guid?)SourceNodes[Ndx]]));
case ConfigurationObjectType.VirtualResource:
return(CopyResource((Guid)SourceNodes[Ndx + 1], (Guid)SourceNodes[Ndx], (Guid)Mappings[(Guid?)SourceNodes[Ndx]], Mappings));
case ConfigurationObjectType.ResourceMetadata:
bool partOfResource = (rootMovedType != ConfigurationObjectType.ResourceMetadata && rootMovedType != ConfigurationObjectType.MetadataFolder);
return(CopyActivity((Guid)SourceNodes[Ndx + 1], (Guid)SourceNodes[Ndx], (Guid)Mappings[(Guid?)SourceNodes[Ndx]], Mappings, partOfResource));
default:
throw new Exception("Unknown Node type in CopyNode?");
}
}
/// <summary>
/// Called when a node is modified.
/// </summary>
/// <param name="node">The node.</param>
private void OnNodeModified(EnterpriseTestMapNode node)
{
if (NodeModified != null && DisplayNode(node))
{
NodeModified(this, new EnterpriseTestUIEventArgs(node));
}
}
private static IEnumerable <EnterpriseTestMapNode> Sort(IEnumerable <EnterpriseTestMapNode> nodes)
{
// The scenarios, resources, and metadata require no special sorting.
EnterpriseTestMapNode first = nodes.FirstOrDefault();
if (first == null || !first.NodeType.IsFolder())
{
return(nodes);
}
// Otherwise, we have a folder set
List <EnterpriseTestMapNode> remaining = new List <EnterpriseTestMapNode>(nodes);
List <EnterpriseTestMapNode> sorted = new List <EnterpriseTestMapNode>();
// We need to make sure that any subfolders come after their parent folder.
// Since this will be a relatively small set, we'll use a simple (though inefficient) approach.
while (remaining.Count > 0)
{
// Create a list of the node IDs that have not been processed yet.
IEnumerable <Guid> remainingIds = remaining.Select(n => n.Id);
// Find all nodes whose parents are not in the "unprocessed" list.
// Their parents must either be processed already, or some other type (scenario, etc.)
// so these nodes can be moved to the sorted list.
var readyNodes = remaining.Where(n => n.ParentId == null || !remainingIds.Contains((Guid)n.ParentId));
foreach (EnterpriseTestMapNode ready in readyNodes.ToList())
{
remaining.Remove(ready);
sorted.Add(ready);
}
}
return(sorted);
}
/// <summary>
/// Checks if the id is the guid for any type of a folder
/// </summary>
/// <param name="id">The id to check</param>
/// <returns>True if this node is any type of a folder</returns>
public bool IsFolder(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType == ConfigurationObjectType.ScenarioFolder ||
node.NodeType == ConfigurationObjectType.ResourceFolder ||
node.NodeType == ConfigurationObjectType.MetadataFolder);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationObjectTag"/> class.
/// </summary>
/// <param name="node">The node.</param>
internal ConfigurationObjectTag(EnterpriseTestMapNode node)
{
Id = node.Id;
ObjectType = node.NodeType;
if (!string.IsNullOrEmpty(node.ResourceType))
{
ResourceType = EnumUtil.Parse <VirtualResourceType>(node.ResourceType);
MetadataType = node.MetadataType;
}
}
/// <summary>
/// Checks two RadTreeNodes to see if they are of different 'types'.
/// </summary>
/// <param name="id1">First node</param>
/// <param name="id2">Second node</param>
/// <returns>true of the nodes are the same type, else false</returns>
public bool NodeCCPGroupsMatch(Guid id1, Guid id2)
{
if ((id1 == Guid.Empty) || (id2 == Guid.Empty))
{
return(false);
}
EnterpriseTestMapNode node1 = _databaseMap[id1];
EnterpriseTestMapNode node2 = _databaseMap[id2];
return(node1.NodeType == node2.NodeType);
}
private static bool DisplayNode(EnterpriseTestMapNode node)
{
if (node.NodeType == ConfigurationObjectType.ResourceMetadata)
{
VirtualResourceType resourceType = EnumUtil.Parse <VirtualResourceType>(node.ResourceType);
return(resourceType.UsesPlugins());
}
else
{
return(true);
}
}
/// <summary>
/// Gets a descriptive tag for the object with the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public ConfigurationObjectTag GetObjectTag(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
if (node == null)
{
return(null);
}
else
{
return(new ConfigurationObjectTag(node));
}
}
/// <summary>
/// Determines whether the object with the specified id can be enabled or disabled.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public Tuple <bool, string> CanEnableDisable(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
if (node.NodeType.CanEnableDisable())
{
return(new Tuple <bool, string>(true, node.Enabled ? "Disable" : "Enable"));
}
else
{
return(new Tuple <bool, string>(false, null));
}
}
/// <summary>
/// Gets al nodes in the subtree starting at the specified node.
/// </summary>
/// <param name="node">The node.</param>
/// <returns></returns>
public IEnumerable <EnterpriseTestMapNode> GetSubtree(EnterpriseTestMapNode node)
{
var nodes = new List <EnterpriseTestMapNode>()
{
node
};
foreach (EnterpriseTestMapNode child in FindChildren(node))
{
nodes.AddRange(GetSubtree(child));
}
return(nodes);
}
private Guid?FindNonFolderParentId(EnterpriseTestMapNode node)
{
if (!node.NodeType.IsFolder())
{
return(node.Id);
}
else if (node.ParentId == null)
{
return(null);
}
else
{
return(FindNonFolderParentId(this[(Guid)node.ParentId]));
}
}
private IEnumerable <EnterpriseTestMapNode> FindNonFolderChildren(EnterpriseTestMapNode node)
{
List <EnterpriseTestMapNode> childNodes = new List <EnterpriseTestMapNode>();
foreach (EnterpriseTestMapNode child in _nodes.Where(n => n.ParentId == node.Id || n.FolderId == node.Id))
{
if (!child.NodeType.IsFolder())
{
childNodes.Add(child);
}
else
{
childNodes.AddRange(FindNonFolderChildren(child));
}
}
return(childNodes);
}
/// <summary>
/// Gets all nodes that would be affected if the specified node was moved.
/// (This will usually not include the entire subtree.)
/// </summary>
/// <param name="node">The node.</param>
/// <returns></returns>
public IEnumerable <Guid> GetMoveAffectedNodes(EnterpriseTestMapNode node)
{
var affectedNodes = new List <Guid>()
{
node.Id
};
// If the node being moved is a folder, then children of that node may be affected,
// since the parent ID could change
if (node.NodeType.IsFolder())
{
foreach (EnterpriseTestMapNode child in FindChildren(node))
{
affectedNodes.AddRange(GetMoveAffectedNodes(child));
}
}
return(affectedNodes);
}
/// <summary>
/// Removes the object with the specified id.
/// </summary>
/// <param name="id">The id.</param>
public void Delete(Guid id)
{
// Get the map node that this id corresponds to and the subtree below it
EnterpriseTestMapNode node = _databaseMap[id];
IEnumerable <EnterpriseTestMapNode> subtree = _databaseMap.GetSubtree(node);
foreach (EnterpriseTestMapNode removingNode in subtree)
{
OnNodeRemoving(removingNode);
}
// Update all the database objects that were affected
DatabaseDelete(subtree);
// Handle object changes
foreach (EnterpriseTestMapNode deleted in subtree)
{
_databaseMap.Remove(deleted);
}
OnNodeRemoved(subtree.FirstOrDefault());
}
/// <summary>
/// Determines whether the node with the specified ID can be dropped onto the target node with the specified ID.
/// </summary>
/// <param name="nodeId">The node id.</param>
/// <param name="targetId">The target id.</param>
/// <returns>
/// <c>true</c> if the drop is valid; otherwise, <c>false</c>.
/// </returns>
public bool CanDrop(Guid nodeId, Guid targetId)
{
EnterpriseTestMapNode source = _databaseMap[nodeId];
EnterpriseTestMapNode target = _databaseMap[targetId];
// Do a schema check first
if (!target.NodeType.CanContain(source.NodeType))
{
return(false);
}
// Make sure we don't copy metadata to a different resource type
if (target.NodeType == ConfigurationObjectType.VirtualResource)
{
return(target.ResourceType == source.ResourceType);
}
else
{
// Otherwise, we're good.
return(true);
}
}
/// <summary>
/// Enables/disable the specified object.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="enabled">Whether the object should be enabled.</param>
public void EnableDisable(Guid id, bool enabled)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, id);
resource.Enabled = enabled;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, id);
metadata.Enabled = enabled;
HandleObjectChange(context, metadata);
break;
}
context.SaveChanges();
}
}
private void MoveHandler(EnterpriseTestContext context, IEnumerable <Guid> affected)
{
foreach (Guid affectedId in affected)
{
EnterpriseTestMapNode moved = _databaseMap[affectedId];
switch (moved.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, affectedId);
scenario.FolderId = moved.FolderId;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, affectedId);
resource.EnterpriseScenarioId = (Guid)moved.ParentId;
resource.FolderId = moved.FolderId;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, affectedId);
metadata.VirtualResourceId = (Guid)moved.ParentId;
metadata.FolderId = moved.FolderId;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, affectedId);
folder.ParentId = moved.ParentId;
HandleObjectChange(context, folder);
break;
}
}
context.SaveChanges();
}
/// <summary>
/// Moves the object with the specified id to the specified parent.
/// </summary>
/// <param name="nodeId">The id.</param>
/// <param name="targetId">The target parent id.</param>
public void Move(Guid nodeId, Guid?targetId)
{
// Get the map node that this id corresponds to and update it
EnterpriseTestMapNode node = _databaseMap[nodeId];
var affected = _databaseMap.GetMoveAffectedNodes(node);
_databaseMap.Move(node, targetId);
// Update all database objects that were affected
// Use the local context if it is available - this fixes an issue where the parent id changes
// but the cached copy in the local context does not get updated, which causes a crash when the object is committed
if (_context != null)
{
MoveHandler(_context, affected);
}
else
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
MoveHandler(context, affected);
}
}
}
/// <summary>
/// Renames the object with the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="name">The name.</param>
public void Rename(Guid id, string name)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, id);
scenario.Name = name;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, id);
resource.Name = name;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, id);
metadata.Name = name;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, id);
folder.Name = name;
HandleObjectChange(context, folder);
break;
}
context.SaveChanges();
}
}
/// <summary>
/// Determines whether the object with the specified id can contain a folder.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>
/// <c>true</c> if the object with the specified id can contain a folder; otherwise, <c>false</c>.
/// </returns>
public bool CanContainFolder(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType != ConfigurationObjectType.ResourceMetadata);
}
/// <summary>
/// Determines whether the object with the specified id can contain a scenario.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>
/// <c>true</c> if the object with the specified id can contain a scenario; otherwise, <c>false</c>.
/// </returns>
public bool CanContainScenario(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType == ConfigurationObjectType.ScenarioFolder);
}
/// <summary>
/// Checks if the id is the guid for resource metadata (Activity)
/// </summary>
/// <param name="id">Guid</param>
/// <returns>True if the node 'is' an activity (Resource Metadata)</returns>
public bool IsResourceMetaData(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType == ConfigurationObjectType.ResourceMetadata);
}
/// <summary>
/// Checks if the id is a Guid for a Virtual Resource
/// </summary>
/// <param name="id">The node id (Guid)</param>
/// <returns>True if the node 'is' a Virtual Resource</returns>
public bool IsResource(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType == ConfigurationObjectType.VirtualResource);
}
/// <summary>
/// Checks if the id is a guid for a scenario
/// </summary>
/// <param name="id">The id to check</param>
/// <returns>True if the Node 'is' a scenario</returns>
public bool IsScenario(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType == ConfigurationObjectType.EnterpriseScenario);
}
public ConfigurationObjectType GetType(Guid id)
{
EnterpriseTestMapNode node = _databaseMap[id];
return(node.NodeType);
}