internal static string ValidateIdentifier(this string name, Action <TraceMessage> reportError)
{
if (!System.CodeDom.Compiler.CodeGenerator.IsValidLanguageIndependentIdentifier(name))
{
reportError(TraceMessage.BuildErrorTraceMessage(BuildError.WrongSymbolicName, String.Format("SymbolicName: '{0}'.", name)));
}
return(name);
}
/// <summary>
/// Imports a part of the OPC UA Address Space contained in the <see cref="UANodeSet" /> object model.
/// </summary>
/// <param name="model">The model to be imported.</param>
/// <exception cref="System.ArgumentNullException">model;the model cannot be null</exception>
void IAddressSpaceContext.ImportUANodeSet(UANodeSet model)
{
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("Entering AddressSpaceContextService.ImportUANodeSet - importing from object model."));
if (model == null)
{
throw new ArgumentNullException("model", "the model cannot be null");
}
ImportNodeSet(model);
}
private void Update(IDataTypeFactory nodeDesign, UADataType nodeSet)
{
nodeSet.Definition.GetParameters(nodeDesign.NewDefinition(), AS, Log.TraceEvent);
nodeDesign.DataTypePurpose = nodeSet.Purpose.ConvertToDataTypePurpose();
if (nodeSet.Purpose != XML.DataTypePurpose.Normal)
{
Log.TraceEvent(TraceMessage.DiagnosticTraceMessage($"DataTypePurpose value {nodeSet.Purpose } is not supported by the tool"));
}
}
private static AccessRestrictions ConvertToAccessRestrictions(byte accessRestrictions, string typeName, Action <TraceMessage> traceEvent)
{
if (accessRestrictions > 7)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongAccessLevel, $"The current value is {accessRestrictions} of the node type {typeName}. Assigned max value"));
return(AccessRestrictions.EncryptionRequired & AccessRestrictions.SessionRequired & AccessRestrictions.SigningRequired);
}
return((AccessRestrictions)accessRestrictions);
}
private void ValidateAndExportModel(int nameSpaceIndex)
{
IEnumerable <UANodeContext> _stubs = from _key in m_NodesDictionary.Values where _key.NodeIdContext.NamespaceIndex == nameSpaceIndex select _key;
//TODO ValidateAndExportModel shall export also instances #40
List <UANodeContext> _nodes = (from _node in _stubs where _node.UANode != null && (_node.UANode is UAType) select _node).ToList();
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(String.Format("AddressSpaceContext.ValidateAndExportModel - selected {0} nodes to be added to the model.", _nodes.Count)));
Validator.ValidateExportModel(_nodes, InformationModelFactory, this, m_TraceEvent);
}
private static void Update(IDataTypeFactory nodeDesign, UADataType nodeSet, IUAModelContext modelContext, Action <TraceMessage> traceEvent)
{
nodeSet.Definition.GetParameters(nodeDesign.NewDefinition(), modelContext, traceEvent);
nodeDesign.DataTypePurpose = nodeSet.Purpose.ConvertToDataTypePurpose();
if (nodeSet.Purpose != XML.DataTypePurpose.Normal)
{
traceEvent(TraceMessage.DiagnosticTraceMessage($"DataTypePurpose value {nodeSet.Purpose } is not supported by the tool"));
}
}
/// <summary>
/// Validates and exports the selected model.
/// </summary>
/// <param name="targetNamespace">The target namespace of the validated model.</param>
/// <exception cref="System.ArgumentOutOfRangeException">targetNamespace;Cannot find this namespace</exception>
void IAddressSpaceContext.ValidateAndExportModel(string targetNamespace)
{
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(string.Format("Entering IAddressSpaceContext.ValidateAndExportModel - starting for the {0} namespace.", targetNamespace)));
int _nsIndex = m_NamespaceTable.GetIndex(targetNamespace);
if (_nsIndex == -1)
{
throw new ArgumentOutOfRangeException("targetNamespace", "Cannot find this namespace");
}
ValidateAndExportModel(_nsIndex);
}
/// <summary>
/// Initializes a new instance of the <see cref="AddressSpaceContext" /> class.
/// </summary>
/// <param name="traceEvent">Encapsulates an action to trace the progress and validation issues.</param>
/// <exception cref="System.ArgumentNullException">traceEvent - cannot be null.</exception>
public AddressSpaceContext(Action <TraceMessage> traceEvent)
{
m_TraceEvent = traceEvent ?? throw new ArgumentNullException("traceEvent");
m_NamespaceTable = new NamespaceTable();
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("Entering AddressSpaceContext creator - starting creation the OPC UA Address Space."));
UANodeSet _standard = UANodeSet.ReadUADefinedTypes();
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("Address Space - the OPC UA defined has been uploaded."));
ImportNodeSet(_standard);
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("Address Space - has bee created successfully."));
}
//methods
/// <summary>
/// Gets or sets the name of the m browse.
/// </summary>
/// <value>The name of the m browse.</value>
private void TraceErrorUndefinedBaseType(NodeId target, bool type, Action <TraceMessage> traceEvent)
{
if (type)
{
string _msg = string.Format("BaseType of Id={0} for node {1}", target, this.BrowseName);
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.UndefinedHasSubtypeTarget, _msg));
}
else
{
string _msg = string.Format("TypeDefinition of Id={0} for node {1}", target, this.BrowseName);
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.UndefinedHasTypeDefinition, _msg));
}
}
private static FactoryType CreateNode <FactoryType, NodeSetType>
(
Func <FactoryType> createNode,
IUANodeBase nodeContext,
Action <FactoryType, NodeSetType> updateNode,
Action <FactoryType, NodeSetType, IUANodeBase, Action <TraceMessage> > updateBase,
Action <TraceMessage> traceEvent
)
where FactoryType : INodeFactory
where NodeSetType : UANode
{
FactoryType _nodeFactory = createNode();
nodeContext.CalculateNodeReferences(_nodeFactory);
NodeSetType _nodeSet = (NodeSetType)nodeContext.UANode;
XmlQualifiedName _browseName = nodeContext.ExportNodeBrowseName();
string _symbolicName;
if (string.IsNullOrEmpty(_nodeSet.SymbolicName))
{
_symbolicName = _browseName.Name.ValidateIdentifier(traceEvent); //TODO IsValidLanguageIndependentIdentifier is not supported by the .NET standard #340
}
else
{
_symbolicName = _nodeSet.SymbolicName.ValidateIdentifier(traceEvent); //TODO IsValidLanguageIndependentIdentifier is not supported by the .NET standard #340
}
_nodeFactory.BrowseName = _browseName.Name.ExportString(_symbolicName);
_nodeSet.Description.ExportLocalizedTextArray(_nodeFactory.AddDescription);
_nodeSet.DisplayName.Truncate(512, traceEvent).ExportLocalizedTextArray(_nodeFactory.AddDisplayName);
_nodeFactory.SymbolicName = new XmlQualifiedName(_symbolicName, _browseName.Namespace);
Action <uint, string> _doReport = (x, y) =>
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongWriteMaskValue, string.Format("The current value is {0:x} of the node type {1}.", x, y)));
};
_nodeFactory.WriteAccess = _nodeSet is UAVariable?_nodeSet.WriteMask.Validate(0x200000, x => _doReport(x, _nodeSet.GetType().Name)) : _nodeSet.WriteMask.Validate(0x400000, x => _doReport(x, _nodeSet.GetType().Name));
_nodeFactory.AccessRestrictions = ConvertToAccessRestrictions(_nodeSet.AccessRestrictions, _nodeSet.GetType().Name, traceEvent);
_nodeFactory.Category = _nodeSet.Category;
if (_nodeSet.RolePermissions != null)
{
traceEvent(TraceMessage.DiagnosticTraceMessage("RolePermissions is not supported. You must fix it manually."));
}
if (!string.IsNullOrEmpty(_nodeSet.Documentation))
{
traceEvent(TraceMessage.DiagnosticTraceMessage("Documentation is not supported. You must fix it manually."));
}
updateBase(_nodeFactory, _nodeSet, nodeContext, traceEvent);
updateNode(_nodeFactory, _nodeSet);
return(_nodeFactory);
}
private static void Update(IVariableInstanceFactory nodeDesign, UAVariable nodeSet, IUANodeBase nodeContext, Action <TraceMessage> traceEvent)
{
nodeDesign.AccessLevel = nodeSet.AccessLevel.GetAccessLevel(traceEvent);
nodeDesign.ArrayDimensions = nodeSet.ArrayDimensions.ExportString(string.Empty);
nodeDesign.DataType = nodeContext.ExportBrowseName(nodeSet.DataType, DataTypes.Number); //TODO add test case must be DataType, must not be abstract
nodeDesign.DefaultValue = nodeSet.Value; //TODO add test case must be of type defined by DataType
nodeDesign.Historizing = nodeSet.Historizing.Export(false);
nodeDesign.MinimumSamplingInterval = nodeSet.MinimumSamplingInterval.Export(0D);
nodeDesign.ValueRank = nodeSet.ValueRank.GetValueRank(traceEvent);
if (nodeSet.Translation != null)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NotSupportedFeature, "- the Translation element for the UAVariable"));
}
}
private static void Update(IReferenceTypeFactory nodeDesign, UAReferenceType nodeSet, Action <TraceMessage> traceEvent)
{
nodeSet.InverseName.ExportLocalizedTextArray(nodeDesign.AddInverseName);
nodeDesign.Symmetric = nodeSet.Symmetric;
if (nodeSet.Symmetric && (nodeSet.InverseName != null && nodeSet.InverseName.Where(x => !string.IsNullOrEmpty(x.Value)).Any()))
{
XML.LocalizedText _notEmpty = nodeSet.InverseName.Where(x => !string.IsNullOrEmpty(x.Value)).First();
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongInverseName, string.Format("If ReferenceType {0} is symmetric the InverseName {1}:{2} shall be omitted.", nodeSet.NodeIdentifier(), _notEmpty.Locale, _notEmpty.Value)));
}
else if (!nodeSet.Symmetric && !nodeSet.IsAbstract && (nodeSet.InverseName == null || !nodeSet.InverseName.Where(x => !string.IsNullOrEmpty(x.Value)).Any()))
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongInverseName, string.Format("If ReferenceType {0} is not symmetric and not abstract the InverseName shall be specified.", nodeSet.NodeIdentifier())));
}
}
/// <summary>
/// Imports a part of the OPC UA Address Space contained in the file <see cref="FileInfo" />.
/// </summary>
/// <param name="model">The model to be imported.</param>
/// <exception cref="System.IO.FileNotFoundException">The imported file does not exist</exception>
void IAddressSpaceContext.ImportUANodeSet(FileInfo model)
{
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("Entering AddressSpaceContextService.ImportUANodeSet - importing form file"));
if (model == null)
{
throw new ArgumentNullException("model", "the model cannot be null");
}
if (!model.Exists)
{
throw new FileNotFoundException("The imported file does not exist", model.FullName);
}
UANodeSet _nodeSet = UANodeSet.ReadModellFile(model);
ImportNodeSet(_nodeSet);
}
/// <summary>
/// Updates this instance in case the wrapped <see cref="UANode" /> is recognized in the model.
/// </summary>
/// <param name="node">The node <see cref="UANode" /> containing definition to be added to the model.</param>
/// <param name="addReference">Used to add new reference to the common collection of references.</param>
/// <exception cref="ArgumentException">node - Argument must not be null</exception>
public void Update(UANode node, Action <UAReferenceContext> addReference)
{
if (node == null)
{
throw new ArgumentException(nameof(node), $"Argument must not be null at {nameof(Update)} ");
}
if (this.UANode != null)
{
Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeIdDuplicated, string.Format("The {0} is already defined and is removed from further processing.", node.NodeId.ToString())));
return;
}
UANode = node;
this.BrowseName = node.BrowseName.Parse(Log.TraceEvent);
if (QualifiedName.IsNull(this.BrowseName))
{
NodeId _id = NodeId.Parse(UANode.NodeId);
this.BrowseName = new QualifiedName($"EmptyBrowseName_{_id.IdentifierPart}", _id.NamespaceIndex);
Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.EmptyBrowseName, $"New identifier {this.BrowseName} is generated to proceed."));
}
if (node.References == null)
{
return;
}
foreach (Reference _reference in node.References)
{
UAReferenceContext _newReference = new UAReferenceContext(_reference, this.m_AddressSpaceContext, this);
switch (_newReference.ReferenceKind)
{
case ReferenceKindEnum.Custom:
case ReferenceKindEnum.HasComponent:
case ReferenceKindEnum.HasProperty:
break;
case ReferenceKindEnum.HasModellingRule:
ModelingRule = _newReference.GetModelingRule();
break;
case ReferenceKindEnum.HasSubtype: //TODO Part 3 7.10 HasSubtype - add test cases #35
m_BaseTypeNode = _newReference.SourceNode;
break;
case ReferenceKindEnum.HasTypeDefinition: //Recognize problems with P3.7.13 HasTypeDefinition ReferenceType #39
m_BaseTypeNode = _newReference.TargetNode;
break;
}
addReference(_newReference);
}
}
private void Update(IPropertyInstanceFactory propertyInstance, UAVariable nodeSet, IUANodeBase nodeContext, UAReferenceContext parentReference)
{
try
{
Update(propertyInstance, nodeSet);
propertyInstance.ReferenceType = parentReference == null ? null : parentReference.GetReferenceTypeName();
if (!nodeContext.IsProperty)
{
Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongReference2Property, $"Creating Property {nodeContext.BrowseName}- wrong reference type {parentReference.ReferenceKind.ToString()}"));
}
}
catch (Exception _ex)
{
Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongReference2Property, string.Format("Cannot resolve the reference for Property because of error {0} at: {1}.", _ex, _ex.StackTrace)));
}
}
private static void Update(IVariableInstanceFactory variableInstance, UAVariable nodeSet, IUANodeBase nodeContext, UAReferenceContext parentReference, Action <TraceMessage> traceEvent)
{
try
{
Update(variableInstance, nodeSet, nodeContext, traceEvent);
variableInstance.ReferenceType = parentReference == null ? null : parentReference.GetReferenceTypeName();
if (nodeContext.IsProperty)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongReference2Variable, string.Format("Creating Variable - wrong reference type {0}", parentReference.ReferenceKind.ToString())));
}
}
catch (Exception _ex)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongReference2Property, string.Format("Cannot resolve the reference for Variable because of error {0} at: {1}.", _ex, _ex.StackTrace)));
}
}
private UANodeContext TryGetUANodeContext(NodeId nodeId, Action <TraceMessage> traceEvent)
{
UANodeContext _ret;
if (!m_NodesDictionary.TryGetValue(nodeId.ToString(), out _ret))
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeIdNotDefined, String.Format("References to node with NodeId: {0} is omitted during the import.", nodeId)));
return(null);
}
if (_ret.UANode == null)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeIdNotDefined, String.Format("NodeId: {0} is omitted during the import.", nodeId)));
return(null);
}
return(_ret);
}
/// <summary>
/// Initializes a new instance of the <see cref="AddressSpaceContext" /> class.
/// </summary>
/// <param name="traceEvent">Encapsulates an action to trace the progress and validation issues.</param>
/// <exception cref="System.ArgumentNullException">traceEvent - cannot be null.</exception>
public AddressSpaceContext(Action <TraceMessage> traceEvent)
{
if (traceEvent == null)
{
throw new ArgumentNullException("traceEvent");
}
m_NamespaceTable = new NamespaceTable(traceEvent);
m_TraceEvent = x => { };
traceEvent(TraceMessage.DiagnosticTraceMessage("Entering AddressSpaceContext creator - starting address space validation."));
UANodeSet _standard = UANodeSet.ReadUADefinedTypes();
Debug.Assert(_standard != null);
traceEvent(TraceMessage.DiagnosticTraceMessage("AddressSpaceContext - uploading the OPC UA defined types."));
ImportNodeSet(_standard);
m_TraceEvent = traceEvent;
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("AddressSpaceContext - has bee created successfully."));
}
/// <summary>
/// Updates this instance in case the wrapped <see cref="UANode"/> is recognized in the model.
/// </summary>
/// <param name="node">The node <see cref="UANode"/> containing definition to be added to the model.</param>
/// <param name="traceEvent">A delegate <see cref="Action{TraceMessage}"/> encapsulates an action to report any errors and trace processing progress.</param>
internal void Update(UANode node, Action <TraceMessage> traceEvent)
{
if (node == null)
{
return;
}
m_UAnode = node;
QualifiedName _broseName = node.BrowseName.Parse(traceEvent);
Debug.Assert(m_BrowseName != null);
if (QualifiedName.IsNull(_broseName))
{
NodeId _id = NodeId.Parse(UANode.NodeId);
_broseName = new QualifiedName(string.Format("EmptyBrowseName{0}", _id.IdentifierPart), _id.NamespaceIndex);
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.EmptyBrowseName, String.Format("New identifier {0} is generated to proceed.", _broseName)));
}
m_BrowseName = m_ModelContext.ImportQualifiedName(_broseName);
}
/// <summary>
/// Updates this instance in case the wrapped <see cref="UANode"/> is recognized in the model.
/// </summary>
/// <param name="node">The node <see cref="UANode"/> containing definition to be added to the model.</param>
void IUANodeContext.Update(UANode node)
{
if (node == null)
{
return;
}
UANode = node;
QualifiedName _broseName = node.BrowseName.Parse(BuildErrorsHandling.Log.TraceEvent);
Debug.Assert(BrowseName != null);
if (QualifiedName.IsNull(_broseName))
{
NodeId _id = NodeId.Parse(UANode.NodeId);
_broseName = new QualifiedName(string.Format("EmptyBrowseName{0}", _id.IdentifierPart), _id.NamespaceIndex);
BuildErrorsHandling.Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.EmptyBrowseName, string.Format("New identifier {0} is generated to proceed.", _broseName)));
}
BrowseName = UAModelContext.ImportQualifiedName(_broseName);
}
/// <summary>
/// Validates the selected nodes <paramref name="nodesCollection"/> and export it using <paramref name="exportModelFactory"/>.
/// </summary>
/// <param name="nodesCollection">The items <see cref="IEnumerable{IUANodeBase}" /> imported to the Address Space <see cref="IAddressSpaceContext" />.</param>
/// <param name="exportModelFactory">The model export factory.</param>
/// <param name="addressSpaceContext">The Address Space context.</param>
/// <param name="traceEvent">The trace event method encapsulation.</param>
internal static void ValidateExportModel(IEnumerable <IUANodeBase> nodesCollection, IModelFactory exportModelFactory, IAddressSpaceValidationContext addressSpaceContext, Action <TraceMessage> traceEvent)
{
traceEvent(TraceMessage.DiagnosticTraceMessage(string.Format("Entering Validator.ValidateExportModel - starting creation of the ModelDesign for {0} nodes.", nodesCollection.Count <IUANodeBase>())));
List <BuildError> _errors = new List <BuildError>(); //TODO should be added to the model;
foreach (IModelTableEntry _ns in addressSpaceContext.ExportNamespaceTable)
{
string _publicationDate = _ns.PublicationDate.HasValue ? _ns.PublicationDate.Value.ToShortDateString() : DateTime.UtcNow.ToShortDateString();
string _version = _ns.Version;
exportModelFactory.CreateNamespace(_ns.ModelUri, _publicationDate, _version);
}
string _msg = null;
int _nc = 0;
foreach (IUANodeBase _item in nodesCollection)
{
try
{
ValidateExportNode(_item, exportModelFactory, null, y =>
{
if (y.TraceLevel != TraceEventType.Verbose)
{
_errors.Add(y.BuildError);
}
traceEvent(y);
});
_nc++;
}
catch (Exception _ex)
{
_msg = string.Format("Error caught while processing the node {0}. The message: {1} at {2}.", _item.UANode.NodeId, _ex.Message, _ex.StackTrace);
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NonCategorized, _msg));
}
}
if (_errors.Count == 0)
{
_msg = string.Format("Finishing Validator.ValidateExportModel - the model contains {0} nodes.", _nc);
}
else
{
_msg = string.Format("Finishing Validator.ValidateExportModel - the model contains {0} nodes and {1} errors.", _nc, _errors.Count);
}
traceEvent(TraceMessage.DiagnosticTraceMessage(_msg));
}
/// <summary>
/// Validates the selected nodes <paramref name="nodesCollection"/> and export it using <paramref name="exportModelFactory"/>.
/// </summary>
/// <param name="nodesCollection">The items <see cref="UANodeContext" /> imported to the Address Space <see cref="IAddressSpaceContext" />.</param>
/// <param name="exportModelFactory">The model export factory.</param>
/// <param name="addressSpaceContext">The Address Space context.</param>
/// <param name="traceEvent">The trace event method encapsulation.</param>
internal static void ValidateExportModel
(IEnumerable <UANodeContext> nodesCollection, IModelFactory exportModelFactory, AddressSpaceContext addressSpaceContext, Action <TraceMessage> traceEvent)
{
traceEvent(TraceMessage.DiagnosticTraceMessage(String.Format("Entering Validator.ValidateExportModel - starting creation of the ModelDesign for {0} nodes.", nodesCollection.Count <UANodeContext>())));
List <BuildError> _errors = new List <BuildError>(); //TODO should be added to the model;
foreach (string _ns in addressSpaceContext.ExportNamespaceTable())
{
exportModelFactory.CreateNamespace(_ns);
}
string _msg = null;
int _nc = 0;
foreach (UANodeContext _item in nodesCollection)
{
try
{
ValidateExportNode(_item, exportModelFactory, null, y =>
{
if (y.TraceLevel != TraceEventType.Verbose)
{
_errors.Add(y.BuildError);
}
traceEvent(y);
});
_nc++;
}
catch (Exception _ex)
{
_msg = String.Format("Error caught while processing the node {0}. The message: {1} at {2}.", _item.UANode.NodeId, _ex.Message, _ex.StackTrace);
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NonCategorized, _msg));
}
}
if (_errors.Count == 0)
{
_msg = String.Format("Finishing Validator.ValidateExportModel - the model contains {0} nodes.", _nc);
}
else
{
_msg = String.Format("Finishing Validator.ValidateExportModel - the model contains {0} nodes and {1} errors.", _nc, _errors.Count);
}
traceEvent(TraceMessage.DiagnosticTraceMessage(_msg));
}
/// <summary>
/// Builds the symbolic identifier.
/// </summary>
/// <param name="path">The browse path.</param>
/// <param name="traceEvent">A delegate <see cref="Action{TraceMessage}"/> encapsulates an action to report any errors and trace processing progress.</param>
internal void BuildSymbolicId(List <string> path, Action <TraceMessage> traceEvent)
{
if (this.UANode == null)
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.DanglingReferenceTarget, ""));
return;
}
IEnumerable <UAReferenceContext> _parentConnector = m_AddressSpaceContext.GetReferences2Me(this).Where <UAReferenceContext>(x => x.ChildConnector);
Debug.Assert(_parentConnector.Count <UAReferenceContext>() <= 1);
UAReferenceContext _connector = _parentConnector.FirstOrDefault <UAReferenceContext>();
if (_connector != null)
{
_connector.BuildSymbolicId(path, traceEvent);
}
string _BranchName = String.IsNullOrEmpty(this.UANode.SymbolicName) ? this.m_BrowseName.Name : this.UANode.SymbolicName;
path.Add(_BranchName);
}
/// <summary>
/// Builds the symbolic identifier.
/// </summary>
/// <param name="path">The browse path.</param>
public void BuildSymbolicId(List <string> path)
{
if (this.UANode == null)
{
Log.TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.DanglingReferenceTarget, $"The target node NodeId={this.NodeIdContext}, current path {string.Join(", ", path)}"));
return;
}
IEnumerable <UAReferenceContext> _parentConnector = m_AddressSpaceContext.GetReferences2Me(this).Where <UAReferenceContext>(x => x.ChildConnector);
Debug.Assert(_parentConnector.Count <UAReferenceContext>() <= 1); //TODO #40; ValidateAndExportModel shall export also instances #40
UAReferenceContext _connector = _parentConnector.FirstOrDefault <UAReferenceContext>();
if (_connector != null)
{
_connector.BuildSymbolicId(path);
}
string _BranchName = string.IsNullOrEmpty(this.UANode.SymbolicName) ? this.BrowseName.Name : this.UANode.SymbolicName;
path.Add(_BranchName);
}
private static FactoryType CreateNode <FactoryType, NodeSetType>
(
Func <FactoryType> createNode,
UANodeContext nodeContext,
Action <FactoryType, NodeSetType> updateNode,
Action <FactoryType, NodeSetType, UANodeContext, Action <TraceMessage> > updateBase,
Action <TraceMessage> traceEvent
)
where FactoryType : INodeFactory
where NodeSetType : UANode
{
FactoryType _nodeFactory = createNode();
nodeContext.CalculateNodeReferences(_nodeFactory, traceEvent);
NodeSetType _nodeSet = (NodeSetType)nodeContext.UANode;
XmlQualifiedName _browseName = nodeContext.ExportNodeBrowseName();
string _symbolicName;
if (String.IsNullOrEmpty(_nodeSet.SymbolicName))
{
_symbolicName = _browseName.Name.ValidateIdentifier(traceEvent);
}
else
{
_symbolicName = _nodeSet.SymbolicName.ValidateIdentifier(traceEvent);
}
_nodeFactory.BrowseName = _browseName.Name.ExportString(_symbolicName);
_nodeSet.Description.ExportLocalizedTextArray(_nodeFactory.AddDescription);
_nodeSet.DisplayName.Truncate(512, traceEvent).ExportLocalizedTextArray(_nodeFactory.AddDisplayName);
_nodeFactory.SymbolicName = new XmlQualifiedName(_symbolicName, _browseName.Namespace);
Action <UInt32, string> _doReport = (x, y) =>
{
traceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.WrongWriteMaskValue, String.Format("The current value is {0:x} of the node type {1}.", x, y)));
};
_nodeFactory.WriteAccess = _nodeSet is UAVariable?_nodeSet.WriteMask.Validate(0x200000, x => _doReport(x, _nodeSet.GetType().Name)) : _nodeSet.WriteMask.Validate(0x400000, x => _doReport(x, _nodeSet.GetType().Name));
updateBase(_nodeFactory, _nodeSet, nodeContext, traceEvent);
updateNode(_nodeFactory, _nodeSet);
return(_nodeFactory);
}
private ushort ImportNamespaceIndex(ushort namespaceIndex)
{
// nothing special required for indexes < 0.
if (namespaceIndex == 0)
{
return(namespaceIndex);
}
// return a new value if parameter is out of range.
string _identifier = $"NameUnknown{m_NamespaceCount++}";
if (m_UANodeSetModel.NamespaceUris.Length > namespaceIndex - 1)
{
_identifier = m_UANodeSetModel.NamespaceUris[namespaceIndex - 1];
}
else
{
BuildErrorsHandling.Log.TraceEvent(
TraceMessage.BuildErrorTraceMessage(BuildError.UndefinedNamespaceIndex, $"ImportNamespaceIndex failed - namespace index {namespaceIndex-1} is out of the NamespaceUris index. New namespace {_identifier} is created insted."));
}
return(AddressSpaceContext.GetIndexOrAppend(_identifier));
}
private void ImportUANode(UANode node, UAModelContext modelContext, Action <TraceMessage> traceEvent)
{
try
{
if (node == null)
{
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeCannotBeNull, "At Importing UANode."));
}
NodeId nodeId = modelContext.ImportNodeId(node.NodeId, false, m_TraceEvent);
UANodeContext _newNode = null;
string nodeIdKey = nodeId.ToString();
if (!m_NodesDictionary.TryGetValue(nodeIdKey, out _newNode))
{
_newNode = new UANodeContext(this, modelContext, nodeId);
_newNode.Update(node, traceEvent);
m_NodesDictionary.Add(nodeIdKey, _newNode);
}
else
{
if (_newNode.UANode != null)
{
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeIdDuplicated, String.Format("The {0} is already defined.", node.NodeId.ToString())));
}
_newNode.Update(node, traceEvent);
}
foreach (Reference _rf in node.References)
{
UAReferenceContext _rs = UAReferenceContext.NewReferenceStub(_rf, this, modelContext, _newNode, m_TraceEvent);
if (!m_References.ContainsKey(_rs.Key))
{
m_References.Add(_rs.Key, _rs);
}
}
}
catch (Exception _ex)
{
string _msg = String.Format("ImportUANode {1} is interrupted by exception {0}", _ex.Message, node.NodeId);
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(_msg));
}
}
//methods
private void ImportNodeSet(UANodeSet model)
{
if (model.ServerUris != null)
{
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NotSupportedFeature, "ServerUris is omitted during the import"));
}
if (model.Extensions != null)
{
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NotSupportedFeature, "Extensions is omitted during the import"));
}
string _namespace = model.NamespaceUris == null?m_NamespaceTable.GetString(0) : model.NamespaceUris[0];
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(String.Format("Entering AddressSpaceContext.ImportNodeSet - starting import {0}.", _namespace)));
UAModelContext _modelContext = new UAModelContext(model.Aliases, model.NamespaceUris, this);
m_TraceEvent(TraceMessage.DiagnosticTraceMessage("AddressSpaceContext.ImportNodeSet - context for imported model is created and starting import nodes."));
foreach (UANode _nd in model.Items)
{
this.ImportUANode(_nd, _modelContext, m_TraceEvent);
}
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(String.Format("Finishing AddressSpaceContext.ImportNodeSet - imported {0} nodes.", model.Items.Length)));
}
internal static XML.LocalizedText[] Truncate(this XML.LocalizedText[] localizedText, int maxLength, Action <TraceMessage> reportError)
{
if (localizedText == null || localizedText.Length == 0)
{
return(null);
}
List <XML.LocalizedText> _ret = new List <XML.LocalizedText>();
foreach (XML.LocalizedText _item in localizedText)
{
if (_item.Value.Length > maxLength)
{
reportError(TraceMessage.BuildErrorTraceMessage(BuildError.WrongDisplayNameLength, string.Format
("The localized text starting with '{0}:{1}' of length {2} is too long.", _item.Locale, _item.Value.Substring(0, 20), _item.Value.Length)));
XML.LocalizedText _localizedText = new XML.LocalizedText()
{
Locale = _item.Locale,
Value = _item.Value.Substring(0, maxLength)
};
}
}
return(localizedText);
}
private void TraceDiagnostic(TraceMessage msg, List<TraceMessage> errors, ref int diagnosticCounter)
{
Console.WriteLine(msg.ToString());
if (msg.BuildError.Focus == Focus.Diagnostic)
{
diagnosticCounter++;
}
else
errors.Add(msg);
}
/// <summary>
/// Validates <paramref name="nodeContext"/> and exports it using an object of <see cref="IModelFactory"/> type.
/// </summary>
/// <param name="nodeContext">The node context to be validated and exported.</param>
/// <param name="exportFactory">A model export factory.</param>
/// <param name="parentReference">The reference to parent node.</param>
/// <param name="traceEvent">The trace event.</param>
/// <returns>An object of <see cref="INodeFactory"/>.</returns>
internal static void ValidateExportNode(IUANodeBase nodeContext, INodeContainer exportFactory, UAReferenceContext parentReference, Action <TraceMessage> traceEvent)
{
Debug.Assert(nodeContext != null, "Validator.ValidateExportNode the argument nodeContext is null.");
//TODO Handle HasComponent ReferenceType errors. #42
if (nodeContext.UANode == null)
{
string _msg = string.Format("The node {0} is undefined", nodeContext.NodeIdContext);
BuildError _be = null;
if (parentReference == null || parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
_be = BuildError.UndefinedHasPropertyTarget;
}
else
{
_be = BuildError.UndefinedHasComponentTarget;
}
TraceMessage _traceMessage = TraceMessage.BuildErrorTraceMessage(_be, _msg);
traceEvent(_traceMessage);
CreateModelDesignStub(exportFactory);
}
else
{
string nodeType = nodeContext.UANode.GetType().Name;
switch (nodeType)
{
case "UAReferenceType":
CreateNode <IReferenceTypeFactory, UAReferenceType>(exportFactory.AddNodeFactory <IReferenceTypeFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateType, traceEvent);
break;
case "UADataType":
CreateNode <IDataTypeFactory, UADataType>(exportFactory.AddNodeFactory <IDataTypeFactory>, nodeContext, (x, y) => Update(x, y, nodeContext.UAModelContext, traceEvent), UpdateType, traceEvent);
break;
case "UAVariableType":
CreateNode <IVariableTypeFactory, UAVariableType>(exportFactory.AddNodeFactory <IVariableTypeFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, traceEvent), UpdateType, traceEvent);
break;
case "UAObjectType":
CreateNode <IObjectTypeFactory, UAObjectType>(exportFactory.AddNodeFactory <IObjectTypeFactory>, nodeContext, Update, UpdateType, traceEvent);
break;
case "UAView":
CreateNode <IViewInstanceFactory, UAView>(exportFactory.AddNodeFactory <IViewInstanceFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateInstance, traceEvent);
break;
case "UAMethod":
CreateNode <IMethodInstanceFactory, UAMethod>(exportFactory.AddNodeFactory <IMethodInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
break;
case "UAVariable":
if (parentReference == null || parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
CreateNode <IPropertyInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IPropertyInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
}
else
{
CreateNode <IVariableInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IVariableInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
}
break;
case "UAObject":
CreateNode <IObjectInstanceFactory, UAObject>(exportFactory.AddNodeFactory <IObjectInstanceFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateInstance, traceEvent);
break;
default:
Debug.Assert(false, "Wrong node type");
break;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceResultException"/> class.
/// </summary>
/// <param name="traceMessage">The trace message.</param>
/// <param name="message">The message.</param>
/// <param name="inner">The inner.</param>
public ServiceResultException(TraceMessage traceMessage, string message, Exception inner)
: base(message, inner)
{
TraceMessage = traceMessage;
}