SkillDashboard.cpp

Go to the documentation of this file.

 
#include "SkillDashboard.h"
 
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
 
#include <boost/locale.hpp>
#include <boost/uuid/name_generator.hpp>
#include <boost/uuid/nil_generator.hpp>
#include <boost/uuid/string_generator.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
 
#include <IceUtil/Optional.h>
 
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>
 
#include <ArmarXCore/core/ManagedIceObject.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/ice_conversions.h>
#include <ArmarXCore/libraries/DecoupledSingleComponent/Decoupled.h>
 
#include "RobotAPI/libraries/skills/core/SkillID.h"
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/interface/skills/SkillMemoryInterface.h>
 
namespace armarx
{
 
    armarx::PropertyDefinitionsPtr
    SkillDashboard::createPropertyDefinitions()
    {
        armarx::PropertyDefinitionsPtr def =
            new ::armarx::ComponentPropertyDefinitions(getConfigIdentifier());
        def->optional(properties.shortcutPath,
                      "ShortcutPath",
                      "Add path of predefined dashboards. Syntax: Package/folderName/fileName");
        return def;
    }
 
    armarx::core::time::Duration
    SkillDashboard::getTimeout(const std::string& skillId)
    {
        constexpr bool addToDependencies = false;
        const auto& managerPrx =
            getProxy<skills::dti::SkillMemoryInterfacePrx>("SkillMemory", addToDependencies);
 
        if (!managerPrx)
        {
            return armarx::core::time::Duration::Seconds(-1);
        }
 
        const auto& splitIt = skillId.find('/');
        std::string provider = "";
        std::string nameSkill = "";
 
        if (splitIt == std::string::npos)
        {
            // TODO: error handling
            return armarx::core::time::Duration::Seconds(-1);
        }
        provider = skillId.substr(0, splitIt);
        nameSkill = skillId.substr(splitIt + 1);
        skills::manager::dto::ProviderID providerId{.providerName = provider};
 
        skills::manager::dto::SkillID skillIdDTO{.providerId = providerId, .skillName = nameSkill};
 
        IceUtil::Optional<armarx::skills::manager::dto::SkillDescription> skillDescDTO =
            managerPrx->getSkillDescription(skillIdDTO);
 
        if (!skillDescDTO)
        {
            return armarx::core::time::Duration::Seconds(-1);
        }
        const auto& dto = *skillDescDTO;
        return armarx::core::time::Duration::MicroSeconds(dto.timeout.microSeconds);
    }
 
    void
    SkillDashboard::updateTimeoutForShortcut(const SkillShortcut& shortcut)
    {
        armarx::core::time::Duration timeout = getTimeout(shortcut.skillId);
        std::unique_lock timeoutsLock(shortcutNameToTimeoutsMutex);
        this->shortcutNameToTimeouts[shortcut.shortcutName] = timeout;
        timeoutsLock.unlock();
    }
 
    bool
    SkillDashboard::loadShortcuts(const std::string& packagepath)
    {
        std::scoped_lock l(registeredShortcutsMutex);
        this->registeredShortcuts = std::vector<SkillShortcut>();
        std::stringstream ss(packagepath);
        std::string item;
        std::vector<std::string> result;
        while (std::getline(ss, item, '/'))
        {
            result.push_back(item);
        }
        if (result.size() < 3)
        {
            ARMARX_ERROR << "Invalid property structure!";
            return false;
        }
        this->packageName = result[0];
 
        std::string absoluteFilepath;
        std::string filename;
        armarx::CMakePackageFinder finder(result[0]);
        if (finder.packageFound())
        {
            ARMARX_INFO << "Found package.";
 
            std::string packageDataDir = finder.getDataDir();
 
            // add the data directory to the search list of ArmarXDataPath
            ArmarXDataPath::addDataPaths(packageDataDir);
            //std::filesystem::create_directory(packageDataDir + "/" + folder);
 
            std::string relativeFilename;
            for (size_t i = 1; i < result.size() - 1; i++)
            {
                if (!relativeFilename.empty())
                {
                    relativeFilename += "/";
                }
                relativeFilename += result[i];
            }
 
            this->pathToDashboard = relativeFilename;
            this->dahsboardName = result[result.size() - 1];
 
            if (ArmarXDataPath::getAbsolutePath(relativeFilename, absoluteFilepath))
            {
                ARMARX_INFO << "Located file at:" << absoluteFilepath;
                filename = result[result.size() - 1] + ".json";
            }
 
 
            std::ifstream file(absoluteFilepath + "/" + filename);
            nlohmann::json jsonData;
 
            if (!file.is_open())
            {
                ARMARX_WARNING << "Could not open file";
            }
 
            file >> jsonData;
            boost::uuids::name_generator generator(boost::uuids::nil_uuid());
 
            for (const auto& item : jsonData["shortcuts"])
            {
                SkillShortcut shortcut;
                shortcut.skillArgs = item["skill_args"].dump(2);
                shortcut.skillId = item["skill_id"];
                if (item.contains("icon_name"))
                {
                    shortcut.iconName = item["icon_name"];
                }
                else
                {
                    shortcut.iconName = "";
                }
                shortcut.shortcutName = item["skill_shortcut_name"];
                if (item.contains("id"))
                {
                    shortcut.id = item["id"];
                }
                else
                {
                    shortcut.id = boost::uuids::to_string(generator(shortcut.shortcutName));
                }
 
                this->registeredShortcuts.push_back(shortcut);
            }
            return true;
        }
        else
        {
            ARMARX_WARNING << "Configured ArmarX package not found for '" << result[0] << "'.";
            return false;
        }
    }
 
    void
    SkillDashboard::onInitComponent()
    {
        offeringTopic("SkillDashboardCoverTopic");
        this->properties.shortcutPath = getProperty<std::string>("ShortcutPath").getValue();
 
        if (not properties.shortcutPath.empty())
        {
            loadShortcuts(properties.shortcutPath);
        }
    }
 
    void
    SkillDashboard::onConnectComponent()
    {
        ARMARX_DEBUG << "Skills dashboard component connected.";
        coverTopicPrx =
            getTopic<armarx::SkillDashboardCoverListenerPrx>("SkillDashboardCoverTopic");
    }
 
    SkillShortcutList
    SkillDashboard::getShortcuts(const ::Ice::Current&)
    {
        ARMARX_DEBUG << "Getting shortcuts … (registered are " << this->registeredShortcuts.size()
                     << ")";
        return this->registeredShortcuts;
    }
 
    SkillShortcutWithTimeoutList
    SkillDashboard::getShortcutsWithTimeout(const ::Ice::Current&)
    {
        ARMARX_DEBUG << "Getting shortcuts with timeout …";
        std::vector<SkillShortcutWithTimeout> shortcutsWithTimeout;
        std::scoped_lock l(registeredShortcutsMutex);
        for (const auto& shortcut : this->registeredShortcuts)
        {
            this->updateTimeoutForShortcut(shortcut);
            SkillShortcutWithTimeout shortcutWithTimeout;
            shortcutWithTimeout.shortcutName = shortcut.shortcutName;
            shortcutWithTimeout.skillId = shortcut.skillId;
            shortcutWithTimeout.skillArgs = shortcut.skillArgs;
            shortcutWithTimeout.iconName = shortcut.iconName;
 
            std::shared_lock timeoutsLock(shortcutNameToTimeoutsMutex);
            shortcutWithTimeout.timeout.microSeconds =
                this->shortcutNameToTimeouts[shortcut.shortcutName].toMicroSeconds();
            timeoutsLock.unlock();
 
            shortcutsWithTimeout.push_back(shortcutWithTimeout);
        }
        return shortcutsWithTimeout;
    }
 
    SkillShortcut
    SkillDashboard::getShortcut(const std::string& name, const ::Ice::Current&)
    {
        std::scoped_lock l(registeredShortcutsMutex);
        for (const SkillShortcut& shortcut : this->registeredShortcuts)
        {
            if (shortcut.shortcutName == name)
            {
                return shortcut;
            }
        }
 
        return SkillShortcut();
    }
 
    std::optional<SkillShortcut>
    SkillDashboard::getShortcutWithId(const std::string& id)
    {
        std::scoped_lock l(registeredShortcutsMutex);
        for (const SkillShortcut& shortcut : this->registeredShortcuts)
        {
            if (shortcut.id == id)
            {
                return shortcut;
            }
        }
 
        return std::nullopt;
    }
 
    void
    SkillDashboard::addNewShortcut(const SkillShortcut& newShortcut, const ::Ice::Current&)
    {
        if (newShortcut.shortcutName == "")
        {
            return;
        }
        if (newShortcut.id == "" || getShortcutWithId(newShortcut.id) == std::nullopt)
        {
            if (getShortcut(newShortcut.shortcutName).shortcutName == "")
            {
                boost::uuids::name_generator generator(boost::uuids::nil_uuid());
 
                SkillShortcut toAddShortcut;
                toAddShortcut.shortcutName = newShortcut.shortcutName;
                toAddShortcut.skillArgs = newShortcut.skillArgs;
                toAddShortcut.skillId = newShortcut.skillId;
                toAddShortcut.iconName = newShortcut.iconName;
                toAddShortcut.id = boost::uuids::to_string(generator(newShortcut.shortcutName));
 
                std::unique_lock l(registeredShortcutsMutex);
                this->registeredShortcuts.push_back(toAddShortcut);
                l.unlock();
                this->updateTimeoutForShortcut(toAddShortcut);
                ARMARX_INFO << "Added shortcut " << newShortcut.shortcutName;
            }
            else
            {
                ARMARX_INFO << "Shortcut name already exists";
            }
        }
        else
        {
            std::optional<SkillShortcut> updatedShortcut;
            std::unique_lock l(registeredShortcutsMutex);
            for (SkillShortcut& shortcut : this->registeredShortcuts)
            {
                if (shortcut.id == newShortcut.id)
                {
                    shortcut.shortcutName = newShortcut.shortcutName;
                    shortcut.skillId = newShortcut.skillId;
                    shortcut.skillArgs = newShortcut.skillArgs;
                    shortcut.iconName = newShortcut.iconName;
 
                    updatedShortcut = shortcut;
                }
            }
            l.unlock();
            if (updatedShortcut)
            {
                this->updateTimeoutForShortcut(*updatedShortcut);
            }
            ARMARX_INFO << "changed shortcut";
        }
    }
 
    void
    SkillDashboard::deleteShortcut(const std::string& name, const ::Ice::Current&)
    {
        std::scoped_lock l(registeredShortcutsMutex);
        for (auto it = this->registeredShortcuts.begin(); it != this->registeredShortcuts.end();
             ++it)
        {
            if (it->shortcutName == name)
            {
                this->registeredShortcuts.erase(it);
                std::unique_lock timeoutsLock(shortcutNameToTimeoutsMutex);
                this->shortcutNameToTimeouts.erase(name);
                timeoutsLock.unlock();
                break;
            }
        }
    }
 
    void
    SkillDashboard::saveShortcutOrder(const std::vector<std::string>& order, const ::Ice::Current&)
    {
        ARMARX_IMPORTANT << "Save shortcut order";
        this->shortcutOrder = order;
    }
 
    void
    SkillDashboard::syncOrderedWithDefault(const ::Ice::Current&)
    {
        std::unordered_map<std::string, std::size_t> index;
        for (std::size_t i = 0; i < this->shortcutOrder.size(); ++i)
        {
            index[this->shortcutOrder[i]] = i;
        }
 
        std::sort(this->registeredShortcuts.begin(),
                  this->registeredShortcuts.end(),
                  [&](const auto& a, const auto& b)
                  { return index[a.shortcutName] < index[b.shortcutName]; });
    }
 
    std::vector<std::string>
    SkillDashboard::getPathStructure(const ::Ice::Current&)
    {
        return std::vector<std::string>{
            this->packageName, this->pathToDashboard, this->dahsboardName};
    }
 
    bool
    SkillDashboard::importShortcuts(const std::string& package,
                                    const std::string& folder,
                                    const std::string& name,
                                    const ::Ice::Current&)
    {
        std::string path = package + "/" + folder + "/" + name;
        return loadShortcuts(path);
    }
 
    void
    SkillDashboard::exportShortcuts(const std::string& package,
                                    const std::string& folder,
                                    const std::string& name,
                                    const ::Ice::Current&)
    {
        nlohmann::json j;
 
        std::unordered_map<std::string, SkillShortcut> lookup;
        lookup.reserve(registeredShortcuts.size());
        std::shared_lock shortcutsLock(registeredShortcutsMutex);
        for (const auto& s : registeredShortcuts)
        {
            lookup[s.shortcutName] = s;
        }
        shortcutsLock.unlock();
 
 
        for (const auto& name : this->shortcutOrder)
        {
 
            auto it = lookup.find(name);
            if (it == lookup.end())
            {
                ARMARX_IMPORTANT << "Shortcut does not exist.";
                continue;
            }
            const auto& shortcut = it->second;
 
            nlohmann::json skillArgs_json = nlohmann::json::parse(shortcut.skillArgs);
 
            j["shortcuts"].push_back({
                {"skill_shortcut_name", shortcut.shortcutName},
                {"skill_id", shortcut.skillId},
                {"skill_args", skillArgs_json},
                {"icon_name", shortcut.iconName},
            });
        }
 
        std::string absoluteFilename;
        armarx::CMakePackageFinder finder(package);
        if (finder.packageFound())
        {
 
            std::string packageDataDir = finder.getDataDir();
 
            // add the data directory to the search list of ArmarXDataPath
            ArmarXDataPath::addDataPaths(packageDataDir);
            std::filesystem::create_directories(packageDataDir + "/" + folder);
 
            std::string relativeFilename(folder);
 
            if (ArmarXDataPath::getAbsolutePath(relativeFilename, absoluteFilename))
            {
                ARMARX_INFO << "Located file at:" << absoluteFilename;
                std::string filename = name + ".json";
                std::ofstream outFile(absoluteFilename + "/" + filename);
                outFile << std::setw(4) << j << std::endl;
                outFile.close();
                ARMARX_INFO << "Insert " << package << "/" << folder << "/" << name
                            << " into the component property.";
            }
        }
    }
 
    void
    SkillDashboard::onDisconnectComponent()
    {
    }
 
    void
    SkillDashboard::onExitComponent()
    {
    }
 
    ARMARX_REGISTER_COMPONENT_EXECUTABLE(SkillDashboard, "SkillDashboard");
} // namespace armarx