rms.cpp

Go to the documentation of this file.

#include <rmscpp/rms.h>
#include <sstream>
#include <stdlib.h>
#include <string.h>

using namespace std;
using namespace rms;

rms_client::rms_client(std::string host, int port, PROTOCOL protocol)
{
  // create the cURL handle
  curl = curl_easy_init();
  // set the pointer to the function which handles the responses
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &write_data);

  // build the start string
  switch (protocol)
  {
    case HTTPS_PROTOCOL:
      url_start = "https://";
      break;
    default:
      // default to HTTP
      url_start = "http://";
      break;
  }
  stringstream ss;
  ss << url_start << host << ":" << port << API;
  url_start = ss.str();
}

rms_client::~rms_client()
{
  // cleanup anything left by cURL
  curl_easy_cleanup(curl);
}

void rms_client::set_authorization(string username, string password)
{
  // set the username and password
  curl_easy_setopt(curl, CURLOPT_USERPWD, username.append(":").append(password).c_str());
}

vector<javascript_file> rms_client::get_javascript_files()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << JAVASCRIPT_FILES_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<javascript_file> v = parse_javascript_files_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

javascript_file rms_client::get_javascript_file_by_id(int fileid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << JAVASCRIPT_FILES_DEFAULT << "?" << JAVASCRIPT_FILES_ID_FIELD << "=" << fileid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    javascript_file jsf = parse_javascript_file(json_object_object_get(json, "data"));
    json_object_put(json);
    return jsf;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<article> rms_client::get_articles()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << ARTICLES_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<article> v = parse_articles_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

article rms_client::get_article_by_id(int artid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << ARTICLES_DEFAULT << "?" << ARTICLES_ID_FIELD << "=" << artid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    article u = parse_article(json_object_object_get(json, "data"));
    json_object_put(json);
    return u;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<article> rms_client::get_articles_by_pageid(int pageid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << ARTICLES_DEFAULT << "?" << ARTICLES_PAGES_ID_FIELD << "=" << pageid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<article> v = parse_articles_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<content_page> rms_client::get_content_pages()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << CONTENT_PAGES_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<content_page> v = parse_content_pages_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

content_page rms_client::get_content_page_by_id(int pageid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << CONTENT_PAGES_DEFAULT << "?" << CONTENT_PAGES_ID_FIELD << "=" << pageid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    content_page cp = parse_content_page(json_object_object_get(json, "data"));
    json_object_put(json);
    return cp;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<slide> rms_client::get_slides()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << SLIDES_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<slide> v = parse_slides_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<condition> rms_client::get_conditions()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << CONDITIONS_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<condition> v = parse_conditions_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

condition rms_client::get_condition_by_id(int condid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << CONDITIONS_DEFAULT << "?" << CONDITIONS_ID_FIELD << "=" << condid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    condition c = parse_condition(json_object_object_get(json, "data"));
    json_object_put(json);
    return c;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<experiment> rms_client::get_experiments()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << EXPERIMENTS_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<experiment> v = parse_experiments_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

experiment rms_client::get_experiment_by_id(int expid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << EXPERIMENTS_DEFAULT << "?" << EXPERIMENTS_ID_FIELD << "=" << expid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    experiment c = parse_experiment(json_object_object_get(json, "data"));
    json_object_put(json);
    return c;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<study> rms_client::get_studies()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << STUDIES_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<study> v = parse_studies_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

study rms_client::get_study_by_id(int studyid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << STUDIES_DEFAULT << "?" << STUDIES_ID_FIELD << "=" << studyid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    study s = parse_study(json_object_object_get(json, "data"));
    json_object_put(json);
    return s;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<study_log> rms_client::get_study_logs()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << STUDY_LOGS_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<study_log> v = parse_study_logs_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

study_log rms_client::get_study_log_by_id(int logid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << STUDY_LOGS_DEFAULT << "?" << STUDY_LOGS_ID_FIELD << "=" << logid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    study_log sl = parse_study_log(json_object_object_get(json, "data"));
    json_object_put(json);
    return sl;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<study_log> rms_client::get_study_logs_by_expid(int expid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << STUDY_LOGS_DEFAULT << "?" << STUDY_LOGS_EXPERIMENTS_ID_FIELD << "=" << expid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<study_log> v = parse_study_logs_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<user_account> rms_client::get_user_accounts()
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << USER_ACCOUNTS_DEFAULT;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    vector<user_account> v = parse_user_accounts_array(json_object_object_get(json, "data"));
    json_object_put(json);
    return v;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

user_account rms_client::get_user_account_by_id(int userid)
{
  // build the string and make the request
  stringstream ss;
  ss << url_start << USER_ACCOUNTS_DEFAULT << "?" << USER_ACCOUNTS_ID_FIELD << "=" << userid;
  json_object *json = make_request(ss.str());

  // check if we should throw an error
  if (extract_json_bool(json, "ok"))
  {
    user_account u = parse_user_account(json_object_object_get(json, "data"));
    json_object_put(json);
    return u;
  }
  else
  {
    string msg = extract_json_string(json, "msg");
    json_object_put(json);
    throw msg;
  }
}

vector<javascript_file> rms_client::parse_javascript_files_array(json_object *json_array)
{
  vector<javascript_file> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_javascript_file(json_object_array_get_idx(json_array, i)));

  return v;
}

javascript_file rms_client::parse_javascript_file(json_object *json)
{
  // pull out all of the info from the JSON object
  int fileid = extract_json_int(json, "fileid");
  string url = extract_json_string(json, "url");
  string path = extract_json_string(json, "path");

  return javascript_file(fileid, url, path);
}

vector<article> rms_client::parse_articles_array(json_object *json_array)
{
  vector<article> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_article(json_object_array_get_idx(json_array, i)));

  return v;
}

article rms_client::parse_article(json_object *json)
{
  // pull out all of the info from the JSON object
  int artid = extract_json_int(json, "artid");
  string title = extract_json_string(json, "title");
  string content = extract_json_string(json, "content");
  int pageid = extract_json_int(json, "pageid");
  int index = extract_json_int(json, "index");

  return article(artid, title, content, pageid, index);
}

vector<content_page> rms_client::parse_content_pages_array(json_object *json_array)
{
  vector<content_page> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_content_page(json_object_array_get_idx(json_array, i)));

  return v;
}

content_page rms_client::parse_content_page(json_object *json)
{
  // pull out all of the info from the JSON object
  int pageid = extract_json_int(json, "pageid");
  string title = extract_json_string(json, "title");
  string menu = extract_json_string(json, "menu");
  int index = extract_json_int(json, "index");
  string js = extract_json_string(json, "js");

  return content_page(pageid, title, menu, index, js);
}

vector<slide> rms_client::parse_slides_array(json_object *json_array)
{
  vector<slide> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_slide(json_object_array_get_idx(json_array, i)));

  return v;
}

slide rms_client::parse_slide(json_object *json)
{
  // pull out all of the info from the JSON object
  int slideid = extract_json_int(json, "slideid");
  string img = extract_json_string(json, "img");
  string caption = extract_json_string(json, "caption");
  int index = extract_json_int(json, "index");

  return slide(slideid, img, caption, index);
}

vector<condition> rms_client::parse_conditions_array(json_object *json_array)
{
  vector<condition> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_condition(json_object_array_get_idx(json_array, i)));

  return v;
}

condition rms_client::parse_condition(json_object *json)
{
  // pull out all of the info from the JSON object
  int condid = extract_json_int(json, "condid");
  int studyid = extract_json_int(json, "studyid");
  string name = extract_json_string(json, "name");
  int intid = extract_json_int(json, "intid");

  return condition(condid, studyid, name, intid);
}

vector<experiment> rms_client::parse_experiments_array(json_object *json_array)
{
  vector<experiment> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_experiment(json_object_array_get_idx(json_array, i)));

  return v;
}

experiment rms_client::parse_experiment(json_object *json)
{
  // pull out all of the info from the JSON object
  int expid = extract_json_int(json, "expid");
  int userid = extract_json_int(json, "userid");
  int condid = extract_json_int(json, "condid");
  int envid = extract_json_int(json, "envid");
  string start = extract_json_string(json, "start");
  string end = extract_json_string(json, "end");

  return experiment(expid, userid, condid, envid, start, end);
}

vector<study> rms_client::parse_studies_array(json_object *json_array)
{
  vector<study> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_study(json_object_array_get_idx(json_array, i)));

  return v;
}

study rms_client::parse_study(json_object *json)
{
  // pull out all of the info from the JSON object
  int studyid = extract_json_int(json, "studyid");
  string name = extract_json_string(json, "name");
  string description = extract_json_string(json, "description");
  string start = extract_json_string(json, "start");
  string end = extract_json_string(json, "end");

  return study(studyid, name, description, start, end);
}

vector<study_log> rms_client::parse_study_logs_array(json_object *json_array)
{
  vector<study_log> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_study_log(json_object_array_get_idx(json_array, i)));

  return v;
}

study_log rms_client::parse_study_log(json_object *json)
{
  // pull out all of the info from the JSON object
  int logid = extract_json_int(json, "logid");
  int expid = extract_json_int(json, "expid");
  string timestamp = extract_json_string(json, "timestamp");
  string entry = extract_json_string(json, "entry");

  return study_log(logid, expid, timestamp, entry);
}

vector<user_account> rms_client::parse_user_accounts_array(json_object *json_array)
{
  vector<user_account> v;

  // go through each JSON object in the array
  int length = json_object_array_length(json_array);
  for (int i = 0; i < length; i++)
    v.push_back(parse_user_account(json_object_array_get_idx(json_array, i)));

  return v;
}

user_account rms_client::parse_user_account(json_object *json)
{
  // pull out all of the info from the JSON object
  int userid = extract_json_int(json, "userid");
  string username = extract_json_string(json, "username");
  string firstname = extract_json_string(json, "firstname");
  string lastname = extract_json_string(json, "lastname");
  string email = extract_json_string(json, "email");
  string type_string = extract_json_string(json, "type");
  USER_ACCOUNT_TYPE type;
  if (type_string.compare("admin") == 0)
    type = ADMIN;
  else
    type = USER;

  return user_account(userid, username, firstname, lastname, email, type);
}

string rms_client::extract_json_string(json_object *json, string key)
{
  json_object *obj = json_object_object_get(json, key.c_str());

  // check for a null value
  if (obj)
  {
    const char *src = json_object_get_string(obj);
    char *dst = (char *)malloc(strlen(src) + 1);
    string s = string(strcpy(dst, src));

    return s;
  }
  else
    return string("NULL");
}

bool rms_client::extract_json_bool(json_object *json, string key)
{
  json_object *obj = json_object_object_get(json, key.c_str());
  bool b = json_object_get_boolean(obj);

  return b;
}

int rms_client::extract_json_int(json_object *json, string key)
{
  json_object *obj = json_object_object_get(json, key.c_str());
  int i = json_object_get_int(obj);

  return i;
}

json_object *rms_client::make_request(string url)
{
  // create the response
  rms_response *resp = new rms_response;
  resp->size = 0;
  resp->data = NULL;
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, resp);

  //send the command to the server
  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
  curl_easy_perform(curl);

  json_object *json = json_tokener_parse(resp->data);

  free_rms_response(resp);
  return json;
}

void rms_client::free_rms_response(rms::rms_response *buf)
{
  // check if the response is null
  if (buf)
  {
    // free the data (if any)
    if (buf->data)
      free(buf->data);
    // free the struct
    free(buf);
  }
}

size_t rms::write_data(char *ptr, size_t size, size_t nmemb, rms::rms_response *buf)
{
  // actual size of the new data
  size_t new_data = size * nmemb;

  // see if there is any data
  if (new_data > 0)
  {
    // check if the buffer already has data
    if (buf->data)
      // resize the buffer
      buf->data = (char *)realloc(buf->data, buf->size + new_data + 1);
    else
      // allocate the initial memory
      buf->data = (char *)malloc(new_data + 1);

    // add the data to the buffer
    memcpy(&(buf->data[buf->size]), ptr, new_data);
    //update the size
    buf->size += new_data;
    // null terminate
    buf->data[buf->size] = '\0';
  }

  return new_data;
}