예제 #1
0
    std::string collection::insert(nlohmann::json::object_t const& document) throw(std::runtime_error)
    {
        bson_oid_t oid;

        std::shared_ptr<bson> bson_doc = convert_to_bson(document);
        if(document.find("_id") != document.end()) {
            std::string const &id = document.find("_id")->second;
            if(!ejdbisvalidoidstr(id.c_str())) {
                throw ejdb_exception(JBEINVALIDBSONPK);
            }
            bson_oid_from_string(&oid, id.c_str());
            std::shared_ptr<bson> bson_oid(bson_create(), bson_del);
            bson_init(bson_oid.get());
            bson_append_oid(bson_oid.get(), "_id", &oid);
            bson_finish(bson_oid.get());
            std::shared_ptr<bson> bson_doc_with_oid(bson_create(), bson_del);
            bson_init(bson_doc_with_oid.get());
            bson_merge(bson_oid.get(), bson_doc.get(), true, bson_doc_with_oid.get());
            bson_finish(bson_doc_with_oid.get());
            bson_doc.swap(bson_doc_with_oid);
        }

        if(!ejdbsavebson(_coll.get(), bson_doc.get(), &oid)) {
            throw_last_ejdb_exception();
        }

        std::string id(24, '\0');
        bson_oid_to_string(&oid, &id[0]);

        document_added(id, document);
        return id;
    }
예제 #2
0
void deserializeGraph(const nlohmann::json::object_t& graph,
                      IntentStoryModel& intentStoryModel) {
  nlohmann::json::object_t::const_iterator sourceEdgeIt = graph.begin();
  nlohmann::json::object_t::const_iterator sourceEdgeItEnd = graph.end();

  for (; sourceEdgeIt != sourceEdgeItEnd; ++sourceEdgeIt) {
    const std::string& sourceId = sourceEdgeIt->first;
    const nlohmann::json::object_t& edgeTarget = sourceEdgeIt->second;

    nlohmann::json::object_t::const_iterator edgeTargetIt = edgeTarget.begin();
    nlohmann::json::object_t::const_iterator edgeTargetItEnd = edgeTarget.end();

    for (; edgeTargetIt != edgeTargetItEnd; ++edgeTargetIt) {
      const std::string& intentAndAction = edgeTargetIt->first;
      std::vector<std::string> tokens;
      SingleCharacterDelimiterTokenizer::tokenize(intentAndAction, ":", tokens);

      std::string intentName;
      std::string actionId;
      intentName = tokens[0];
      if (tokens.size() == 2) actionId = tokens[1];

      const std::string& targetId = edgeTargetIt->second;

      IntentStoryModel::EdgeInfo edgeInfo;
      edgeInfo.intent.intentId = intentName;
      edgeInfo.actionId = actionId;

      IntentStoryModel::StoryGraph::Vertex source;
      IntentStoryModel::StoryGraph::Vertex target;

      IntentStoryModel::VertexByStateIdIndex::const_iterator it =
          intentStoryModel.vertexByStateId.find(sourceId);
      if (it != intentStoryModel.vertexByStateId.end()) {
        source = it->second;
      } else  // Adding vertex
      {
        IntentStoryModel::VertexInfo vertexInfo;
        vertexInfo.stateId = sourceId;
        source = intentStoryModel.graph.addVertex(vertexInfo);
        intentStoryModel.vertexByStateId[sourceId] = source;
      }

      it = intentStoryModel.vertexByStateId.find(targetId);
      if (it != intentStoryModel.vertexByStateId.end()) {
        target = it->second;
      } else  // Adding vertex
      {
        IntentStoryModel::VertexInfo vertexInfo;
        vertexInfo.stateId = targetId;
        target = intentStoryModel.graph.addVertex(vertexInfo);
        intentStoryModel.vertexByStateId[targetId] = target;
      }

      intentStoryModel.graph.addEdge(source, target, edgeInfo);
    }
  }
}
예제 #3
0
void deserializeReplies(const nlohmann::json::object_t& replies,
                        ChatbotActionModel& chatbotActionModel) {
  nlohmann::json::object_t::const_iterator replyIt = replies.begin();
  nlohmann::json::object_t::const_iterator replyItEnd = replies.end();

  for (; replyIt != replyItEnd; ++replyIt) {
    const std::string& replyId = replyIt->first;
    const std::string& reply = replyIt->second;

    chatbotActionModel.replyContentByReplyIdIndex[replyId] = reply;
  }
}
예제 #4
0
void deserializeReplyIdsByActionId(
    const nlohmann::json::object_t& repliesByAction, const std::string& state,
    ChatbotActionModel& chatbotActionModel) {
  nlohmann::json::object_t::const_iterator repliesByActionIt =
      repliesByAction.begin();
  nlohmann::json::object_t::const_iterator repliesByActionItEnd =
      repliesByAction.end();

  for (; repliesByActionIt != repliesByActionItEnd; ++repliesByActionIt) {
    const std::string& actionId = repliesByActionIt->first;
    const nlohmann::json::array_t& repliesList = repliesByActionIt->second;

    appendRepliesListByStateAndActionId(state, actionId, repliesList,
                                        chatbotActionModel);
  }
}
예제 #5
0
void deserializeReplyIdsByStateAndActionId(
    const nlohmann::json::object_t& repliesByStatesAndActions,
    ChatbotActionModel& chatbotActionModel) {
  nlohmann::json::object_t::const_iterator repliesByStatesAndActionsIt =
      repliesByStatesAndActions.begin();
  nlohmann::json::object_t::const_iterator repliesByStatesAndActionsItEnd =
      repliesByStatesAndActions.end();

  for (; repliesByStatesAndActionsIt != repliesByStatesAndActionsItEnd;
       ++repliesByStatesAndActionsIt) {
    const std::string& state = repliesByStatesAndActionsIt->first;
    const nlohmann::json::object_t& repliesByActions =
        repliesByStatesAndActionsIt->second;

    deserializeReplyIdsByActionId(repliesByActions, state, chatbotActionModel);
  }
}
예제 #6
0
void deserializeDictionary(const nlohmann::json::object_t& dictionary,
                           DictionaryModel& dictionaryModel) {
  nlohmann::json::object_t::const_iterator entitiesIt = dictionary.begin();
  nlohmann::json::object_t::const_iterator entitiesItEnd = dictionary.end();

  unsigned int termId = 0;
  for (unsigned int i = 0; entitiesIt != entitiesItEnd; ++entitiesIt, i++) {
    dictionaryModel.entitiesByEntityId[i] = entitiesIt->first;

    const nlohmann::json::object_t& termsAndAlias = entitiesIt->second;
    nlohmann::json::object_t::const_iterator termsAndAliasIt =
        termsAndAlias.begin();
    nlohmann::json::object_t::const_iterator termsAndAliasItEnd =
        termsAndAlias.end();

    for (; termsAndAliasIt != termsAndAliasItEnd; ++termsAndAliasIt) {
      if (isTermRegex(termsAndAliasIt)) {
        dictionaryModel.regexesByEntityId[termsAndAliasIt->second] = i;
      } else {
        Term term;

        term.term = termsAndAliasIt->first;
        term.termId = termId;
        term.entityId = i;

        nlohmann::json::array_t alias = termsAndAliasIt->second;
        nlohmann::json::array_t::const_iterator aliasIt = alias.begin();
        nlohmann::json::array_t::const_iterator aliasItEnd = alias.end();

        for (unsigned int k = 0; aliasIt != aliasItEnd; aliasIt++, ++k) {
          term.alias.push_back(*aliasIt);
        }

        dictionaryModel.dictionary.pushTerm(term);
      }
      termId++;
    }
  }
}
예제 #7
0
    nlohmann::json collection::modified_fields(nlohmann::json::object_t const& a, nlohmann::json::object_t const& b)
    {
        nlohmann::json::object_t diff;
        std::set_difference(b.begin(), b.end(), a.begin(), a.end(), std::inserter(diff, diff.begin()));

        std::vector<std::string> cleared_fields;
        for(auto const& field: a) {
            if(b.find(field.first) == b.end()) {
                cleared_fields.push_back(field.first);
            }
        }
        return {{ "fields", diff }, { "cleared", cleared_fields }};
    }