Bridges.h

Go to the documentation of this file.

#ifndef BRIDGES_H
#define BRIDGES_H
 
#include <iostream>
#include <algorithm>
using namespace std;
 
#include "DataStructure.h" //string, using std
#include "ServerComm.h" //vector
 
#include <JSONutil.h>
#include <alltypes.h>
#include <chrono>
 
namespace bridges {
    using namespace bridges::datastructure;
 
    namespace game {
        class SocketConnection;
    }
    class Bridges {
        private:
            static bool profile() {
                return false;
            }
 
            static string getDefaultServerURL() {
                return "http://bridges-cs.herokuapp.com";
            }
 
            bool jsonFlag = false;                  // if JSON is to be printed
 
            // this flag will turn on all labels in the visualization
            bool element_labelFlag = false, link_labelFlag = false;
 
            bool post_visualization_link = true;    // post flag of visualization url
 
            string user_name = string(),
                   api_key = string();              // user credentials
 
            string map[2];                          // for map overlays
 
            string description = string();          // visualization description
 
            string title = string();                            // title of visualization
 
            unsigned int assn_num = 0;              // assignment id
 
            DataStructure* ds_handle = nullptr;     // data structure handle
 
            string server_url = "http://bridges-cs.herokuapp.com";
 
            string BASE_URL = server_url + "/assignments/";
 
            // map overlay options
            string map_overlay_options[3] = {"cartesian", "albersusa", "equirectangular"};
            bool map_overlay = false;
            string coord_system_type = "cartesian";
 
            // world coordinate window
            vector<double> wc_window;
 
            unsigned int lastAssignNum = 0, subAssignNum = 0;
 
        public:
 
            Bridges() {
                Bridges (0, "", "");
            }
            Bridges (const string& name, const string& key) {
                Bridges (0, name, key);
            }
            Bridges (unsigned int num, const string& name, const string& key) {
                setAssignment(num);
                setUserName(name);
                setApiKey(key);
                setServer("live");
            }
 
            void setElementLabelFlag(bool flag) {
                element_labelFlag = flag;
            }
            void setLinkLabelFlag(bool flag) {
                link_labelFlag = flag;
            }
 
            bool getElementLabelFlag() const {
                return element_labelFlag;
            }
            bool getLinkLabelFlag() const {
                return link_labelFlag;
            }
 
            bool getJSONFlag() const {
                return jsonFlag;
            }
 
            void  postVisualizationLink(bool link_url) {
                post_visualization_link = link_url;
            }
 
            void setJSONFlag(bool flag) {
                jsonFlag = flag;
            }
 
            const string& getUserName() const {
                return user_name;
            }
            void setUserName(string name) {
                char* force = getenv("FORCE_BRIDGES_USERNAME");
                if (force != nullptr) {
                    name = force;
                }
 
                user_name = name;
            }
            const string& getApiKey()  const {
                return api_key;
            }
            void setApiKey(string key) {
                char* force = getenv("FORCE_BRIDGES_APIKEY");
                if (force != nullptr) {
                    key = force;
                }
                api_key = key;
            }
            unsigned int getAssignment() const {
                return assn_num;
            }
            void setAssignment(unsigned int num) {
                char* force = getenv("FORCE_BRIDGES_ASSIGNMENT");
                if (force != nullptr) {
                    num = std::atoi(force);
                }
 
                assn_num =  num;
 
                if (assn_num != lastAssignNum) {        // reset if a new assignment
                    lastAssignNum = assn_num;
                    subAssignNum = 0;
                }
            }
            const string& getTitle() const {
                return title;
            }
 
            void setTitle(const string& t) {
                title = t;
            }
            const string& getDescription() const {
                return description;
            }
            void setDescription(const string& descr) {
                description = descr;
            }
 
            void setDataStructure(DataStructure *ds) {
                ds_handle = ds;
            }
 
            void setDataStructure(DataStructure &ds) {
                setDataStructure(&ds);
            }
 
            DataStructure* getDataStructure() {
                return ds_handle;
            }
 
            void setServer(string server_type) {
                char* force = getenv("FORCE_BRIDGES_APISERVER");
                if (force != nullptr) {
                    server_type = force;
                }
 
                if (server_type == "live")
                    server_url = "http://bridges-cs.herokuapp.com";
                else if (server_type == "clone")
                    server_url = "http://bridges-clone.herokuapp.com";
                else if (server_type == "games")
                    server_url = "http://bridges-games.herokuapp.com";
                else if (server_type == "local")
                    server_url = "http://127.0.0.1:3000";
 
                BASE_URL = server_url + "/assignments/";
            }
 
            void setMapOverlay (bool overlay_flag) {
                map_overlay = overlay_flag;
            }
 
            void setMap(string my_map, string info) {
                map[0] = my_map;
                map[1] = info;
            }
 
            void setCoordSystemType (string coord) {
                std::transform(coord.begin(), coord.end(), coord.begin(), ::tolower);
                if (coord == "cartesian" || coord == "albersusa" || coord == "equirectangular"
                    || coord == "window")
                    coord_system_type = coord;
                else  {
                    cout << "Unrecognized coordinate system \'" + coord + "\', defaulting to "
                        << "cartesian. Options:";
                    for (auto proj : map_overlay_options)
                        cout <<  + "\t" ;
                    coord_system_type = "cartesian";
                }
            }
            const string&  getCoordSystemType () {
                return coord_system_type;
            }
 
            void setWindow (int xmin, int xmax, int ymin, int ymax) {
                setWindow(double(xmin), double(xmax), double(ymin), double(ymax));
            }
 
            void setWindow (double xmin, double xmax, double ymin, double ymax) {
                wc_window.clear();
                wc_window.push_back(xmin);
                wc_window.push_back(xmax);
                wc_window.push_back(ymin);
                wc_window.push_back(ymax);
            }
 
            string getVisualizeURL() const {
                return BASE_URL + to_string(getAssignment()) + "/" + getUserName();
            }
 
            void visualize() {
                std::chrono::time_point<std::chrono::system_clock> start;
                std::chrono::time_point<std::chrono::system_clock> end;
                std::chrono::time_point<std::chrono::system_clock> jsonbuild_start;
                std::chrono::time_point<std::chrono::system_clock> jsonbuild_end;
                std::chrono::time_point<std::chrono::system_clock> httprequest_start;
                std::chrono::time_point<std::chrono::system_clock> httprequest_end;
 
                if (profile())
                    start = std::chrono::system_clock::now();
 
                if (getAssignment() != lastAssignNum) {         // reset if a new assignment
                    lastAssignNum = getAssignment();
                    subAssignNum = 0;
                }
                if (subAssignNum == 99) {
                    cout << "#sub-assignments limit(99) exceeded, visualization not generated .."
                        << endl;
                    return;
                }
                if (!ds_handle) {
                    cerr << "Error: Data Structure handle null! Visualization not generated.";
                    return;
                }
 
                //
                // get the JSON of the data structure
                // each data structure is responsible for generating its JSON
                //
                if (profile())
                    jsonbuild_start = std::chrono::system_clock::now();
 
                // THIS IS BAD - NEEDS FIXING!!!
                string ds_json;
                if (ds_handle->getDStype() == "Scene") {
                    string ds_part_json = ds_handle->getDataStructureRepresentation();
                    // erase open curly brace
                    ds_part_json.erase(0, 1);
                    ds_json = getJSONHeader() + ds_part_json;
                }
                else
                    ds_json = getJSONHeader() + ds_handle->getDataStructureRepresentation();
                if (profile())
                    jsonbuild_end = std::chrono::system_clock::now();
 
                //
                // print JSON if flag is on
                //
                if (getJSONFlag()) {
                    cout << "JSON[" + ds_handle->getDStype() + "]:\t" << ds_json << endl;
                }
 
                if (profile())
                    httprequest_start = std::chrono::system_clock::now();
 
                try {                       // send the JSON of assignment to the server
                    ServerComm::makeRequest(BASE_URL + to_string(getAssignment()) + "." +
                        (subAssignNum > 9 ? "" : "0") + to_string(subAssignNum) + "?apikey=" + getApiKey() +
                        "&username=" + getUserName(), {"Content-Type: text/plain"}, ds_json);
 
                    if (post_visualization_link) {
                        cout << "Success: Assignment posted to the server. " << endl
                            << "Check out your visualization at:" << endl << endl
                            << getVisualizeURL() << endl << endl;
                    }
                    subAssignNum++;
                }
                catch (const string& error_str) {
                    cerr << "\nPosting assignment to the server failed!" << endl
                        << error_str << endl << endl;
                    cerr << "Provided Bridges Credentials:" << endl <<
                        "\t User Name: " << getUserName() << endl <<
                        "\t API Key: " << getApiKey() << endl <<
                        "\t Assignment Number: " << getAssignment() << endl;
                }
                catch (const HTTPException& he) {
                    cerr << "\nPosting assignment to the server failed!" << endl;
                    if (he.httpcode == 401) {
                        cerr << "Provided Bridges Credentials are incorrect:" << endl <<
                            "\t ServerURL: " << getServerURL() << endl <<
                            "\t User Name: " << getUserName() << endl <<
                            "\t API Key: " << getApiKey() << endl <<
                            "\t Assignment Number: " << getAssignment() << endl;
                    }
                    else if (he.httpcode == 413) {
                        cerr << "Assignment is too large." << endl;
                        cerr << "In general the assignment should be smaller than 16MB once serialized to JSON." << endl;
                    }
                    else {
                        std::cerr << he.what() << endl;
                    }
                }
                if (profile())
                    httprequest_end = std::chrono::system_clock::now();
 
                if (profile()) {
                    end = std::chrono::system_clock::now();
 
                    std::chrono::duration<double> totaltime = end - start;
                    std::chrono::duration<double> jsonbuildtime = jsonbuild_end - jsonbuild_start;
                    std::chrono::duration<double> httptime = httprequest_end - httprequest_start;
                    std::cerr << "total visualize() time:" << totaltime.count() << " seconds"
                        << " (including JSON build time: " << jsonbuildtime.count() << " seconds"
                        << " and HTTP request time: " << httptime.count() << " seconds)."
                        << std::endl;
                }
            }
 
        private:
            string getServerURL() const {
                return server_url;
            }
 
            string getJSONHeader () {
                using bridges::JSONUtil::JSONencode;
 
                string json_header = OPEN_CURLY +
                    QUOTE + "visual" + QUOTE + COLON + JSONencode(ds_handle->getDStype()) + COMMA +
                    QUOTE + "title" + QUOTE + COLON + JSONencode(getTitle()) + COMMA +
                    QUOTE + "description" + QUOTE + COLON + JSONencode( getDescription()) + COMMA +
                    QUOTE + "map_overlay" + QUOTE + COLON + ((map_overlay) ? "true" : "false") + COMMA +
                    QUOTE + "map" + QUOTE + COLON + OPEN_BOX + QUOTE + map[0] + QUOTE +
                    COMMA + QUOTE + map[1] + QUOTE + CLOSE_BOX + COMMA +
                    QUOTE + "element_label_flag" + QUOTE + COLON + ((element_labelFlag) ? "true" : "false") + COMMA +
                    QUOTE + "link_label_flag" + QUOTE + COLON + ((link_labelFlag) ? "true" : "false") + COMMA +
                    QUOTE + "coord_system_type" + QUOTE + COLON + JSONencode(getCoordSystemType()) +
                    COMMA;
 
                if (wc_window.size() == 4) {        // world coord window has been specified
                    json_header += QUOTE + string("window") + QUOTE + COLON + OPEN_BOX;
                    json_header += std::to_string(wc_window[0]) + COMMA +
                        std::to_string(wc_window[1]) + COMMA +
                        std::to_string(wc_window[2]) + COMMA + std::to_string(wc_window[3]);
                    json_header += CLOSE_BOX + COMMA;
 
                }
 
                return json_header;
            }
 
            friend DataSource;
            friend bridges::game::SocketConnection;
    };  //end of class Bridges
 
}   // end of bridges namespace
#endif