SkillDashboard.cpp

Go to the documentation of this file.

 
#include "SkillDashboard.h"
 
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
 
#include <nlohmann/json.hpp>
 
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;
    }
 
    bool
    SkillDashboard::loadShortcuts(const std::string& packagepath)
    {
        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;
 
            for (const auto& item : jsonData["shortcuts"])
            {
                SkillShortcut shortcut;
                shortcut.skillArgs = item["skill_args"].dump(2);
                shortcut.skillId = item["skill_id"];
                shortcut.shortcutName = item["skill_shortcut_name"];
 
                this->registeredShortcuts.push_back(shortcut);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
 
    void
    SkillDashboard::onInitComponent()
    {
 
        this->properties.shortcutPath = getProperty<std::string>("ShortcutPath").getValue();
 
        if (not properties.shortcutPath.empty())
        {
            loadShortcuts(properties.shortcutPath);
        }
    }
 
    void
    SkillDashboard::onConnectComponent()
    {
    }
 
    SkillShortcutList
    SkillDashboard::getShortcuts(const ::Ice::Current&)
    {
        return this->registeredShortcuts;
    }
 
    SkillShortcut
    SkillDashboard::getShortcut(const std::string& name, const ::Ice::Current&)
    {
        for (const SkillShortcut& shortcut : this->registeredShortcuts)
        {
            if (shortcut.shortcutName == name)
            {
                return shortcut;
            }
        }
 
        return SkillShortcut();
    }
 
    void
    SkillDashboard::addNewShortcut(const SkillShortcut& newShortcut, const ::Ice::Current&)
    {
        if (newShortcut.shortcutName != "")
        {
            if (getShortcut(newShortcut.shortcutName).shortcutName == "")
            {
 
                this->registeredShortcuts.push_back(newShortcut);
                ARMARX_INFO << "Added shortcut " << newShortcut.shortcutName;
            }
            else
            {
                for (SkillShortcut& shortcut : this->registeredShortcuts)
                {
                    if (shortcut.shortcutName == newShortcut.shortcutName)
                    {
                        shortcut.skillId = newShortcut.skillId;
                        shortcut.skillArgs = newShortcut.skillArgs;
                    }
                }
                ARMARX_INFO << "changed shortcut";
            }
        }
    }
 
    void
    SkillDashboard::deleteShortcut(const std::string& name, const ::Ice::Current&)
    {
        for (auto it = this->registeredShortcuts.begin(); it != this->registeredShortcuts.end();
             ++it)
        {
            if (it->shortcutName == name)
            {
                this->registeredShortcuts.erase(it);
                break;
            }
        }
    }
 
    void
    SkillDashboard::saveShortcutOrder(const std::vector<std::string>& order, const ::Ice::Current&)
    {
        ARMARX_IMPORTANT << "Save shortcut order";
        this->shortcutOrder = order;
    }
 
    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());
        for (const auto& s : registeredShortcuts)
        {
            lookup[s.shortcutName] = s;
        }
 
 
        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}});
        }
 
        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()
    {
    }
 
 
} // namespace armarx