/// <summary>
/// Specifies that the value of a cell should be mapped to a fixed value if it cannot be parsed. This
/// is useful for mapping columns where equivilent data was entered differently.
/// </summary>
/// <typeparam name="TPropertyMap">The type of the property map.</typeparam>
/// <typeparam name="T">The type of the property or field that the property map represents.</typeparam>
/// <param name="propertyMap">The property map to use.</param>
/// <param name="mappingDictionary">A dictionary that maps a fixed string value to a fixed value of T.</param>
/// <param name="comparer">The comparer uses to map fixed string values. This allows for case-insensitive mappings, for example.</param>
/// <returns>The property map on which this method was invoked.</returns>
public static TPropertyMap WithMapping <TPropertyMap, T>(this TPropertyMap propertyMap, IDictionary <string, T> mappingDictionary, IEqualityComparer <string> comparer = null) where TPropertyMap : ISinglePropertyMap <T>
{
var item = new DictionaryMapper <T>(mappingDictionary, comparer);
propertyMap.AddCellValueMapper(item);
return(propertyMap);
}
/// <summary>
/// Initializes the helper.
/// </summary>
/// <param name="graphControl">The control that displays the graph.</param>
/// <param name="component">The component the is dragged.</param>
/// <param name="components">Defines components that should not be separated by the layout algorithm.</param>
public ClearAreaLayoutHelper(GraphControl graphControl, IGraph component, DictionaryMapper <INode, object> components)
{
this.graphControl = graphControl;
this.oldLocation = GetCenter(component);
this.Component = component;
this.components = components;
}
public void Can_Map_Key_Property()
{
// Act
string column = new DictionaryMapper(MockSqlContext(), CreateMaps()).Map("Key");
// Assert
Assert.That(column, Is.EqualTo("[cmsDictionary].[id]"));
}
public void Can_Map_ItemKey_Property()
{
// Act
string column = new DictionaryMapper().Map(new SqlCeSyntaxProvider(), "ItemKey");
// Assert
Assert.That(column, Is.EqualTo("[cmsDictionary].[key]"));
}
public void Can_Map_ItemKey_Property()
{
// Act
string column = new DictionaryMapper(TestHelper.GetMockSqlContext(), TestHelper.CreateMaps()).Map("ItemKey");
// Assert
Assert.That(column, Is.EqualTo("[cmsDictionary].[key]"));
}
protected DictionaryMapper Property <TKey, TValue>(
Expression <Func <TEntity, IDictionary <TKey, TValue> > > predicate)
{
var mapper = new DictionaryMapper(predicate.ExtractNameAndType());
_mappers.Add(mapper);
return(mapper);
}
public void Can_Map_Id_Property()
{
// Act
var column = new DictionaryMapper(TestHelper.GetMockSqlContext(), TestHelper.CreateMaps()).Map("Id");
// Assert
Assert.That(column, Is.EqualTo("[cmsDictionary].[pk]"));
}
void Awake()
{
_sceneMapping = new DictionaryMapper <string, string>(k => k);
foreach (StringPair stringPair in sceneMapping)
{
_sceneMapping[stringPair.First] = stringPair.Second;
}
}
public void Can_Map_ItemKey_Property()
{
// Arrange
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
// Act
string column = new DictionaryMapper().Map("ItemKey");
// Assert
Assert.That(column, Is.EqualTo("[cmsDictionary].[key]"));
}
private static void AddNodeHalos(LayoutGraphAdapter adapter, IGraph graph, bool layoutOnlySelection)
{
var nodeHalos = new DictionaryMapper <INode, NodeHalo>();
foreach (var node in graph.Nodes)
{
var top = 0.0;
var left = 0.0;
var bottom = 0.0;
var right = 0.0;
// for each port with an EventPortStyle extend the node halo to cover the ports render size
foreach (var port in node.Ports)
{
var eventPortStyle = port.Style as EventPortStyle;
if (eventPortStyle != null)
{
var renderSize = eventPortStyle.RenderSize;
var location = port.GetLocation();
top = Math.Max(top, node.Layout.Y - location.Y - renderSize.Height / 2);
left = Math.Max(left, node.Layout.X - location.X - renderSize.Width / 2);
bottom = Math.Max(bottom, location.Y + renderSize.Height / 2 - node.Layout.GetMaxY());
right = Math.Max(right, location.X + renderSize.Width / 2 - node.Layout.GetMaxX());
}
}
// for each node without incoming or outgoing edges reserve space for laid out exterior labels
if (graph.InDegree(node) == 0 || graph.OutDegree(node) == 0)
{
foreach (var label in node.Labels)
{
if (IsNodeLabelAffected(label, adapter, layoutOnlySelection))
{
var labelBounds = label.GetLayout().GetBounds();
if (graph.InDegree(node) == 0)
{
left = Math.Max(left, labelBounds.Width);
top = Math.Max(top, labelBounds.Height);
}
if (graph.OutDegree(node) == 0)
{
right = Math.Max(right, labelBounds.Width);
bottom = Math.Max(bottom, labelBounds.Height);
}
}
}
}
nodeHalos[node] = NodeHalo.Create(top, left, bottom, right);
}
adapter.AddDataProvider(NodeHalo.NodeHaloDpKey, nodeHalos);
}
public static InputInfo CreateInputClassInfo(XPDictionary outputDictionary, string inputPutClass, params ColumnInfo[] columnInfos)
{
var table = CreateDbTable(inputPutClass, columnInfos);
var dataSet = new DataSet();
var inputUnitOfWork = new UnitOfWork(new SimpleDataLayer(new DataSetDataStore(dataSet, AutoCreateOption.DatabaseAndSchema)));
var dictionaryMapper = new DictionaryMapper(new[] { table });
dictionaryMapper.Map(outputDictionary, inputUnitOfWork.Dictionary);
var classInfo = inputUnitOfWork.Dictionary.QueryClassInfo(null, inputPutClass);
return(new InputInfo(classInfo, inputUnitOfWork, dataSet));
}
public void Ctor_Dictionary_ReturnsExpected()
{
var mapping = new Dictionary <string, object> {
{ "key", "value" }
};
var comparer = StringComparer.CurrentCulture;
var item = new DictionaryMapper <object>(mapping, comparer);
Dictionary <string, object> itemMapping = Assert.IsType <Dictionary <string, object> >(item.MappingDictionary);
Assert.Equal(mapping, itemMapping);
Assert.Same(comparer, itemMapping.Comparer);
}
private async void OnLoaded(object sender, EventArgs e)
{
InitializeInteraction();
configOptionsValid = true;
SetUiDisabled(false);
incrementalNodesMapper = new DictionaryMapper <INode, bool> {
DefaultValue = false
};
var samples = new[] {
new Sample("Sample: Minimum Spanning Tree", "MinimumSpanningTree"),
new Sample("Sample: Connected Components", "Connectivity"),
new Sample("Sample: Biconnected Components", "Connectivity"),
new Sample("Sample: Strongly Connected Components", "Connectivity"),
new Sample("Sample: Reachability", "Connectivity"),
new Sample("Sample: Shortest Paths", "Paths"),
new Sample("Sample: All Paths", "Paths"),
new Sample("Sample: All Chains", "Paths"),
new Sample("Sample: Single Source", "Paths"),
new Sample("Sample: Cycles", "Cycles"),
new Sample("Sample: Degree Centrality", "Centrality"),
new Sample("Sample: Weight Centrality", "Centrality"),
new Sample("Sample: Graph Centrality", "Centrality"),
new Sample("Sample: Node Edge Betweenness Centrality", "Centrality"),
new Sample("Sample: Closeness Centrality", "Centrality"),
new Sample("Sample: Independent Sets", "MinimumSpanningTree")
};
sampleComboBox.ComboBox.DataSource = samples;
sampleComboBox.SelectedIndex = 0;
directionComboBox.ComboBox.Enabled = false;
directionComboBox.SelectedIndex = 0;
uniformEdgeWeightsComboBox.ComboBox.Enabled = false;
uniformEdgeWeightsComboBox.SelectedIndex = 0;
RegisterCommands();
InitializeGraph();
UpdateGraphInformation();
preventLayout = true;
InitializeAlgorithms();
mIsInitializing = false;
await RunLayout(false, true, true);
}
public void GetProperty_ValidStringValue_ReturnsSuccess(string stringValue, PropertyMapperResultType expectedType, object expectedValue)
{
var mapping = new Dictionary <string, object> {
{ "key", "value" }, { "KEY2", 10 }
};
var comparer = StringComparer.OrdinalIgnoreCase;
var item = new DictionaryMapper <object>(mapping, comparer);
object value = null;
PropertyMapperResultType result = item.GetProperty(new ReadCellValueResult(-1, stringValue), ref value);
Assert.Equal(expectedType, result);
Assert.Equal(expectedValue, value);
}
/// <summary>
/// Creates and configures the graph that is used for the placer configuration preview.
/// </summary>
private void SetupPreview()
{
IGraph graph = previewControl.Graph;
DictionaryMapper <INode, bool> assistantMap =
graph.MapperRegistry.CreateMapper <INode, bool>(AssistantNodePlacer.AssistantNodeDpKey);
graph.NodeDefaults.Size = new SizeD(40, 30);
graph.NodeDefaults.Style = new ShinyPlateNodeStyle
{
Brush = Brushes.LightGray,
Insets = new InsetsD(5),
DrawShadow = false,
Pen = Pens.Black
};
var rootStyle = new ShinyPlateNodeStyle
{
Brush = Brushes.Red,
Insets = new InsetsD(5),
Pen = Pens.Black,
DrawShadow = false
};
var assistantStyle = new ShinyPlateNodeStyle
{
Brush = Brushes.LightGray,
Insets = new InsetsD(5),
Pen = new Pen(Brushes.Black, 1)
{
DashStyle = DashStyles.Dash
},
DrawShadow = false
};
INode root = graph.CreateNode();
graph.SetStyle(root, rootStyle);
INode n1 = graph.CreateNode();
graph.SetStyle(n1, assistantStyle);
assistantMap[n1] = true;
INode n2 = graph.CreateNode();
INode n3 = graph.CreateNode();
INode n4 = graph.CreateNode();
INode n5 = graph.CreateNode(new RectD(0, 0, 60, 30));
graph.CreateEdge(root, n1);
graph.CreateEdge(root, n2);
graph.CreateEdge(root, n3);
graph.CreateEdge(root, n4);
graph.CreateEdge(root, n5);
previewLayout = new TreeLayout();
}
public ObservableCollection <RefTypeModel> GetRefTypeModels()
{
var request = PrepareRequest(new RefTypeRequest());
request.LoadOptions = new[] { "RefTypes" };
var response = RefTypeClient.GetRefTypes(request);
if (response.Acknowledge != AcknowledgeType.Success)
{
throw new ApplicationException(response.Message);
}
return(DictionaryMapper.FromDataTransferObjects(response.RefTypes));
}
public IActionResult Get([FromRoute] long id)
{
IResult <Dictionary> result = _queryBus.Send <DictionaryGetByIdQuery, Dictionary>(new DictionaryGetByIdQuery(id));
if (!result.IsValid())
{
var Error = (InvalidResult <Dictionary>)result;
return(BadRequest(Error.Errors));
}
var Success = (SuccessResult <Dictionary>)result;
Dictionary dictionary = Success.Data;
return(Ok(DictionaryMapper.MapToReadModel(dictionary)));
}
public IActionResult GetMany([FromQuery] int amount = 20, [FromQuery] int pages = 1)
{
IResult <List <Dictionary> > result = _queryBus.Send <DictionaryGetManyQuery, List <Dictionary> >(new DictionaryGetManyQuery(amount, pages));
if (!result.IsValid())
{
var Error = (InvalidResult <List <Dictionary> >)result;
return(BadRequest(Error.Errors));
}
var Success = (SuccessResult <List <Dictionary> >)result;
List <Dictionary> dictionaries = Success.Data;
return(Ok(dictionaries.Select(x => DictionaryMapper.MapToReadModel(x))));
}
///<summary>
/// Random graph generator in case multiple edges are allowed.
///</summary>
private void GenerateMultipleGraph(IGraph G)
{
int n = NodeCount;
int m = EdgeCount;
IMapper <IPortOwner, int> index = new DictionaryMapper <IPortOwner, int>();
int[] deg = new int[n];
INode[] V = new INode[n];
for (int i = 0; i < n; i++)
{
V[i] = G.CreateNode();
index[V[i]] = i;
}
for (int i = 0; i < m; i++)
{
deg[random.Next(n)]++;
}
for (int i = 0; i < n; i++)
{
INode v = V[i];
int d = deg[i];
while (d > 0)
{
int j = random.Next(n);
if (j == i && (!AllowCycles || !AllowSelfLoops))
{
continue;
}
G.CreateEdge(v, V[j]);
d--;
}
}
if (!AllowCycles)
{
foreach (IEdge edge in G.Edges)
{
IPort sourcePort = edge.SourcePort;
IPort targetPort = edge.TargetPort;
if (index[sourcePort.Owner] > index[targetPort.Owner])
{
G.SetEdgePorts(edge, targetPort, sourcePort);
}
}
}
}
///<summary>
/// Random graph generator for sparse graphs.
///</summary>
private void GenerateSparseGraph(IGraph G)
{
G.Clear();
IMapper <IPortOwner, int> index = new DictionaryMapper <IPortOwner, int>();
int n = NodeCount;
int m = Math.Min(GetMaxEdges(), EdgeCount);
INode[] V = new INode[n];
for (int i = 0; i < n; i++)
{
V[i] = G.CreateNode();
index[V[i]] = i;
}
RandomSupport.Permutate(random, V);
int count = m;
while (count > 0)
{
int vi = random.Next(n);
INode v = V[vi];
INode w = V[random.Next(n)];
if (G.GetEdge(v, w) != null || (v == w && (!AllowSelfLoops || !AllowCycles)))
{
continue;
}
G.CreateEdge(v, w);
count--;
}
if (!AllowCycles)
{
foreach (IEdge edge in G.Edges)
{
IPort sourcePort = edge.SourcePort;
IPort targetPort = edge.TargetPort;
if (index[sourcePort.Owner] > index[targetPort.Owner])
{
G.SetEdgePorts(edge, targetPort, sourcePort);
}
}
}
}
/// <summary>
/// Wires up the UI components.
/// </summary>
public ComponentDragAndDropForm()
{
InitializeComponent();
// load description
description.LoadFile(new MemoryStream(Properties.Resources.description), RichTextBoxStreamType.RichText);
// set commands to buttons and menu items
undoButton.SetCommand(Commands.Undo, graphControl);
redoButton.SetCommand(Commands.Redo, graphControl);
zoomInButton.SetCommand(Commands.IncreaseZoom, graphControl);
zoomOutButton.SetCommand(Commands.DecreaseZoom, graphControl);
zoomFitButton.SetCommand(Commands.FitContent, graphControl);
graphComponents = new DictionaryMapper <INode, object>();
}
public void ShouldMapTypeByDictionary()
{
var source = new Dictionary <string, int>();
source.Add("Prop", 1);
source.Add("Prop2", 1);
source.Add("Prop3", 1);
var mapper = new DictionaryMapper <int, ClassW4Properties>();
var dest = mapper.Map(source);
Assert.IsNotNull(dest);
Assert.AreEqual(source["Prop"], dest.Prop);
Assert.AreEqual(source["Prop2"], dest.Prop2);
Assert.AreEqual(source["Prop3"], dest.Prop3);
}
private void ReadSampleGraph()
{
string fileName = string.Format("Resources" + Path.DirectorySeparatorChar + "{0}.graphml", graphChooserBox.SelectedItem.ToString());
DictionaryMapper <IGraph, string> descriptionMapper = new DictionaryMapper <IGraph, string>();
graphControl.Graph.Clear();
var ioHandler = new GraphMLIOHandler();
ioHandler.AddRegistryInputMapper <INode, string>("Description");
ioHandler.AddRegistryInputMapper <INode, string>("ToolTip");
ioHandler.AddRegistryInputMapper <INode, string>("Url");
ioHandler.AddInputMapper <IGraph, string>("GraphDescription", descriptionMapper);
ioHandler.Read(graphControl.Graph, fileName);
graphDescriptionTextBlock.Text = descriptionMapper[graphControl.Graph.GetFoldingView().Manager.MasterGraph] ?? string.Empty;
graphControl.FitGraphBounds(new InsetsD(10));
}
public void WithMapping_ValidReader_Success()
{
var dictionaryMapping = new Dictionary <string, DateTime> {
{ "key", DateTime.MinValue }
};
StringComparer comparer = StringComparer.CurrentCultureIgnoreCase;
SingleExcelPropertyMap <DateTime> propertyMap = Map(t => t.DateValue);
Assert.Same(propertyMap, propertyMap.WithMapping(dictionaryMapping, comparer));
DictionaryMapper <DateTime> item = propertyMap.CellValueMappers.OfType <DictionaryMapper <DateTime> >().Single();
Assert.NotSame(dictionaryMapping, item.MappingDictionary);
Assert.Equal(dictionaryMapping, item.MappingDictionary);
Assert.Same(comparer, Assert.IsType <Dictionary <string, DateTime> >(item.MappingDictionary).Comparer);
}
/// <summary>
/// Initializes the graph instance, setting default styles
/// and creating a small sample graph.
/// </summary>
protected virtual void InitializeGraph()
{
// create the manager for the folding operations
FoldingManager foldingManager = new FoldingManager();
// create a view
foldingView = foldingManager.CreateFoldingView();
// and set it to the GraphControl
graphControl.Graph = foldingView.Graph;
// decorate the behavior of nodes
NodeDecorator nodeDecorator = graphControl.Graph.GetDecorator().NodeDecorator;
// adjust the insets so that labels are considered
nodeDecorator.InsetsProviderDecorator.SetImplementationWrapper(
delegate(INode node, INodeInsetsProvider insetsProvider) {
if (insetsProvider != null)
{
InsetsD insets = insetsProvider.GetInsets(node);
return(new LabelInsetsProvider(insets));
}
else
{
return(new LabelInsetsProvider());
}
});
//Constrain group nodes to at least the size of their labels
nodeDecorator.SizeConstraintProviderDecorator.SetImplementationWrapper(
(node, oldImpl) => new LabelSizeConstraintProvider(oldImpl));
fixedGroupNodeLayout = graphControl.Graph.MapperRegistry.CreateMapper <INode, RectD?>("NodeLayouts");
ReadSampleGraph();
incrementalNodes.UnionWith(graphControl.Graph.Nodes);
}
/// <summary>
/// Wires up the UI components.
/// </summary>
public ComponentDragAndDropDemo()
{
InitializeComponent();
components = new DictionaryMapper <INode, object>();
}
private void LoadDefaults(string uri)
{
Style accordionStyle = (Style)Application.Current.Resources["AccordionItemStyle"];
IMapper <string, HeaderedContentControl> accordionItems = new DictionaryMapper <string, HeaderedContentControl>();
{
var graph = new DefaultGraph();
try {
new GraphMLIOHandler().Read(graph, uri);
} catch (Exception) {
return;
}
List <StyleChooser> nodeChoosers = new List <StyleChooser>();
foreach (var node in graph.Nodes)
{
string tag = (string)(node.Tag ?? "Other");
if ("Dummy" == tag)
{
continue;
}
HeaderedContentControl accordionItem = accordionItems[tag];
if (null == accordionItem)
{
accordionItem = new Expander()
{
Style = accordionStyle
};
accordionItem.Header = tag;
accordionItems[tag] = accordionItem;
StyleChooserAccordion.Items.Add(accordionItem);
var styleChooser = new StyleChooser();
styleChooser.ItemType = typeof(INodeStyle);
styleChooser.ItemsSource = new ObservableCollection <INode>();
styleChooser.SelectionChanged += delegate(object sender, SelectionChangedEventArgs args) {
if (args.AddedItems.Count > 0)
{
foreach (var n in nodeChoosers)
{
if (n != sender)
{
n.Deselect();
}
}
}
};
styleChooser.SelectionChanged += OnSelectionChanged;
nodeChoosers.Add(styleChooser);
accordionItem.Content = styleChooser;
styleChooser.HorizontalAlignment = HorizontalAlignment.Stretch;
}
StyleChooser chooser = (StyleChooser)accordionItem.Content;
ObservableCollection <INode> itemSource = (ObservableCollection <INode>)chooser.ItemsSource;
itemSource.Add(node);
}
var nodeChooser = nodeChoosers.FirstOrDefault();
if (nodeChooser != null)
{
nodeChooser.SelectFirst();
}
HeaderedContentControl edgeTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
edgeTypesAccordionItem.Header = "Edge Types";
StyleChooserAccordion.Items.Add(edgeTypesAccordionItem);
var edgeStyleChooser = new StyleChooser();
edgeStyleChooser.ItemType = typeof(IEdgeStyle);
var edgeStyles = new ObservableCollection <IEdgeStyle>();
edgeStyleChooser.ItemsSource = edgeStyles;
edgeStyleChooser.SelectionChanged += OnSelectionChanged;
edgeTypesAccordionItem.Content = edgeStyleChooser;
foreach (var edge in graph.Edges)
{
edgeStyles.Add(edge.Style);
}
edgeStyleChooser.SelectFirst();
var labelTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
labelTypesAccordionItem.Header = "Label Types";
StyleChooserAccordion.Items.Add(labelTypesAccordionItem);
var labelStyleChooser = new StyleChooser();
labelStyleChooser.ItemType = typeof(ILabelStyle);
var labelStyles = new ObservableCollection <ILabelStyle>();
labelStyleChooser.ItemsSource = labelStyles;
labelTypesAccordionItem.Content = labelStyleChooser;
labelStyleChooser.SelectionChanged += OnSelectionChanged;
foreach (var label in graph.Labels)
{
if (label.Owner is INode && Equals("Dummy", label.Owner.Tag))
{
var style = label.Style;
if (style is NodeStyleLabelStyleAdapter)
{
// unwrap from NodeStyleLabelStyleAdapter
style = ((NodeStyleLabelStyleAdapter)style).LabelStyle;
}
// adjust the default flow direction of SimpleLabelStyles to the flowdirection of the current application.
if (style is DefaultLabelStyle)
{
((DefaultLabelStyle)style).FlowDirection = this.FlowDirection;
}
if (style is LabelStyle)
{
((LabelStyle)style).FlowDirection = this.FlowDirection;
}
labelStyles.Add(label.Style);
}
}
labelStyleChooser.SelectFirst();
var portTypesAccordionItem = new Expander()
{
Style = accordionStyle
};
portTypesAccordionItem.Header = "Port Types";
StyleChooserAccordion.Items.Add(portTypesAccordionItem);
var portStyleChooser = new StyleChooser();
portStyleChooser.ItemType = typeof(IPortStyle);
var portStyles = new ObservableCollection <IPortStyle>();
portStyleChooser.ItemsSource = portStyles;
portTypesAccordionItem.Content = portStyleChooser;
portStyleChooser.SelectionChanged += OnSelectionChanged;
foreach (var port in graph.Ports)
{
if (Equals("Dummy", port.Owner.Tag) && port.Tag != null)
{
portStyles.Add(port.Style);
}
}
// clear tags except for group nodes - no one needs them....
foreach (var node in graph.Nodes)
{
if (!Equals("Group Nodes", node.Tag))
{
node.Tag = null;
}
}
foreach (var edge in graph.Edges)
{
edge.Tag = null;
}
}
}
public void DictionaryMapper_Success()
{
var converters = new Dictionary <string, IConverter>();
var converterConfig1 = new ConverterConfiguration()
{
Id = ID_CONVERTER_1,
};
var converter1 = new AllUpperCaseConverter();
converter1.Configure(converterConfig1);
converters.Add(converter1.Id, converter1);
var leftSideMap1 = new Dictionary <string, List <string> >()
{
{ "FirstName", new List <string>()
{
"FirstName"
} }
};
// Create the converters we are targeting
var targetConverters = new List <SourceTargetConverter>();
targetConverters.Add(new SourceTargetConverter()
{
Id = ID_CONVERTER_1, LeftSideMap = leftSideMap1, CombineInputOutput = false
});
// Now create the targeted mapping
var targetMappings = new List <SourceTargetMapping>();
targetMappings.Add(new SourceTargetMapping()
{
PrimaryKey = "FirstName",
TargetConverters = targetConverters
});
var mapperConfig = new MapperConfiguration()
{
Id = "1234",
TransformerId = "6678",
SourceTargetMappings = targetMappings,
DataType = TYPE_MOCKUSER
};
var mapper = new DictionaryMapper();
mapper.Configure(mapperConfig, converters);
var dataToConvert = new Dictionary <string, object>()
{
{ "FirstName", "Jane" },
{ "LastName", "Doe" },
{ "Email", "*****@*****.**" },
{ "LastLogin", "06-25-2018 09:03:45.123456" }
};
var dataPoint = new KeyValuePair <string, object>("AD User", dataToConvert);
var dataRow = new EntityCollection();
dataRow.Entities.Add(dataPoint.Key, dataPoint.Value);
var data = mapper.Map(new List <IEntityCollection> {
dataRow
});
data.Count.Should().Be(1);
var user = data[0] as MockUser;
user.FirstName.Should().Be("JANE");
}
/// <summary>
/// Initializes the graph from the supplied GraphML file and creates the model from it.
/// </summary>
/// <remarks>
/// While this reads the graph from a GraphML file and constructs the model from an already-finished graph, a
/// real-world application would likely create the model from whichever data source is available and then create
/// the graph from it.
/// </remarks>
private void InitGraphAndModel()
{
var graph = new DefaultGraph
{
NodeDefaults = { Style = new NodeControlNodeStyle("NodeStyle")
{
OutlineShape = new Ellipse()
} },
EdgeDefaults = { Style = new EdgeSegmentControlEdgeStyle("EdgeStyle") }
};
var ioh = new GraphMLIOHandler();
// Parse node kinds and other info
IMapper <INode, NodeKind> nodeKinds = new DictionaryMapper <INode, NodeKind>();
IMapper <INode, NodeInfo> nodeInfos = new DictionaryMapper <INode, NodeInfo>();
ioh.AddInputMapper("NetworkMonitoring.NodeKind", nodeKinds);
ioh.AddInputMapper("NetworkMonitoring.NodeInfo", nodeInfos);
ioh.Read(graph, @"Resources\network.graphml");
foreach (var node in graph.Nodes)
{
// Create and attach the model node to the graph node.
var modelNode = new ModelNode
{
Name = nodeInfos[node].Name,
Ip = nodeInfos[node].Ip,
Enabled = true,
Kind = nodeKinds[node]
};
node.Tag = modelNode;
// Add the label
var label = graph.AddLabel(node, "", FreeLabelModel.Instance.CreateDefaultParameter(), nodeLabelStyle, tag: modelNode);
// Attach event handler for changing label visibility, so that the graph redraws accordingly.
// Since visibility can change via clicking on the node *and* from within the label, we have to use an event
// handler on the model node here.
modelNode.PropertyChanged += delegate(object sender, PropertyChangedEventArgs args) {
if (args.PropertyName == "LabelVisible")
{
GraphControl.Invalidate();
}
};
}
foreach (var edge in graph.Edges)
{
// Create and attach the model edge to the graph edge
var modelEdge = new ModelEdge
{
Source = (ModelNode)edge.GetSourceNode().Tag,
Target = (ModelNode)edge.GetTargetNode().Tag
};
edge.Tag = modelEdge;
// Add the edge label
var label = graph.AddLabel(edge, "", NinePositionsEdgeLabelModel.CenterCentered, edgeLabelStyle, tag: modelEdge);
}
// Create the mappings from model items to graph elements.
modelNodeToINode = graph.Nodes.ToDictionary(node => (ModelNode)node.Tag);
modelEdgeToIEdge = graph.Edges.ToDictionary(edge => (ModelEdge)edge.Tag);
model = new NetworkModel(modelNodeToINode.Keys, modelEdgeToIEdge.Keys);
GraphControl.Graph = graph;
}
/// <summary>
/// Set up the input mode and other aspects of interaction.
/// </summary>
private void InitializeInteraction()
{
incrementalElements = new DictionaryMapper <INode, bool> {
DefaultValue = false
};
var inputMode = new GraphEditorInputMode {
ShowHandleItems = GraphItemTypes.Bend | GraphItemTypes.Edge | GraphItemTypes.Label | GraphItemTypes.Port,
AllowAddLabel = false
};
// deletion: notify configuration about removed elements and remove the elements from the maps, too
inputMode.DeletingSelection += (sender, e) => {
var selection = (IGraphSelection)e.Selection;
CurrentConfig.EdgeRemoved = true;
var graph = e.Context.GetGraph();
foreach (var node in selection.SelectedNodes)
{
foreach (var edge in graph.EdgesAt(node))
{
if (!selection.IsSelected(edge.Opposite(node)))
{
incrementalNodesMapper[(INode)edge.Opposite(node)] = true;
}
}
}
foreach (var edge in selection.SelectedEdges)
{
if (!selection.IsSelected(edge.GetSourceNode()))
{
incrementalNodesMapper[edge.GetSourceNode()] = true;
incrementalElements[edge.GetSourceNode()] = true;
}
if (!selection.IsSelected(edge.GetTargetNode()))
{
incrementalNodesMapper[edge.GetTargetNode()] = true;
incrementalElements[edge.GetTargetNode()] = true;
}
}
CurrentConfig.IncrementalElements = incrementalElements;
};
// after deletion: update the graph information panel
// and run a layout and the current algorithm
inputMode.DeletedSelection += async(sender, e) => {
UpdateGraphInformation();
await RunLayout(true, false, true);
};
// edge creation: update the graph information panel
// and add the new edge to the elements to be updated;
// run a new layout and a new algorithm
inputMode.CreateEdgeInputMode.EdgeCreated += async(sender, e) => {
UpdateGraphInformation();
var edge = e.Item;
incrementalNodesMapper[edge.GetSourceNode()] = true;
incrementalNodesMapper[edge.GetTargetNode()] = true;
incrementalElements[edge.GetSourceNode()] = true;
incrementalElements[edge.GetTargetNode()] = true;
CurrentConfig.IncrementalElements = incrementalElements;
await RunLayout(true, false, true);
};
// same for new nodes
inputMode.NodeCreated += (sender, e) => {
UpdateGraphInformation();
incrementalElements[e.Item] = true;
CurrentConfig.IncrementalElements = incrementalElements;
// prevent a new layout from starting and disable the UI's buttons
inLayout = true;
SetUiDisabled(true);
ApplyAlgorithm();
// permit a new layout to start and enable the UI's buttons
ReleaseLocks();
SetUiDisabled(false);
};
inputMode.LabelTextChanged += (sender, e) => {
// prevent a new layout from starting and disable the UI's buttons
inLayout = true;
SetUiDisabled(true);
ApplyAlgorithm();
// permit a new layout to start and enable the UI's buttons
ReleaseLocks();
SetUiDisabled(false);
};
// also we add a context menu
inputMode.ContextMenuItems = GraphItemTypes.Node;
inputMode.ContextMenuInputMode.ClearMenu = true;
inputMode.PopulateItemContextMenu += (o, args) => {
if (CurrentConfig != null && configOptionsValid && !inLayout)
{
CurrentConfig.PopulateContextMenu(args);
}
};
graphControl.InputMode = inputMode;
}
