FluxioSkill.cpp

Go to the documentation of this file.

#include "FluxioSkill.h"
 
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/container/Dict.h"
#include "RobotAPI/libraries/aron/core/data/variant/forward_declarations.h"
#include "RobotAPI/libraries/skills/core/FluxioParameter.h"
#include "RobotAPI/libraries/skills/core/FluxioProvider.h"
#include <RobotAPI/interface/aron/Aron.h>
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioEdge.aron.generated.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioNode.aron.generated.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioParameter.aron.generated.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioSkill.aron.generated.h>
 
#include "FluxioControlNode.h"
#include "FluxioEdge.h"
#include "FluxioNode.h"
#include "FluxioParameterNode.h"
#include "FluxioSubSkillNode.h"
 
namespace armarx
{
    namespace skills
    {
        std::optional<manager::dto::FluxioSkill>
        FluxioSkill::toManagerIce() const
        {
            if (skillProviderPtr == nullptr)
            {
                ARMARX_WARNING << "SkillProvider for Skill with id " << id << " not set";
                return std::nullopt;
            }
 
            manager::dto::FluxioSkill ret;
 
            ret.id = id;
            ret.name = name;
            ret.description = description;
            ret.lastChanged = lastChanged;
            ret.executable = executable;
            ret.native = native;
            ret.skillProviderId = skillProviderPtr->toFluxioIdentificatorIce();
 
            skills::manager::dto::FluxioParameterList ret_parameters;
            for (const auto& [id, parameter] : parameters)
            {
                ret_parameters.push_back(parameter.toManagerIce());
            }
            ret.parameters = ret_parameters;
 
            skills::manager::dto::FluxioNodeList ret_nodes;
            skills::manager::dto::FluxioEdgeList ret_edges;
            if (native)
            {
                ret.nodesHasValue = false;
                ret.edgesHasValue = false;
            }
            else
            {
                ret.nodesHasValue = true;
                ret.edgesHasValue = true;
 
                for (const auto& [id, nodePtr] : nodes)
                {
                    const auto& node = nodePtr->toManagerIce();
 
                    if (!node.has_value())
                    {
                        ARMARX_WARNING << "Node with id " << id << " could not be converted";
                        continue;
                    }
 
                    ret_nodes.push_back(node.value());
                }
 
                for (const auto& edge : edges)
                {
                    const auto& edgeDTO = edge.toManagerIce();
 
                    if (!edgeDTO.has_value())
                    {
                        ARMARX_WARNING << "Edge could not be converted";
                        continue;
                    }
 
                    ret_edges.push_back(edgeDTO.value());
                }
            }
            ret.nodes = ret_nodes;
            ret.edges = ret_edges;
 
            armarx::core::time::toIce(ret.timeout, timeout);
 
            return ret;
        }
 
        manager::dto::FluxioIdentificator
        FluxioSkill::toFluxioIdentificatorIce() const
        {
            manager::dto::FluxioIdentificator ret;
 
            ret.id = id;
            ret.hint = name;
 
            return ret;
        }
 
        manager::arondto::FluxioIdentificator
        FluxioSkill::toFluxioIdentificatorAron() const
        {
            manager::arondto::FluxioIdentificator ret;
 
            ret.id = id;
            ret.hint = name;
 
            return ret;
        }
 
        bool
        FluxioSkill::updateFromIce(const manager::dto::FluxioSkill& i,
                                   std::map<std::string, FluxioProvider>& providersMap,
                                   std::map<std::string, FluxioProfile>& profilesMap,
                                   std::map<std::string, FluxioSkill>& skillsMap,
                                   std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            if (id != i.id)
            {
                ARMARX_WARNING << "Trying to update Skill with id " << id << " with Skill with id "
                               << i.id;
                return false;
            }
 
            if (native != i.native)
            {
                ARMARX_WARNING << "Trying to update native state of Skill with id " << id;
                return false;
            }
 
            // TODO: add corrupted flag to FluxioSkill to indicate invalid states
 
            name = i.name;
            description = i.description;
            armarx::core::time::fromIce(i.timeout, timeout);
            lastChanged = armarx::DateTime::Now().toDateTimeString();
            executable = i.executable;
            const auto skillProviderPtr =
                skills::FluxioProvider::FromFluxioIdentificatorIce(i.skillProviderId, providersMap);
            this->skillProviderPtr = skillProviderPtr;
 
            // parameters
            // create a parameter dto map for convenience
            std::map<std::string, manager::dto::FluxioParameter> parameterDTOMap;
            for (const auto& parameter : i.parameters)
            {
                parameterDTOMap[parameter.id] = parameter;
            }
 
            // find parameters to delete
            std::list<std::string> parameterIdsToDelete;
            for (const auto& [id, param] : parameters)
            {
                const auto& paramIt = parameterDTOMap.find(id);
                if (paramIt == parameterDTOMap.end())
                {
                    parameterIdsToDelete.push_back(id);
                }
            }
 
            // handle parameter deletion
            for (const std::string& paramId : parameterIdsToDelete)
            {
                for (auto& [k, s] : skillsMap)
                {
                    s.deleteParameter(paramId);
                }
            }
 
            for (const auto& [id, paramDTO] : parameterDTOMap)
            {
                const auto& paramIt = parameters.find(id);
                if (paramIt == parameters.end()) // add new parameter
                {
                    parameters[id] = FluxioParameter::FromIce(paramDTO, profilesMap, typesMap);
                }
                else // update existing parameter
                {
                    parameters[id].updateFromIce(paramDTO, profilesMap, typesMap);
                }
            }
 
            // nodes
            if (i.nodesHasValue)
            {
                nodes.clear(); // create all nodes anew
                auto controllNodes = std::vector<manager::dto::FluxioNode>();
                for (const manager::dto::FluxioNode& node : i.nodes)
                {
                    FluxioNodeType nodeType = FluxioNodeTypeFromString(node.nodeType);
                    if (nodeType == FluxioNodeType::CONTROL)
                    {
                        controllNodes.push_back(node);
                        continue;
                    }
                    auto n = CreateNode(node, parameters, skillsMap, profilesMap, typesMap, nodes);
 
                    if (n != nullptr)
                    {
                        nodes.emplace(n->nodeId, std::move(n));
                    }
                }
                for (const manager::dto::FluxioNode& node : controllNodes)
                {
                    auto n = CreateNode(node, parameters, skillsMap, profilesMap, typesMap, nodes);
 
                    if (n != nullptr)
                    {
                        nodes.emplace(n->nodeId, std::move(n));
                    }
                }
            }
 
            // edges
            if (i.edgesHasValue)
            {
                edges.clear(); // create all edges anew
                for (const manager::dto::FluxioEdge& edge : i.edges)
                {
                    const auto& e = FluxioEdge::FromIce(edge, nodes, parameters);
 
                    if (e.has_value())
                    {
                        edges.push_back(e.value());
                    }
                    else
                    {
                        ARMARX_WARNING << "Edge could not be converted";
                    }
                }
            }
 
            return true;
        }
 
        bool
        FluxioSkill::updateFromAron(const aron::data::dto::DictPtr& d,
                                    std::map<std::string, FluxioProvider>& providersMap,
                                    std::map<std::string, FluxioProfile>& profilesMap,
                                    std::map<std::string, FluxioSkill>& skillsMap,
                                    std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            const aron::data::DictPtr& dict = aron::make_dict(d);
 
            if (!dict->fullfillsType(manager::arondto::FluxioSkill::ToAronType()))
            {
                ARMARX_WARNING << "DictPtr does not fullfill type FluxioSkill";
                return false;
            }
 
            const manager::arondto::FluxioSkill i = manager::arondto::FluxioSkill::FromAron(d);
 
            if (id != i.id)
            {
                ARMARX_WARNING << "Trying to update Skill with id " << id << " with Skill with id "
                               << i.id;
                return false;
            }
 
            if (native != i.native)
            {
                ARMARX_WARNING << "Trying to update native state of Skill with id " << id;
                return false;
            }
 
            // TODO: add corrupted flag to FluxioSkill to indicate invalid states
 
            name = i.name;
            description = i.description;
            timeout = i.timeout;
            lastChanged = armarx::DateTime::Now().toDateTimeString();
            executable = i.executable;
            const auto skillProviderPtr = skills::FluxioProvider::FromFluxioIdentificatorAron(
                i.skillProviderId, providersMap);
            this->skillProviderPtr = skillProviderPtr;
 
            // parameters
            // create a parameter dto map for convenience
            std::map<std::string, manager::arondto::FluxioParameter> parameterDTOMap;
            for (const auto& parameter : i.parameters)
            {
                parameterDTOMap[parameter.id] = parameter;
            }
 
            // find parameters to delete
            std::list<std::string> parameterIdsToDelete;
            for (const auto& [id, param] : parameters)
            {
                const auto& paramIt = parameterDTOMap.find(id);
                if (paramIt == parameterDTOMap.end())
                {
                    parameterIdsToDelete.push_back(id);
                }
            }
 
            // handle parameter deletion
            for (const std::string& paramId : parameterIdsToDelete)
            {
                for (auto& [k, s] : skillsMap)
                {
                    s.deleteParameter(paramId);
                }
            }
 
            for (const auto& [id, paramDTO] : parameterDTOMap)
            {
                const auto& paramIt = parameters.find(id);
                if (paramIt == parameters.end()) // add new parameter
                {
                    parameters[id] = FluxioParameter::FromAron(paramDTO, profilesMap, typesMap);
                }
                else // update existing parameter
                {
                    parameters[id].updateFromAron(paramDTO, profilesMap, typesMap);
                }
            }
 
            // nodes
            if (i.nodesHasValue)
            {
                nodes.clear(); // create all nodes anew
                auto controllNodes = std::vector<manager::arondto::FluxioNode>();
                for (const manager::arondto::FluxioNode& node : i.nodes)
                {
                    FluxioNodeType nodeType = FluxioNodeTypeFromString(node.nodeType);
                    if (nodeType == FluxioNodeType::CONTROL)
                    {
                        controllNodes.push_back(node);
                        continue;
                    }
                    auto n = CreateNode(node, parameters, skillsMap, profilesMap, typesMap, nodes);
 
                    if (n != nullptr)
                    {
                        nodes.emplace(n->nodeId, std::move(n));
                    }
                }
                for (const manager::arondto::FluxioNode& node : controllNodes)
                {
                    auto n = CreateNode(node, parameters, skillsMap, profilesMap, typesMap, nodes);
 
                    if (n != nullptr)
                    {
                        nodes.emplace(n->nodeId, std::move(n));
                    }
                }
            }
 
            // edges
            if (i.edgesHasValue)
            {
                edges.clear(); // create all edges anew
                for (const manager::arondto::FluxioEdge& edge : i.edges)
                {
                    const auto& e = FluxioEdge::FromAron(edge, nodes, parameters);
 
                    if (e.has_value())
                    {
                        edges.push_back(e.value());
                    }
                    else
                    {
                        ARMARX_WARNING << "Edge could not be converted";
                    }
                }
            }
 
            return true;
        }
 
        void
        FluxioSkill::removeParameterNodesAndEdges(const std::string& parameterId,
                                                  bool keepParameterNodes)
        {
            std::vector<std::string> nodeIdsToDelete = {};
            for (const auto& [nodeId, nodePtr] : nodes)
            {
                if (nodePtr == nullptr)
                {
                    ARMARX_WARNING << "Unexpected nullptr!";
                    continue;
                }
 
                if (nodePtr->nodeType != FluxioNodeType::PARAMETER)
                {
                    continue;
                }
 
                const auto& parameterNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioParameterNode*>(nodePtr.get()));
                if (parameterNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to parameter node";
                    continue;
                }
 
                if (parameterNodePtr->parameterPtr == nullptr)
                {
                    ARMARX_WARNING << "ParameterPtr for ParameterNode is not set";
                    continue;
                }
                if (parameterNodePtr->parameterPtr->id == parameterId)
                {
                    edges.remove_if(
                        [nodeId](const FluxioEdge& e)
                        {
                            return e.fromNodePtr == nullptr || e.toNodePtr == nullptr ||
                                   e.fromNodePtr->nodeId == nodeId || e.toNodePtr->nodeId == nodeId;
                        });
 
                    nodeIdsToDelete.push_back(nodeId);
                }
            }
 
            if (!keepParameterNodes)
            {
                for (const auto& id : nodeIdsToDelete)
                {
                    nodes.erase(id);
                }
            }
        }
 
        void
        FluxioSkill::deleteParameter(const std::string& parameterId)
        {
            removeParameterNodesAndEdges(parameterId, false);
            parameters.erase(parameterId);
        }
 
        void
        FluxioSkill::removeSubSkillNodesAndEdges(const std::string& skillId)
        {
            std::vector<std::string> nodeIdsToDelete = {};
            for (const auto& [nodeId, nodePtr] : nodes)
            {
                if (nodePtr == nullptr)
                {
                    ARMARX_WARNING << "Unexpected nullptr!";
                    continue;
                }
 
                if (nodePtr->nodeType != FluxioNodeType::SUBSKILL)
                {
                    continue;
                }
 
                const auto& subSkillNodePtr = std::experimental::make_observer(
                    dynamic_cast<const FluxioSubSkillNode*>(nodePtr.get()));
                if (subSkillNodePtr == nullptr)
                {
                    ARMARX_WARNING << "Failed to cast node to sub skill node";
                    continue;
                }
 
                if (subSkillNodePtr->skillPtr == nullptr)
                {
                    ARMARX_WARNING << "SkillPtr for SubSkillNode is not set";
                    continue;
                }
 
                if (subSkillNodePtr->skillPtr->id == skillId)
                {
                    edges.remove_if(
                        [&nodeId](const FluxioEdge& e) {
                            return e.fromNodePtr->nodeId == nodeId || e.toNodePtr->nodeId == nodeId;
                        });
 
                    nodeIdsToDelete.push_back(nodeId);
                }
            }
 
            for (const auto& id : nodeIdsToDelete)
            {
                nodes.erase(id);
            }
        }
 
        void
        FluxioSkill::removeEdgesConnectedToParameter(const std::string& parameterId)
        {
            edges.remove_if(
                [&parameterId](const FluxioEdge& e)
                {
                    if (e.fromParameterPtr != nullptr && e.fromParameterPtr->id == parameterId)
                    {
                        return true;
                    }
 
                    if (e.toParameterPtr != nullptr && e.toParameterPtr->id == parameterId)
                    {
                        return true;
                    }
 
                    return false;
                });
        }
 
        std::experimental::observer_ptr<const FluxioSkill>
        FluxioSkill::FromFluxioIdentificatorIce(const manager::dto::FluxioIdentificator& i,
                                                std::map<std::string, FluxioSkill>& skillsMap)
        {
            const auto& skillIt = skillsMap.find(i.id);
 
            if (skillIt == skillsMap.end())
            {
                ARMARX_WARNING << "Skill with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(&skillsMap[skillIt->first]);
        }
 
        std::experimental::observer_ptr<const FluxioSkill>
        FluxioSkill::FromFluxioIdentificatorAron(const manager::arondto::FluxioIdentificator& i,
                                                 std::map<std::string, FluxioSkill>& skillsMap)
        {
            const auto& skillIt = skillsMap.find(i.id);
 
            if (skillIt == skillsMap.end())
            {
                ARMARX_WARNING << "Skill with id " << i.id << " not found";
                return nullptr;
            }
 
            return std::experimental::make_observer(&skillsMap[skillIt->first]);
        }
 
        std::unique_ptr<FluxioSkill>
        FluxioSkill::FromIce(const manager::dto::FluxioSkill& i,
                             std::map<std::string, FluxioProvider>& providersMap,
                             std::map<std::string, FluxioProfile>& profilesMap,
                             std::map<std::string, FluxioSkill>& skillsMap,
                             std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            const auto& providerPtr =
                FluxioProvider::FromFluxioIdentificatorIce(i.skillProviderId, providersMap);
            if (providerPtr == nullptr)
            {
                ARMARX_WARNING << "Provider for Skill with id " << i.id << " not found";
                return nullptr;
            }
 
            FluxioSkill ret;
 
            ret.id = i.id;
            ret.name = i.name;
            ret.description = i.description;
            armarx::core::time::fromIce(i.timeout, ret.timeout);
            ret.lastChanged = i.lastChanged;
            ret.executable = i.executable;
            ret.native = i.native;
            ret.skillProviderPtr = providerPtr;
            ret.parameters = std::map<std::string, FluxioParameter>();
            ret.nodes = std::map<const std::string, const std::unique_ptr<FluxioNode>>();
            ret.edges = std::list<FluxioEdge>();
 
            for (const manager::dto::FluxioParameter& parameter : i.parameters)
            {
                skills::FluxioParameter param =
                    FluxioParameter::FromIce(parameter, profilesMap, typesMap);
                ret.parameters[param.id] = param;
            }
 
            if (i.native)
            {
                return std::make_unique<FluxioSkill>(std::move(ret));
            }
 
            if (i.nodesHasValue)
            {
                auto controllNodes = std::vector<manager::dto::FluxioNode>();
                for (const manager::dto::FluxioNode& node : i.nodes)
                {
                    FluxioNodeType nodeType = FluxioNodeTypeFromString(node.nodeType);
                    if (nodeType == FluxioNodeType::CONTROL)
                    {
                        controllNodes.push_back(node);
                        continue;
                    }
                    auto n = CreateNode(
                        node, ret.parameters, skillsMap, profilesMap, typesMap, ret.nodes);
 
                    if (n != nullptr)
                    {
                        ret.nodes.emplace(n->nodeId, std::move(n));
                    }
                }
                for (const manager::dto::FluxioNode& node : controllNodes)
                {
                    auto n = CreateNode(
                        node, ret.parameters, skillsMap, profilesMap, typesMap, ret.nodes);
 
                    if (n != nullptr)
                    {
                        ret.nodes.emplace(n->nodeId, std::move(n));
                    }
                }
            }
 
            if (i.edgesHasValue)
            {
                for (const manager::dto::FluxioEdge& edge : i.edges)
                {
                    const auto& e = FluxioEdge::FromIce(edge, ret.nodes, ret.parameters);
 
                    if (e.has_value())
                    {
                        ret.edges.push_back(e.value());
                    }
                }
            }
 
            return std::make_unique<FluxioSkill>(std::move(ret));
        }
 
        std::unique_ptr<FluxioSkill>
        FluxioSkill::FromAron(const aron::data::dto::DictPtr& d,
                              std::map<std::string, FluxioProvider>& providersMap,
                              std::map<std::string, FluxioProfile>& profilesMap,
                              std::map<std::string, FluxioSkill>& skillsMap,
                              std::map<std::string, aron::type::ObjectPtr>& typesMap)
        {
            const aron::data::DictPtr dict = aron::make_dict(d);
            if (!dict->fullfillsType(manager::arondto::FluxioSkill::ToAronType()))
            {
                ARMARX_WARNING << "DictPtr does not fullfill type FluxioSkill";
                return nullptr;
            }
 
            const manager::arondto::FluxioSkill i = manager::arondto::FluxioSkill::FromAron(d);
 
            const auto& providerPtr =
                FluxioProvider::FromFluxioIdentificatorAron(i.skillProviderId, providersMap);
 
            if (providerPtr == nullptr)
            {
                ARMARX_WARNING << "Provider for Skill with id " << i.id << " not found";
                return nullptr;
            }
 
            FluxioSkill ret;
 
            ret.id = i.id;
            ret.name = i.name;
            ret.description = i.description;
            ret.timeout = i.timeout;
            ret.lastChanged = i.lastChanged;
            ret.executable = i.executable;
            ret.native = i.native;
            ret.skillProviderPtr = providerPtr;
            ret.parameters = std::map<std::string, FluxioParameter>();
            ret.nodes = std::map<const std::string, const std::unique_ptr<FluxioNode>>();
            ret.edges = std::list<FluxioEdge>();
 
            for (const manager::arondto::FluxioParameter& parameter : i.parameters)
            {
                skills::FluxioParameter param =
                    FluxioParameter::FromAron(parameter, profilesMap, typesMap);
                ret.parameters[param.id] = param;
            }
 
            if (i.native)
            {
                return std::make_unique<FluxioSkill>(std::move(ret));
            }
 
            if (i.nodesHasValue)
            {
                auto controllNodes = std::vector<manager::arondto::FluxioNode>();
                for (const manager::arondto::FluxioNode& node : i.nodes)
                {
                    FluxioNodeType nodeType = FluxioNodeTypeFromString(node.nodeType);
                    if (nodeType == FluxioNodeType::CONTROL)
                    {
                        controllNodes.push_back(node);
                        continue;
                    }
                    auto n = CreateNode(
                        node, ret.parameters, skillsMap, profilesMap, typesMap, ret.nodes);
 
                    if (n != nullptr)
                    {
                        ret.nodes.emplace(n->nodeId, std::move(n));
                    }
                }
                for (const manager::arondto::FluxioNode& node : i.nodes)
                {
                    auto n = CreateNode(
                        node, ret.parameters, skillsMap, profilesMap, typesMap, ret.nodes);
 
                    if (n != nullptr)
                    {
                        ret.nodes.emplace(n->nodeId, std::move(n));
                    }
                }
            }
 
            if (i.edgesHasValue)
            {
                for (const manager::arondto::FluxioEdge& edge : i.edges)
                {
                    const auto& e = FluxioEdge::FromAron(edge, ret.nodes, ret.parameters);
 
                    if (e.has_value())
                    {
                        ret.edges.push_back(e.value());
                    }
                }
            }
 
            return std::make_unique<FluxioSkill>(std::move(ret));
        }
 
        std::unique_ptr<FluxioNode>
        FluxioSkill::CreateNode(
            const manager::dto::FluxioNode& i,
            std::map<std::string, FluxioParameter>& parametersMap,
            std::map<std::string, FluxioSkill>& skillsMap,
            std::map<std::string, FluxioProfile>& profilesMap,
            std::map<std::string, aron::type::ObjectPtr>& typesMap,
            std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            FluxioNodeType nodeType = FluxioNodeTypeFromString(i.nodeType);
 
            if (nodeType == FluxioNodeType::PARAMETER)
            {
                const auto& n = FluxioParameterNode::FromIce(i, parametersMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioParameterNode>(n.value());
                }
 
                ARMARX_WARNING << "ParameterNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& n = FluxioSubSkillNode::FromIce(i, skillsMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioSubSkillNode>(n.value());
                }
                ARMARX_WARNING << "SubSkillNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::CONTROL)
            {
                const auto& n = FluxioControlNode::FromIce(i, profilesMap, typesMap, nodesMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioControlNode>(n.value());
                }
                ARMARX_WARNING << "controlNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::UNKNOWN)
            {
                ARMARX_WARNING << "Node with id " << i.nodeId << " has unknown type";
            }
            else
            {
                ARMARX_INFO << "Node type " << i.nodeType << " not supported yet. Ignoring.";
            }
 
            return nullptr;
        }
 
        std::unique_ptr<FluxioNode>
        FluxioSkill::CreateNode(
            const manager::arondto::FluxioNode& i,
            std::map<std::string, FluxioParameter>& parametersMap,
            std::map<std::string, FluxioSkill>& skillsMap,
            std::map<std::string, FluxioProfile>& profilesMap,
            std::map<std::string, aron::type::ObjectPtr>& typesMap,
            std::map<const std::string, const std::unique_ptr<FluxioNode>>& nodesMap)
        {
            FluxioNodeType nodeType = FluxioNodeTypeFromString(i.nodeType);
 
            if (nodeType == FluxioNodeType::PARAMETER)
            {
                const auto& n = FluxioParameterNode::FromAron(i, parametersMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioParameterNode>(n.value());
                }
 
                ARMARX_WARNING << "ParameterNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::SUBSKILL)
            {
                const auto& n = FluxioSubSkillNode::FromAron(i, skillsMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioSubSkillNode>(n.value());
                }
                ARMARX_WARNING << "SubSkillNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::CONTROL)
            {
                const auto& n = FluxioControlNode::FromAron(i, profilesMap, typesMap, nodesMap);
 
                if (n.has_value())
                {
                    return std::make_unique<FluxioControlNode>(n.value());
                }
                ARMARX_WARNING << "controlNode with id " << i.nodeId << " could not be converted";
            }
            else if (nodeType == FluxioNodeType::UNKNOWN)
            {
                ARMARX_WARNING << "Node with id " << i.nodeId << " has unknown type";
            }
            else
            {
                ARMARX_INFO << "Node type " << i.nodeType << " not supported yet. Ignoring.";
            }
 
            return nullptr;
        }
 
        std::optional<manager::arondto::FluxioSkill>
        FluxioSkill::toAronXml() const
        {
            if (skillProviderPtr == nullptr)
            {
                ARMARX_WARNING << "SkillProvider for Skill with id " << id << " not set";
                return std::nullopt;
            }
 
            manager::arondto::FluxioSkill ret;
 
            ret.id = id;
            ret.name = name;
            ret.description = description;
            ret.lastChanged = lastChanged;
            ret.executable = executable;
            ret.native = native;
            ret.skillProviderId = skillProviderPtr->toFluxioIdentificatorAron();
 
            std::vector<manager::arondto::FluxioParameter> ret_parameters;
            ret_parameters.reserve(parameters.size());
            for (const auto& [id, parameter] : parameters)
            {
                ret_parameters.push_back(parameter.toAron());
            }
            ret.parameters = ret_parameters;
 
            std::vector<manager::arondto::FluxioNode> ret_nodes;
            std::vector<manager::arondto::FluxioEdge> ret_edges;
            if (native)
            {
                ret.nodesHasValue = false;
                ret.edgesHasValue = false;
            }
            else
            {
                ret.nodesHasValue = true;
                ret.edgesHasValue = true;
 
                for (const auto& [id, nodePtr] : nodes)
                {
                    const auto& node = nodePtr->toAron();
 
                    if (!node.has_value())
                    {
                        ARMARX_WARNING << "Node with id " << id << " could not be converted";
                        continue;
                    }
 
                    ret_nodes.push_back(node.value());
                }
 
                for (const auto& edge : edges)
                {
                    const auto& edgeDTO = edge.toAron();
 
                    if (!edgeDTO.has_value())
                    {
                        ARMARX_WARNING << "Edge could not be converted";
                        continue;
                    }
 
                    ret_edges.push_back(edgeDTO.value());
                }
            }
            ret.nodes = ret_nodes;
            ret.edges = ret_edges;
 
            ret.timeout = timeout;
 
            return ret;
        }
 
        std::optional<aron::data::dto::DictPtr>
        FluxioSkill::toAronDTO() const
        {
            const std::optional<manager::arondto::FluxioSkill> ret = toAronXml();
            if (!ret.has_value())
            {
                return std::nullopt;
            }
 
            return toAronXml()->toAronDTO();
        }
 
    } // namespace skills
} // namespace armarx