HumanProfileWriter.cpp

Go to the documentation of this file.

#include "HumanProfileWriter.h"
 
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include <RobotAPI/libraries/aron/core/aron_conversions.h>
 
#include <VisionX/libraries/armem_human/aron_conversions.h>
 
namespace armarx::armem::human::client
{
 
    ProfileWriter::ProfileWriter() : armem::client::util::SimpleWriterBase()
    {
    }
 
    ProfileWriter::~ProfileWriter() = default;
 
    void
    ProfileWriter::registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def)
    {
        armem::client::util::SimpleWriterBase::registerPropertyDefinitions(def);
    }
 
    void
    ProfileWriter::connect(armem::client::MemoryNameSystem& memoryNameSystem)
    {
        ARMARX_VERBOSE << "Connecting ...";
        armem::client::util::SimpleWriterBase::connect(memoryNameSystem);
        ARMARX_VERBOSE << "Connected.";
 
        humanMemory =
            armem::human::HumanMemoryServerInterfacePrx::checkedCast(this->memoryWriter().memory);
 
        reader.connect(memoryNameSystem);
    }
 
    bool
    ProfileWriter::commitHumanProfile(const Person& humanProfile,
                                      const std::string& provider,
                                      const armem::Time& referencedTime,
                                      const std::string& entityName)
    {
        std::string entityNameAdjusted = entityName;
        if (entityName == "")
        {
            entityNameAdjusted = (humanProfile.id.firstName + "-" + humanProfile.id.lastName);
            ARMARX_INFO << "Setting entity name to " << entityNameAdjusted;
        }
        this->commitHumanProfiles({humanProfile}, provider, referencedTime, entityNameAdjusted);
        return true;
    }
 
    bool
    ProfileWriter::commitPreferencesToProfile(const armarx::armem::human::PersonID& personID,
                                              const std::string& providerName,
                                              const armem::Time& referencedTime,
                                              const armarx::armem::human::Preferences preferences)
    {
        armarx::armem::human::Person profile;
        try
        {
            profile = this->reader.queryLatestProfileByName(
                personID.firstName, personID.lastName, providerName);
        }
        catch (...)
        {
            ARMARX_WARNING << "You are trying to commit preferences to a profile which cannot be "
                              "read (maybe it does not exist?)";
            return false;
        }
 
        profile.preferences = preferences;
        this->commitHumanProfile(profile, providerName, referencedTime);
 
        ARMARX_DEBUG << "Committed adjusted profile with new preferences for " << personID.firstName
                     << " " << personID.lastName;
 
        return true;
    }
 
    bool
    ProfileWriter::setCustomAttributeInProfile(const armarx::armem::human::PersonID& personID,
                                               const std::string& providerName,
                                               const armem::Time& referencedTime,
                                               const std::string key,
                                               const std::string value)
 
    {
        armarx::armem::human::Person profile;
        try
        {
            profile = this->reader.queryLatestProfileByName(
                personID.firstName, personID.lastName, providerName);
            if (profile.id.firstName == "")
            {
                return false;
            }
        }
        catch (...)
        {
            ARMARX_WARNING << "You are trying to commit preferences to a profile which cannot be "
                              "read (maybe it does not exist?)";
            return false;
        }
 
        int customAttributeCountBefore = profile.customAttributes.size();
        ARMARX_INFO << "Amount of custom attributes before: " << customAttributeCountBefore;
        profile.customAttributes[key] = value;
        if (profile.customAttributes.size() == (customAttributeCountBefore + 1))
        {
            ARMARX_INFO << "Added additional attribute for " << personID.firstName << " "
                        << personID.lastName << " successfully";
        }
        else
        {
            ARMARX_INFO << "Changed existing attribute for " << personID.firstName << " "
                        << personID.lastName << " successfully";
        }
        ARMARX_INFO << "Amount of custom attributes before commiting: "
                    << profile.customAttributes.size();
        this->commitHumanProfile(profile, providerName, referencedTime);
 
        ARMARX_DEBUG << "Committed adjusted profile with new preferences for " << personID.firstName
                     << " " << personID.lastName;
 
        return true;
    }
 
    bool
    ProfileWriter::commitHumanProfiles(const std::vector<Person>& humanProfiles,
                                       const std::string& provider,
                                       const armem::Time& referencedTime,
                                       const std::string& entityName)
    {
        std::vector<armarx::aron::data::dto::DictPtr> humanProfilesDto;
        for (const Person& humanProfile : humanProfiles)
        {
            armarx::human::arondto::Person humanProfileAron;
            toAron(humanProfileAron, humanProfile);
            humanProfilesDto.push_back(humanProfileAron.toAronDTO());
        }
 
        core::time::dto::DateTime referencedTimeDto;
        toIce(referencedTimeDto, referencedTime);
        try
        {
            humanMemory->commitHumanProfiles(
                humanProfilesDto, provider, referencedTimeDto, entityName);
            return true;
        }
        catch (...)
        {
            ARMARX_INFO << "Failed to commit human profiles: " << GetHandledExceptionString();
            return false;
        }
    }
 
    bool
    ProfileWriter::setPreferredDrink(const armarx::armem::human::PersonID& personID,
                                     const std::string& providerName,
                                     const armem::Time& referencedTime,
                                     const std::string& drink)
    {
        Preferences preferences;
 
        try
        {
            preferences = this->reader.queryPreferences(
                personID.firstName, personID.lastName, armarx::Duration::Hours(1000), providerName);
        }
        catch (...)
        {
            ARMARX_WARNING << "You are trying to set preferred drinks on a profile which could not "
                              "be read (maybe it does not exist?)";
            return false;
        }
 
        if (!preferences.drink)
            preferences.drink.emplace();
 
        // Filter out duplicates
        preferences.drink->preferred.erase(std::remove(preferences.drink->preferred.begin(),
                                                       preferences.drink->preferred.end(),
                                                       drink),
                                           preferences.drink->preferred.end());
 
        // We will insert the new preference at the beginning, implicitly conveying it is the "number one" preferred (-> favorite) drink
        // This way, we don't loose prior information about other liked drinks
        preferences.drink->preferred.insert(preferences.drink->preferred.begin(), drink);
 
        return this->commitPreferencesToProfile(personID, providerName, referencedTime, preferences);
    }
 
 
} // namespace armarx::armem::human::client