model_object.cpp

Go to the documentation of this file.

/******************************************************************************
 *   Copyright (C) 2013-2014 by Alexander Rykovanov                        *
 *   rykovanov.as@gmail.com                                                   *
 *                                                                            *
 *   This library is free software; you can redistribute it and/or modify     *
 *   it under the terms of the GNU Lesser General Public License as           *
 *   published by the Free Software Foundation; version 3 of the License.     *
 *                                                                            *
 *   This library is distributed in the hope that it will be useful,          *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *   GNU Lesser General Public License for more details.                      *
 *                                                                            *
 *   You should have received a copy of the GNU Lesser General Public License *
 *   along with this library; if not, write to the                            *
 *   Free Software Foundation, Inc.,                                          *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                *
 ******************************************************************************/

#include "model_impl.h"

#include <opc/ua/model.h>

namespace OpcUa
{
  namespace Model
  {

    Object::Object(NodeId objectId, Services::SharedPtr services)
      : Node(services)
    {
      Id = objectId;
      ReadParameters attrs;
      attrs.AttributesToRead.push_back(ToReadValueId(objectId, AttributeId::DisplayName));
      attrs.AttributesToRead.push_back(ToReadValueId(objectId, AttributeId::BrowseName));
      std::vector<DataValue> values = services->Attributes()->Read(attrs);
      DisplayName = values[0].Value.As<LocalizedText>();
      BrowseName = values[1].Value.As<QualifiedName>();
    }

    Object::Object(Object&& object)
      : Node(std::move(object.OpcUaServices))
    {
      Id = std::move(object.Id);
      DisplayName = std::move(object.DisplayName);
      BrowseName = std::move(object.BrowseName);
    }

    Object::Object(const Object& object)
      : Node(object.OpcUaServices)
    {
      Id = object.Id;
      DisplayName = object.DisplayName;
      BrowseName = object.BrowseName;
    }

    Object::Object(Services::SharedPtr services)
      : Node(services)
    {
    }

    ObjectType Object::GetType() const
    {
      return ObjectType(ObjectId::Null, GetServices());
    }

    std::vector<Variable> Object::GetVariables() const
    {
      return Browse<Variable>(GetId(), NodeClass::Variable, GetServices());
    }

    Variable Object::GetVariable(const QualifiedName& name) const
    {
      OpcUa::RelativePathElement element;
      element.ReferenceTypeId = OpcUa::ObjectId::HierarchicalReferences;
      element.IncludeSubtypes = true;
      element.TargetName = name;

      OpcUa::RelativePath path;
      path.Elements.push_back(element);
      return GetVariable(path);
    }

    Variable Object::GetVariable(const RelativePath& relativePath) const
    {
      OpcUa::BrowsePath browsePath;
      browsePath.StartingNode = GetId();
      browsePath.Path = relativePath;
      OpcUa::TranslateBrowsePathsParameters params;
      params.BrowsePaths.push_back(browsePath);
      const std::vector<OpcUa::BrowsePathResult>& result = GetServices()->Views()->TranslateBrowsePathsToNodeIds(params);
      if (result.size() != 1)
        throw std::runtime_error("object_model| Server returned more than one browse paths on TranslateBrowsePathsToNodeIds request.");

      const OpcUa::BrowsePathResult& resultPath = result.back();
      OpcUa::CheckStatusCode(resultPath.Status);
      if (resultPath.Targets.size() != 1)
        throw std::runtime_error("object_model| Server returned too many target elements on TranslateBrowsePathsToNodeIds request.");

      return Variable(resultPath.Targets.back().Node, GetServices());
    }


    std::vector<Object> Object::GetObjects() const
    {
      return Browse<Object>(GetId(), NodeClass::Object, GetServices());
    }

    Object Object::GetObject(const QualifiedName& name) const
    {
      return Object(ObjectId::Null, GetServices());
    }

    Object Object::GetObject(const RelativePath& name) const
    {
      return Object(ObjectId::Null, GetServices());
    }

    Object Object::CreateObject(const ObjectType& type, const QualifiedName& browseName)
    {
      return CreateObject(NodeId(), type, browseName);
    }

    Object Object::CreateObject(const NodeId& newNodeId, const ObjectType& nodeType, const QualifiedName& browseName)
    {
      return CreateObject(newNodeId, GetId(), nodeType.GetId(), browseName, browseName.Name);
    }

    Object Object::CreateObject(const ObjectType& type, const QualifiedName& browseName, const std::string& displayName)
    {
      return CreateObject(NodeId(), GetId(), type.GetId(), browseName, displayName);
    }

    Object Object::CreateObject(const NodeId& newNodeId, const NodeId& parentNode, const NodeId& typeId, const QualifiedName& browseName, const std::string& displayName)
    {
      Object object(GetServices());
      object.Id = InstantiateType(newNodeId, parentNode, typeId, NodeClass::Object, browseName, displayName);
      object.BrowseName = browseName;
      object.DisplayName = LocalizedText(displayName);
      return object;

    }

    NodeId Object::InstantiateType(const NodeId& newNodeId, const NodeId& parentNode, const NodeId& typeId, NodeClass nodeClass, const QualifiedName& browseName, const std::string& displayName)
    {
      // Creating new node for object
      AddNodesItem newNodeRequest;
      newNodeRequest.BrowseName = browseName;
      newNodeRequest.RequestedNewNodeId = newNodeId;
      newNodeRequest.Class = nodeClass;
      newNodeRequest.ParentNodeId = parentNode;
      newNodeRequest.ReferenceTypeId = nodeClass == NodeClass::Object ? ObjectId::HasComponent : ObjectId::HasProperty;
      newNodeRequest.TypeDefinition = typeId;
      ObjectAttributes attrs;
      attrs.Description = LocalizedText(displayName);
      attrs.DisplayName = LocalizedText(displayName);
      newNodeRequest.Attributes = attrs;

      NodeManagementServices::SharedPtr nodes = GetServices()->NodeManagement();
      std::vector<AddNodesResult> newObjectNode = nodes->AddNodes({newNodeRequest});
      if (newObjectNode.size() != 1)
      {
        throw std::runtime_error("opcua_model| Server returned wrong number new nodes results.");
      }

      OpcUa::CheckStatusCode(newObjectNode[0].Status);

      std::map<NodeId, std::vector<ReferenceDescription>> nextRefs;
      nextRefs.insert({newObjectNode[0].AddedNodeId, BrowseObjectsAndVariables(typeId)});
      while(!nextRefs.empty())
      {
        std::map<NodeId, std::vector<ReferenceDescription>> newRefs;
        for (auto idRefs : nextRefs)
        {
          std::map<NodeId, std::vector<ReferenceDescription>> tmpRefs = CopyObjectsAndVariables(idRefs.first, idRefs.second);
          newRefs.insert(tmpRefs.begin(), tmpRefs.end());
        }
        nextRefs = std::move(newRefs);
      }
      return newObjectNode[0].AddedNodeId;
    }

    std::vector<ReferenceDescription> Object::BrowseObjectsAndVariables(const NodeId& id)
    {
      // Id of the new node.
      BrowseDescription desc;
      desc.Direction = BrowseDirection::Forward;
      desc.IncludeSubtypes = true;
      desc.NodeClasses =   NodeClass::Object | NodeClass::Variable | NodeClass::Method;
      desc.ReferenceTypeId = ObjectId::HierarchicalReferences;
      desc.NodeToBrowse = id;
      desc.ResultMask = BrowseResultMask::NodeClass | BrowseResultMask::TypeDefinition | BrowseResultMask::BrowseName | BrowseResultMask::DisplayName;

      // browse sub objects and variables.
      NodesQuery query;
      query.NodesToBrowse.push_back(desc);
      ViewServices::SharedPtr views = GetServices()->Views();
      return views->Browse(query)[0].Referencies; //FIME: this method should return BrowseResults
    }

    std::map<NodeId, std::vector<ReferenceDescription>> Object::CopyObjectsAndVariables(const NodeId& targetNode, const std::vector<ReferenceDescription>& refs)
    {
      std::map<NodeId, std::vector<ReferenceDescription>> nextCopyData;
      for (const ReferenceDescription& ref : refs)
      {
        std::vector<AddNodesResult> result;
        std::vector<AddNodesItem> newNodeRequest;
        switch (ref.TargetNodeClass)
        {
          case NodeClass::Object:
          {
            if (ref.TargetNodeTypeDefinition !=ObjectId::Null)
            {
              InstantiateType(NodeId(), targetNode, ref.TargetNodeTypeDefinition, NodeClass::Object, ref.BrowseName, ref.DisplayName.Text);
            }
            else
            {
              newNodeRequest = {CreateObjectCopy(targetNode, ref)};
            }
            break;
          }
          case NodeClass::Variable:
          {
            newNodeRequest = {CreateVariableCopy(targetNode, ref)};
            break;
          }
          default:
          {
            continue;
          }
        }
        if (newNodeRequest.empty())
        {
          continue;
        }
        result = GetServices()->NodeManagement()->AddNodes(newNodeRequest);
        std::vector<ReferenceDescription> newRefs = BrowseObjectsAndVariables(ref.TargetNodeId);
        nextCopyData.insert({result[0].AddedNodeId, newRefs});
      }
      return nextCopyData;
    }

    Variable Object::CreateVariable(const QualifiedName& browseName, const Variant& value)
    {
      return CreateVariable(NodeId(), browseName, value);
    }

    Variable Object::CreateVariable(const NodeId& newVariableId, const QualifiedName& browseName, const Variant& value)
    {
      // Creating new node for object
      AddNodesItem newNodeRequest;
      newNodeRequest.BrowseName = browseName;
      newNodeRequest.RequestedNewNodeId = newVariableId;
      newNodeRequest.Class = NodeClass::Variable;
      newNodeRequest.ParentNodeId = GetId();
      newNodeRequest.ReferenceTypeId = ObjectId::HasProperty;
      newNodeRequest.TypeDefinition = NodeId();
      VariableAttributes attrs;
      attrs.Description = LocalizedText(browseName.Name);
      attrs.DisplayName = LocalizedText(browseName.Name);
      attrs.Value = value;
      attrs.Type = OpcUa::VariantTypeToDataType(value.Type());
      newNodeRequest.Attributes = attrs;

      NodeManagementServices::SharedPtr nodes = GetServices()->NodeManagement();
      std::vector<AddNodesResult> newNode = nodes->AddNodes({newNodeRequest});
      if (newNode.size() != 1)
      {
        throw std::runtime_error("opcua_model| Server returned wrong number new nodes results.");
      }

      OpcUa::CheckStatusCode(newNode[0].Status);
      Variable newVariable(GetServices());
      newVariable.Id = newNode[0].AddedNodeId;
      newVariable.BrowseName = browseName;
      newVariable.DisplayName = attrs.Description;
      newVariable.DataType = value.Type();
      newVariable.TypeId = newNodeRequest.TypeDefinition;
      return newVariable;
    }

    Variable Object::CreateVariable(const QualifiedName& browseName, const VariableType& type)
    {
      return Variable(GetServices());
    }

    Variable Object::CreateVariable(const NodeId& newVariableId, const QualifiedName& browseName, const VariableType& type)
    {
      return Variable(GetServices());
    }

    AddNodesItem Object::CreateVariableCopy(const NodeId& parentId, const ReferenceDescription& ref)
    {
      const NodeId& nodeId = ref.TargetNodeId;

      ReadParameters readParams;
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::DisplayName));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::Description));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::Value));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::DataType));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::ValueRank));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::ArrayDimensions));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::AccessLevel));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::UserAccessLevel));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::MinimumSamplingInterval));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::Historizing));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::WriteMask));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::UserWriteMask));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::BrowseName));
      std::vector<DataValue> values = GetServices()->Attributes()->Read(readParams);

      VariableAttributes attrs;
      attrs.DisplayName = values[0].Value.As<LocalizedText>();
      attrs.Description = values[1].Value.As<LocalizedText>();
      attrs.Value = values[2].Value;
      attrs.Type = values[3].Value.As<NodeId>();
      attrs.Rank = values[4].Value.As<int32_t>();
      attrs.Dimensions = values[5].Value.As<std::vector<uint32_t>>();
      attrs.AccessLevel = static_cast<VariableAccessLevel>(values[6].Value.As<uint8_t>());
      attrs.UserAccessLevel = static_cast<VariableAccessLevel>(values[7].Value.As<uint8_t>());
      attrs.MinimumSamplingInterval = values[8].Value.As<Duration>();
      attrs.Historizing = values[9].Value.As<bool>();
      attrs.WriteMask = values[10].Value.As<uint32_t>();
      attrs.UserWriteMask = values[11].Value.As<uint32_t>();

      AddNodesItem newNode;
      newNode.BrowseName = values[12].Value.As<QualifiedName>();
      newNode.Class = NodeClass::Variable;
      newNode.ParentNodeId = parentId;
      newNode.ReferenceTypeId = ref.ReferenceTypeId;
      newNode.TypeDefinition = ref.TargetNodeTypeDefinition;
      newNode.Attributes = attrs;
      return newNode;
    }

    AddNodesItem Object::CreateObjectCopy(const NodeId& parentId, const ReferenceDescription& ref)
    {
      const NodeId& nodeId = ref.TargetNodeId;

      ReadParameters readParams;
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::DisplayName));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::Description));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::WriteMask));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::UserWriteMask));
      readParams.AttributesToRead.push_back(ToReadValueId(nodeId, AttributeId::BrowseName));
      std::vector<DataValue> values = GetServices()->Attributes()->Read(readParams);

      ObjectAttributes attrs;
      attrs.DisplayName = values[0].Value.As<LocalizedText>();
      attrs.Description = values[1].Value.As<LocalizedText>();
      attrs.WriteMask = values[2].Value.As<uint32_t>();
      attrs.UserWriteMask = values[3].Value.As<uint32_t>();

      AddNodesItem newNode;
      newNode.BrowseName = values[4].Value.As<QualifiedName>();
      newNode.Class = NodeClass::Object;
      newNode.ParentNodeId = parentId;
      newNode.ReferenceTypeId = ref.ReferenceTypeId;
      newNode.TypeDefinition = ref.TargetNodeTypeDefinition;
      newNode.Attributes = attrs;
      return newNode;
    }

  } // namespace Model
} // namespace OpcUa