private void addParentIdColumns(DiscoverQuery dq, DataTable dt, XmlNode n)
{
XmlNode myNode = n;
xmlaElement e;
while (myNode.ParentNode != null)
{
myNode = myNode.ParentNode;
e = dq.Elements.FindByName(myNode.Name);
foreach (XmlNode innerNode in myNode.ChildNodes)
{
if (innerNode.Name == "ID")
{
dt.Columns.Add(PARENT_PREFIX + myNode.Name + "ID");
}
//TODO - coonverting the .Contains call to BinarySearch would
// allow for the injection of a custom implementation of IComparer
// in order to do a case insensitive search.
if (e != null &&
e.Fields.Contains(innerNode.Name) &&
!dt.Columns.Contains(myNode.Name + innerNode.Name))
{
dt.Columns.Add(myNode.Name + innerNode.Name);
}
}
}
}
protected DiscoveryResponse Handle(DiscoverQuery message)
{
var pinNumber = message.AsInt(MessageProperties.PinNumber);
bool pinInWriteMode = IsPinInWriteMode(pinNumber);
return(new DiscoveryResponse(RequierdProperties(), pinInWriteMode ? new PowerState(ReadWriteMode.Write) : new PowerState(ReadWriteMode.Read)));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
return(new DiscoveryResponse(RequierdProperties(), new PowerState(),
new VolumeState()
));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
return(new DiscoveryResponse(RequierdProperties(), new PowerState(ReadWriteMode.Write),
new VolumeState(ReadWriteMode.Write),
new MuteState(ReadWriteMode.Write),
new InputSourceState(ReadWriteMode.Write)
));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
return(new DiscoveryResponse(RequierdProperties(), new PowerState(),
new VolumeState(),
new MuteState(),
new InputSourceState(),
new SurroundSoundState(),
new DescriptionState()
));
}
private void RegisterPinNumber(DiscoverQuery message)
{
var pin = message.AsByte(MessageProperties.PinNumber);
var registrationMessage = new byte[] { 1, pin };
if (!_state.ContainsKey(pin))
{
_state.Add(pin, 0);
}
MessageBroker.SendToService(I2cCommand.Create(_i2cAddress, registrationMessage));
}
private void EnsureExplicitLeafColumnsExist(DiscoverQuery dq, DataTable dt, XmlNode n)
{
foreach (var ele in dq.Elements)
{
if (ele.Next != null)
{
continue;
}
foreach (var fld in ele.Fields)
{
if (dt.Columns.Contains(fld))
{
continue;
}
dt.Columns.Add(fld);
}
}
}
private void addParentIdValues(DiscoverQuery dq, DataTable dt, string[] data, XmlNode fld)
{
int colIdx = -1;
XmlNode myNode;
myNode = fld;
xmlaElement e;
while (myNode.ParentNode != null)
{
myNode = myNode.ParentNode;
e = dq.Elements.FindByName(myNode.Name);
foreach (XmlNode innerNode in myNode.ChildNodes)
{
if (innerNode.Name == "ID")
{
colIdx = dt.Columns.IndexOf(PARENT_PREFIX + myNode.Name + "ID");
if (colIdx > -1)
{
data[colIdx] = innerNode.FirstChild.Value;
}
}
//TODO - coonverting the .Contains call to BinarySearch would
// allow for the injection of a custom implementation of IComparer
// in order to do a case insensitive search.
if (e != null && e.Fields.Contains(innerNode.Name))
{
colIdx = dt.Columns.IndexOf(myNode.Name + innerNode.Name);
if (colIdx > -1)
{
data[colIdx] = innerNode.FirstChild.Value;
}
}
}
}
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
RegisterPinNumber(message);
return(new DiscoveryResponse(RequierdProperties(), new HumidityState(ReadWriteMode.Read)));
}
private async Task InitializeAdapters()
{
var discoveryRequests = (await _adapters.WhenAll(adapter => MessageBroker.Request <DiscoverQuery, DiscoveryResponse>(DiscoverQuery.CreateQuery(adapter), adapter.Uid)).ConfigureAwait(false));
foreach (var discovery in discoveryRequests)
{
discovery.Input.AddRequierdProperties(discovery.Result.RequierdProperties);
Subscribe <Event>(discovery.Input.GetRoutingFilter());
}
_componentState = new ComponentState(discoveryRequests.ToDictionary(k => k.Input, v => v.Result));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
RegisterPinNumber(message);
return(new DiscoveryResponse(RequierdProperties(), new CurrentState()));
}
public DataTable Parse(XmlDocument doc, string filter, bool prepareOnly, string whereClause)
{
DiscoverQuery dq;
DataTable dt = new DataTable();
string[] elements;
elements = filter.Split((@"\").ToCharArray());
dq = new DiscoverQuery(elements);
XmlNodeList e;
// We basically grab all the elements that match the last
// item type in the path. So if you ask for '\Database\Dimensions\Dimension'
// we get all the 'Dimension' elements and then in the next step we
// spin through them to see if they are under the appropriate
// parent elements.
//e = doc.GetElementsByTagName(elements[elements.Length - 1]);
e = doc.GetElementsByTagName(dq.Elements.Last.Value.Name);
/*
* Get elements matching last item in the filter
* work up the parentNode properties, making sure
* that they match the path.
*/
List <XmlNode> finalList = new List <XmlNode>();
for (int i = 0; i < e.Count; i++)
{
Context.CheckCancelled();
XmlNode node = e.Item(i);
XmlNode parentNode = node;
xmlaElement xe = dq.Elements.Last.Value;
while (xe != null)
{
parentNode = parentNode.ParentNode;
if (xe.Previous != null &&
string.Compare(parentNode.Name, xe.Previous.Name, true) != 0) // Case insensitive compare
{
break;
}
else if (xe.Previous == null)
{
finalList.Add(node);
}
xe = xe.Previous;
}
}
// Now we generate the data table based on the data in one of the nodes
bool tableBuilt = false;
foreach (XmlNode n in finalList)
{
if (!tableBuilt)
{
// Only build the table based on this node if it is not empty
// or if it is the last node in the collection
if ((n.HasChildNodes) || (finalList.IndexOf(n) == finalList.Count))
{
foreach (XmlNode fld in n.ChildNodes)
{
Context.CheckCancelled();
//TODO - coonverting the .Contains call to BinarySearch would
// allow for the injection of a custom implementation of IComparer
// in order to do a case insensitive search.
if (fld.NodeType == XmlNodeType.Element &&
(!fld.HasChildNodes ||
(fld.HasChildNodes &&
(fld.ChildNodes.Count == 1) &&
(fld.FirstChild.NodeType == XmlNodeType.Text)
)
) &&
(!dt.Columns.Contains(fld.Name)))
{
// Only add nodes that are elements and have 0 or 1 children (do not add collections)
dt.Columns.Add(new DataColumn(fld.Name));
}
}
// Add attributes from last node
if (n.Attributes.Count > 0)
{
foreach (XmlAttribute xa in n.Attributes)
{
dt.Columns.Add(n.LocalName + "." + xa.LocalName);
}
}
addParentIdColumns(dq, dt, n);
tableBuilt = true;
// If this is a prepare call, we only need to return an empty table
//if (prepareOnly)
//{
// return dt;
//}
}
}
}
// loop throught the collection of nodes again to populate the table
foreach (XmlNode n in finalList)
{
DataRow dr = dt.NewRow();
string[] data = new string[dr.ItemArray.Length];
foreach (XmlNode fld in n.ChildNodes)
{
Context.CheckCancelled();
if ((dr.Table.Columns.IndexOf(fld.Name) >= 0) &&
(fld.HasChildNodes && fld.ChildNodes.Count == 1))
{
data[dr.Table.Columns.IndexOf(fld.Name)] = fld.FirstChild.InnerText;
}
addParentIdValues(dq, dt, data, fld);
}
if (!n.HasChildNodes)
{
// we have found a empty node, just add any ancestor fields
addParentIdValues(dq, dt, data, n);
}
// Extract Attributes
if (n.Attributes.Count > 0)
{
foreach (XmlAttribute xa in n.Attributes)
{
data[dr.Table.Columns.IndexOf(n.LocalName + "." + xa.LocalName)] = xa.Value;
}
}
dr.ItemArray = data;
dt.Rows.Add(dr);
}
if (whereClause.Length > 0)
{
dt.DefaultView.RowFilter = whereClause;
dt = dt.DefaultView.ToTable();
}
return(dt);
}
protected DiscoveryResponse Handle(DiscoverQuery discoverQuery)
{
return(new DiscoveryResponse(new string[] { MessageProperties.PinNumber }, new PowerState()));
}
protected DiscoveryResponse Handle(DiscoverQuery discoverQuery)
{
return(new DiscoveryResponse(new PowerState()));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
return(new DiscoveryResponse(new PowerState()));
}
protected DiscoveryResponse Discover(DiscoverQuery message)
{
return(new DiscoveryResponse(new InfraredReceiverState(), new InfraredSenderState()));
}
