mongodb.cpp

Go to the documentation of this file.

#include "mongodb.h"
 
// Simox
#include <SimoxUtility/json.h>
 
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::armem::server::ltm::util::mongodb
{
    namespace bbuilder = bsoncxx::builder;
    namespace bdoc = bsoncxx::document;
 
    namespace detail
    {
        std::string
        escapeName(const std::string& segmentName)
        {
            std::string ret = segmentName;
            //simox::alg::replace_all(ret, Prefix, PrefixEscaped);
            for (const auto& [s, r] : EscapeTable)
            {
                ret = simox::alg::replace_all(ret, s, r);
            }
            return ret;
        }
 
        std::string
        unescapeName(const std::string& escapedName)
        {
            std::string ret = escapedName;
            for (
                const auto& [s, r] :
                EscapeTable) // Here we assume that noone uses the replaced char usually in the segment name... TODO
            {
                ret = simox::alg::replace_all(ret, r, s);
            }
            return ret;
        }
 
        bool
        insert(mongocxx::collection& coll, const nlohmann::json& value)
        {
            std::string v = value.dump();
            auto q = bsoncxx::from_json(v);
            auto res = coll.insert_one(q.view());
 
            return (bool)res;
        }
 
        std::optional<nlohmann::json>
        contains(mongocxx::collection& coll, const nlohmann::json& value)
        {
            // check mongodb
            std::string v = value.dump();
            auto q = bsoncxx::from_json(v);
            auto res = coll.find_one(q.view());
            if (res)
            {
                return nlohmann::json::parse(bsoncxx::to_json(*res));
            }
            return std::nullopt;
        }
 
        bool
        update(mongocxx::collection& coll,
               const nlohmann::json& query,
               const nlohmann::json& update)
        {
            // check mongodb
            auto q = bsoncxx::from_json(query.dump());
            auto udoc = bsoncxx::from_json(update.dump());
            auto u = bbuilder::basic::make_document(bbuilder::basic::kvp("$set", udoc));
 
            auto res = coll.update_one(q.view(), u.view());
 
            return (bool)res;
        }
    } // namespace detail
 
    std::optional<mongocxx::database>
    databaseExists(mongocxx::client& client, const std::string& databaseName)
    {
        //auto names = client.list_databases();
        //if (auto it = std::find(names.begin(), names.end(), databaseName); it != names.end())
        //{
        //    return client[databaseName];
        //}
        return std::nullopt;
    }
 
    mongocxx::database
    ensureDatabaseExists(mongocxx::client& client,
                         const std::string& databaseName,
                         bool createIfNotExistent)
    {
        auto db = databaseExists(client, databaseName);
        if (!db)
        {
            if (!createIfNotExistent)
            {
                throw armarx::LocalException("Database existence can not be ensured: " +
                                             databaseName);
            }
        }
        return client[databaseName];
    }
 
    std::optional<mongocxx::collection>
    collectionExists(mongocxx::database& db, const std::string& collectionName)
    {
        if (db.has_collection(collectionName))
        {
            return db[collectionName];
        }
        return std::nullopt;
    }
 
    mongocxx::collection
    ensureCollectionExists(mongocxx::database& db,
                           const std::string& collectionName,
                           bool createIfNotExistent)
    {
        auto coll = collectionExists(db, collectionName);
        if (!coll)
        {
            if (!createIfNotExistent)
            {
                throw armarx::LocalException("Collection existence can not be ensured: " +
                                             collectionName);
            }
        }
        return db[collectionName];
    }
 
    std::string
    toDocumentID(const armem::MemoryID& id)
    {
        if (id.hasTimestamp())
        {
            return id.timestampStr();
        }
 
        // fallback
        throw armarx::LocalException("Called toDocumentName() on non-snapshot id: " + id.str());
    }
 
    std::string
    toCollectionName(const armem::MemoryID& id)
    {
        ARMARX_CHECK(id.isWellDefined());
        std::stringstream ss;
        if (id.hasMemoryName())
        {
            ss << detail::escapeName(id.memoryName);
        }
        if (id.hasCoreSegmentName())
        {
            ss << "." << detail::escapeName(id.coreSegmentName);
        }
        if (id.hasProviderSegmentName())
        {
            ss << "." << detail::escapeName(id.providerSegmentName);
        }
        if (id.hasEntityName())
        {
            ss << "." << detail::escapeName(id.entityName);
        }
 
        return ss.str();
    }
 
    std::optional<nlohmann::json>
    documentExists(mongocxx::collection& collection, const nlohmann::json& json)
    {
        return detail::contains(collection, json);
    }
 
    nlohmann::json
    ensureDocumentExists(mongocxx::collection& collection,
                         const nlohmann::json& json,
                         bool createIfNotExistent)
    {
        auto op = documentExists(collection, json);
        if (!op)
        {
            if (!createIfNotExistent)
            {
                throw armarx::LocalException("Document existence can not be ensured: " +
                                             json.dump());
            }
        }
 
        if (!op)
        {
            detail::insert(collection, json);
        }
 
        auto find = detail::contains(collection, json);
        if (!find)
        {
            throw armarx::LocalException(
                "Even after creating the docuemnt it wasnt found.. error: " + json.dump());
        }
        return *find;
    }
 
    nlohmann::json
    readDataFromDocument(mongocxx::collection& collection, const nlohmann::json& json)
    {
        auto doc = detail::contains(collection, json);
 
        ARMARX_CHECK((bool)doc) << " Could not find document matching: " << json.dump()
                                << " in collection " << collection.name();
 
        return *doc;
    }
 
    void
    writeDataToDocument(mongocxx::collection& collection,
                        const nlohmann::json& query,
                        const nlohmann::json& update)
    {
        if (documentExists(collection, query))
        {
            detail::update(collection, query, update);
        }
        else
        {
            nlohmann::json full;
            full.update(query);
            full.update(update);
            detail::insert(collection, full);
        }
    }
 
    std::vector<nlohmann::json>
    getAllDocuments(mongocxx::collection& collection)
    {
        std::vector<nlohmann::json> ret;
        mongocxx::cursor cursor = collection.find({});
        for (const auto& doc : cursor)
        {
            ret.push_back(
                nlohmann::json::parse(bsoncxx::to_json(doc, bsoncxx::ExtendedJsonMode::k_relaxed)));
        }
        return ret;
    }
 
} // namespace armarx::armem::server::ltm::util::mongodb