void printHomeData(ULONG ID) {
printHeaders();
JSON::Object obj;
obj.add(new JSON::String("ID"), new JSON::Integer(ID));
obj.add(new JSON::String("homeData"), new JSON::String("test"));
obj.render();
}
// Test connection with node.
bool ElasticSearch::isActive() {
Json::Object root;
try {
_http.get(0, 0, &root);
}
catch(Exception& e){
printf("get(0) failed in ElasticSearch::isActive(). Exception caught: %s\n", e.what());
return false;
}
catch(std::exception& e){
printf("get(0) failed in ElasticSearch::isActive(). std::exception caught: %s\n", e.what());
return false;
}
catch(...){
printf("get(0) failed in ElasticSearch::isActive().\n");
return false;
}
if(root.empty())
return false;
if(!root.member("status") || root["status"].getInt() != 200){
printf("Status is not 200. Cannot find Elasticsearch Node.\n");
return false;
}
return true;
}
Promise<void> Client::ClientSession (
String access_token,
String profile_id,
String server_id,
const Vector<Byte> & secret,
const Vector<Byte> & public_key
) {
// Create JSON request
JSON::Object obj;
obj.Add(
session_token_key,
std::move(access_token),
session_profile_key,
std::move(profile_id),
session_server_id_key,
get_hash(server_id,secret,public_key)
);
// We have to use a custom URL
auto request=get_request(std::move(obj));
request.URL=String::Format(
session_url,
client_session_endpoint
);
// Dispatch
return dispatch<void>(std::move(request));
}
SEXP create(const json::Object& value, Protect* pProtect)
{
// create the list
SEXP listSEXP ;
pProtect->add(listSEXP = Rf_allocVector(VECSXP, value.size()));
// build list of names
SEXP namesSEXP ;
pProtect->add(namesSEXP = Rf_allocVector(STRSXP, value.size()));
// add each object field to it
int index = 0;
for (json::Object::const_iterator
it = value.begin();
it != value.end();
++it)
{
// set name
SET_STRING_ELT(namesSEXP, index, Rf_mkChar(it->first.c_str()));
// set value
SEXP valueSEXP = create(it->second, pProtect);
SET_VECTOR_ELT(listSEXP, index, valueSEXP);
// increment element index
index++;
}
// attach names
Rf_setAttrib(listSEXP, R_NamesSymbol, namesSEXP);
// return the list
return listSEXP;
}
Promise<RefreshResult> Client::Refresh (
String access_token,
String client_token,
Nullable<Profile> profile
) {
// Create JSON request
JSON::Object obj;
obj.Add(
refresh_token_key,
std::move(access_token),
refresh_client_token_key,
std::move(client_token)
);
if (!profile.IsNull()) obj.Add(
refresh_profile_key,
profile->ToJSON()
);
// Dispatch request
return dispatch<RefreshResult>(
refresh_endpoint,
std::move(obj)
);
}
void CompositorLoader::ParseRenderTargets(Compositor::Ptr& compositor, const json::Object& renderTargets)
{
for (auto it = renderTargets.begin(); it != renderTargets.end(); ++it)
{
const Value& data = it->second;
DataFormat dataFormat = JsonTypeHelper::ParseDataFormat(data);
compositor->AddRenderTarget(it->first, dataFormat);
if (data.HasKey("scale"))
{
compositor->SetRenderTargetScale(it->first, JsonTypeHelper::ParseFloatVector(data["scale"]).XY());
}
if (dataFormat.IsDepthFormat())
{
if (data.HasKey("clearDepth"))
{
compositor->SetClearDepth(it->first, data["clearDepth"].ToFloat(1.0f));
}
}
else
{
if (data.HasKey("clearColor"))
{
compositor->SetClearColor(it->first, JsonTypeHelper::ParseColor(data["clearColor"]));
}
}
}
}
Promise<AuthenticateResult> Client::Authenticate (
String username,
String password,
Nullable<String> client_token,
Nullable<Agent> agent
) {
// Create JSON request
JSON::Object obj;
obj.Add(
auth_username_key,
std::move(username),
auth_password_key,
std::move(password)
);
if (!client_token.IsNull()) obj.Add(
auth_client_token_key,
std::move(*client_token)
);
if (!agent.IsNull()) obj.Add(
auth_agent_key,
agent->ToJSON()
);
// Dispatch request
return dispatch<AuthenticateResult>(
auth_endpoint,
std::move(obj)
);
}
/// Index a document.
bool ElasticSearch::index(const std::string& index, const std::string& type, const std::string& id, const Json::Object& jData){
if(_readOnly)
return false;
std::stringstream url;
url << index << "/" << type << "/" << id;
std::stringstream data;
data << jData;
Json::Object result;
_http.put(url.str().c_str(), data.str().c_str(), &result);
if(!result.member("created"))
EXCEPTION("The index induces error.");
if(result.getValue("created"))
return true;
std::cout << "endPoint: " << index << "/" << type << "/" << id << std::endl;
std::cout << "jData" << jData.pretty() << std::endl;
std::cout << "result" << result.pretty() << std::endl;
EXCEPTION("The index returns ok: false.");
return false;
}
void BulkBuilder::update_doc(const std::string &index, const std::string &type, const std::string &id, const Json::Object &fields, bool upsert) {
createCommand("update", index, type, id);
Json::Object updateFields;
updateFields.addMemberByKey("doc", fields);
updateFields.addMemberByKey("doc_as_upsert", upsert);
operations.push_back(updateFields);
}
WeatherForecast::WeatherForecast(const Json::Object &json)
: _city(json.get("city"))
{
_count = json.get("cnt").toNumber().orIfNull(0);
_cod = json.get("cod").toString().orIfNull("");
Json::Array weathers = json.get("list");
for(auto w: weathers) {
_weathers.push_back({w});
}
}
/// Delete the document by index/type/id.
bool ElasticSearch::deleteDocument(const char* index, const char* type, const char* id){
if(_readOnly)
return false;
std::ostringstream oss;
oss << index << "/" << type << "/" << id;
Json::Object msg;
_http.remove(oss.str().c_str(), 0, &msg);
return msg.getValue("found");
}
JSON::Object Profile::ToJSON () {
JSON::Object retr;
retr.Add(
profile_id_key,
std::move(ID),
profile_name_key,
std::move(Name)
);
return retr;
}
JSON::Object Agent::ToJSON () {
JSON::Object retr;
retr.Add(
agent_name_key,
std::move(Name),
agent_version_key,
to_dbl(Version)
);
return retr;
}
// Request the document number of type T in index I.
long unsigned int ElasticSearch::getDocumentCount(const char* index, const char* type){
std::ostringstream oss;
oss << index << "/" << type << "/_count";
Json::Object msg;
_http.get(oss.str().c_str(),0,&msg);
size_t pos = 0;
if(msg.member("count"))
pos = msg.getValue("count").getUnsignedInt();
else
printf("We did not find \"count\" member.\n");
return pos;
}
void exceptionIfMissingKeys(
const json::Object& obj,
const string& objKey,
const string& key) {
if (!obj.HasKey(objKey)) {
throw VrCamException("JSON error. missing key:" + objKey);
}
const json::Object obj2 = obj[objKey];
if (!obj2.HasKey(key)) {
throw VrCamException("JSON error. missing key:" + key);
}
}
// Test if document exists
bool ElasticSearch::exist(const std::string& index, const std::string& type, const std::string& id){
std::stringstream url;
url << index << "/" << type << "/" << id;
Json::Object result;
_http.get(url.str().c_str(), 0, &result);
if(!result.member("found")){
std::cout << result << std::endl;
EXCEPTION("Database exception, field \"found\" must exist.");
}
return result.getValue("found");
}
core::Error readObject(const json::Object& object,
const std::string& name,
T* pValue)
{
json::Object::const_iterator it = object.find(name) ;
if (it == object.end())
return Error(errc::ParamMissing, ERROR_LOCATION) ;
if (!isType<T>(it->second))
return Error(errc::ParamTypeMismatch, ERROR_LOCATION) ;
*pValue = it->second.get_value<T>() ;
return Success() ;
}
Promise<void> Client::Signout (String username, String password) {
// Create JSON request
JSON::Object obj;
obj.Add(
signout_username_key,
std::move(username),
signout_password_key,
std::move(password)
);
// Dispatch
return dispatch<void>(
signout_endpoint,
std::move(obj)
);
}
/// Delete the document by index/type.
bool ElasticSearch::deleteAll(const char* index, const char* type){
if(_readOnly)
return false;
std::ostringstream uri, data;
uri << index << "/" << type << "/_query";
data << "{\"query\":{\"match_all\": {}}}";
Json::Object msg;
_http.remove(uri.str().c_str(), data.str().c_str(), &msg);
if(!msg.member("_indices") || !msg["_indices"].getObject().member(index) || !msg["_indices"].getObject()[index].getObject().member("_shards"))
return false;
if(!msg["_indices"].getObject()[index].getObject()["_shards"].getObject().member("failed"))
return false;
return (msg["_indices"].getObject()[index].getObject()["_shards"].getObject()["failed"].getInt() == 0);
}
Promise<void> Client::Invalidate (String access_token, String client_token) {
// Create JSON request
JSON::Object obj;
obj.Add(
invalidate_token_key,
std::move(access_token),
invalidate_client_token_key,
std::move(client_token)
);
// Dispatch
return dispatch<void>(
invalidate_endpoint,
std::move(obj)
);
}
// Update a document field.
bool ElasticSearch::update(const std::string& index, const std::string& type, const std::string& id, const std::string& key, const std::string& value){
if(_readOnly)
return false;
std::stringstream url;
url << index << "/" << type << "/" << id << "/_update";
std::stringstream data;
data << "{\"doc\":{\"" << key << "\":\""<< value << "\"}}";
Json::Object result;
_http.post(url.str().c_str(), data.str().c_str(), &result);
if(!result.member("_version"))
EXCEPTION("The update failed.");
return true;
}
// Update doccument fields.
bool ElasticSearch::update(const std::string& index, const std::string& type, const std::string& id, const Json::Object& jData){
if(_readOnly)
return false;
std::stringstream url;
url << index << "/" << type << "/" << id << "/_update";
std::stringstream data;
data << "{\"doc\":" << jData;
data << "}";
Json::Object result;
_http.post(url.str().c_str(), data.str().c_str(), &result);
if(result.member("error"))
EXCEPTION("The update doccument fields failed.");
return true;
}
/// Search API of ES.
long ElasticSearch::search(const std::string& index, const std::string& type, const std::string& query, Json::Object& result, const int n_result=10){
std::stringstream url;
url << index << "/" << type << "/_search?size=" << n_result;
_http.post(url.str().c_str(), query.c_str(), &result);
if(!result.member("timed_out")){
std::cout << url.str() << " -d " << query << std::endl;
std::cout << "result: " << result << std::endl;
EXCEPTION("Search failed.");
}
if(result.getValue("timed_out")){
std::cout << "result: " << result << std::endl;
EXCEPTION("Search timed out.");
}
return result.getValue("hits").getObject().getValue("total").getLong();
}
Promise<bool> Client::Validate (String access_token) {
// Create JSON request
JSON::Object obj;
obj.Add(
validate_token_key,
std::move(access_token)
);
// Dispatch request
return http.Execute(
get_request(
validate_endpoint,
std::move(obj)
)
).Then([] (Promise<MCPP::HTTPResponse> p) {
auto response=p.Get();
try {
check(response);
// We need to catch the ERROR to see whether
// it's JUST RETURNING FALSE ARE YOU KIDDING
// ME?
} catch (const Error & e) {
if (
(e.Type==invalid_token_type) &&
(e.Message==invalid_token_message)
) return false;
throw;
}
return true;
});
}
void getMailSettings(JSON::Object &obj, IDatabase *db)
{
std::vector<std::wstring> slist=getMailSettingsList();
IQuery *q=db->Prepare("SELECT key, value FROM settings_db.settings WHERE clientid=0 AND key=?");
for(size_t i=0;i<slist.size();++i)
{
q->Bind(slist[i]);
db_results res=q->Read();
q->Reset();
if(!res.empty())
{
obj.set(Server->ConvertToUTF8(slist[i]), res[0][L"value"]);
}
else
{
std::string v="";
if(slist[i]==L"mail_serverport")
v="25";
obj.set(Server->ConvertToUTF8(slist[i]), v);
}
}
}
//retrive all documemnts of a class
int ElasticSearch::fullScan(const std::string& index, const std::string& type, const std::string& query, Json::Array& resultArray, int scrollSize) {
// Get the scroll id
std::stringstream scrollUrl;
scrollUrl << index << "/" << type << "/_search?search_type=scan&scroll=10m&size=" << scrollSize;
Json::Object scrollObject;
_http.post(scrollUrl.str().c_str(),query.c_str(),&scrollObject);
if(!scrollObject.member("hits"))
EXCEPTION("Result corrupted, no member \"hits\".");
if(!scrollObject.getValue("hits").getObject().member("total"))
EXCEPTION("Result corrupted, no member \"total\" nested in \"hits\".");
int total = scrollObject.getValue("hits").getObject().getValue("total").getInt();
std::string scrollId = scrollObject["_scroll_id"].getString();
int count = 0;
while(count < total) {
Json::Object result;
_http.rawpost("_search/scroll?scroll=10m", scrollId.c_str(), &result);
// Kepp the new scroll id we received to inject in the next iteration.
scrollId = result["_scroll_id"].getString();
for(const Json::Value& value : result["hits"].getObject()["hits"].getArray()){
resultArray.addElement(value);
++count;
}
}
if(count != total)
EXCEPTION("Result corrupted, total is different from count.");
return total;
}
/// Index a document with automatic id creation
std::string ElasticSearch::index(const std::string& index, const std::string& type, const Json::Object& jData){
if(_readOnly)
return "";
std::stringstream url;
url << index << "/" << type << "/";
std::stringstream data;
data << jData;
Json::Object result;
_http.post(url.str().c_str(), data.str().c_str(), &result);
if(!result.member("created") || !result.getValue("created")){
std::cout << "url: " << url.str() << std::endl;
std::cout << "data: " << data.str() << std::endl;
std::cout << "result: " << result.str() << std::endl;
EXCEPTION("The index induces error.");
}
return result.getValue("_id").getString();
}
// this method is called when REST response is received for request to get user information:
void handleMe(boost::system::error_code err, const Http::Message& response)
{
#ifndef WT_TARGET_JAVA
WApplication::instance()->resumeRendering();
#endif
if (!err && response.status() == 200) {
#ifndef WT_TARGET_JAVA
Json::ParseError e;
Json::Object me;
bool ok = Json::parse(response.body(), me, e);
#else
Json::Object me;
try {
me = (Json::Object)Json::Parser().parse(response.body());
}
catch (Json::ParseError pe) {
}
bool ok = me.isNull();
#endif
if (!ok) {
LOG_ERROR("could not parse JSON: '" << response.body() << "'");
setError(ERROR_MSG("badjson"));
authenticated().emit(Identity::Invalid);
}
else {
std::string id = me.get("id");
std::string email = me.get("emailAddress");
if (getUserProfileAsJson)
{
// In the Identity's name field more complete user info is passed in JSON format as returned from LinkedIn, see details at:
// https://developer.linkedin.com/docs/fields/basic-profile
authenticated().emit(Identity(service().name(), id, response.body(), email, true));
}
else
{
std::string name = me.get("firstName");
name += std::string(" ");
name += std::string(me.get("lastName"));
authenticated().emit(Identity(service().name(), id, name, email, true));
}
}
}
else {
if (!err) {
LOG_ERROR("user info request returned: " << response.status());
LOG_ERROR("with: " << response.body());
}
else {
LOG_ERROR("handleMe(): " << err.message());
}
setError(ERROR_MSG("badresponse"));
authenticated().emit(Identity::Invalid);
}
}
void PlotManipulatorManager::setPlotManipulatorValues(const json::Object& values)
{
if (manipulatorIsActive())
{
// get the manipulator
SEXP manipulatorSEXP = plotManager().activePlot().manipulatorSEXP();
// set the underlying values
std::for_each(values.begin(),
values.end(),
boost::bind(setManipulatorJsonValue, manipulatorSEXP, _1));
// replay the manipulator
replayManipulator(manipulatorSEXP);
// set all of the buttons to false
setManipulatorButtonsToFalse(manipulatorSEXP);
}
else
{
LOG_WARNING_MESSAGE("called setPlotManipulatorValues but active plot "
"has no manipulator");
}
}
void ControllerServer::handle_http_get( const HttpServer::Request & request , HttpServer::Response & response )
{
if ( request.get_path() == "/controllers" )
{
JSON::Object result;
result[ "version" ] = CONTROLLER_PROTOCOL_VERSION;
result[ "port" ] = server->get_port();
response.set_response( "application/json", result.stringify() );
response.set_status( HttpServer::HTTP_STATUS_OK );
return;
}
ResourceMap::iterator it = resources.find( request.get_path() );
if ( it == resources.end() )
{
return;
}
response.respond_with_file_contents( it->second.native_uri );
}