Refactoring some code to be more readable

8 files changed, 210 insertions, 205 deletions

diff --git a/api/umosapi.cpp b/api/umosapi.cpp
index 737df24..6b25124 100644
--- a/api/umosapi.cpp
+++ b/api/umosapi.cpp
@@ -23,69 +23,58 @@
 #include <fstream>
 #include <streambuf>
 
-mongo_access mongo;
-
-
-using bsoncxx::builder::stream::close_array;
-using bsoncxx::builder::stream::close_document;
-using bsoncxx::builder::stream::document;
-using bsoncxx::builder::stream::finalize;
-using bsoncxx::builder::stream::open_array;
-using bsoncxx::builder::stream::open_document;
+UmosapiService::mongo_access mongo;
 
 using json = nlohmann::json;
 
-using namespace std;
-using namespace restbed;
-
-UmosapiService::UmosapiService() {}
+UmosapiService::Api::Api() {}
 
-void UmosapiService::init() {
+void UmosapiService::Api::init() {
 
     auto uri = mongocxx::uri{config["mongoURI"]};
     mongo.configure(std::move(uri));
-    createResource();
+    UmosapiService::Api::createResource();
     ofstream swagger_json;
     swagger_json.open(config["swaggerui"] + "/swagger.json");
-    swagger_json << _swagger.dump();
+    swagger_json << UmosapiService::Api::_swagger.dump();
     swagger_json.close();
 }
 
-void UmosapiService::start(int port, int thr) {
-    auto settings = make_shared< Settings >();
+void UmosapiService::Api::start(int port, int thr) {
+    auto settings = make_shared< restbed::Settings >();
     settings->set_port( port );
     settings->set_worker_limit( thr );
     settings->set_default_header("Connection", "close");
-    _service.start(settings);
+    UmosapiService::Api::_service.start(settings);
 }
 
-void service_error_handler( const int, const exception& e, const shared_ptr< Session > session )
+void service_error_handler( const int, const exception& e, const shared_ptr< restbed::Session > session )
 {
     std::string message = "Backend Service is dead: ";
     message += e.what();
     if ( session ) {
         if ( session->is_open( ) ) {
-            session->close( 500, message, { { "Content-Length", ::to_string(message.length()) } } );
+            session->close( 500, message, { { "Content-Length", std::to_string(message.length()) } } );
         }
     }
     fprintf( stderr, "ERROR: %s.\n", message.c_str() );
 }
 
-void resource_error_handler( const int, const exception& e, const shared_ptr< Session > session )
+void resource_error_handler( const int, const exception& e, const shared_ptr< restbed::Session > session )
 {
     std::string message = "Backend Resource is dead: ";
     message += e.what();
     if ( session->is_open( ) )
-        session->close( 500, message, { { "Content-Length", ::to_string(message.length()) } } );
+        session->close( 500, message, { { "Content-Length", std::to_string(message.length()) } } );
     fprintf( stderr, "ERROR: %s.\n", message.c_str() );
 }
 
-void faulty_method_handler( const shared_ptr< Session > )
+void faulty_method_handler( const shared_ptr< restbed::Session > )
 {
     throw SERVICE_UNAVAILABLE;
 }
 
-void is_ready(const shared_ptr<Session> session)
+void is_ready(const shared_ptr< restbed::Session > session)
 {
     session->close( OK, "1", { { "Content-Length", "1"}});
 }
@@ -99,111 +88,111 @@ void is_ready(const shared_ptr<Session> session)
  * error_callback: error to show if everything is broken
  * tags: array of tags
  */
-void UmosapiService::desc(std::string route, std::string http_word, const std::function< void ( const std::shared_ptr< Session > ) >& callback, const std::function< void(int, const std::exception&, std::shared_ptr<restbed::Session>) >& error_callback, tag tags[]) {
-    auto resource = make_shared< Resource > ();
+void UmosapiService::Api::desc(std::string route, std::string http_word, const std::function< void ( const std::shared_ptr< restbed::Session > ) >& callback, const std::function< void(int, const std::exception&, std::shared_ptr< restbed::Session >) >& error_callback, tag tags[]) {
+    auto resource = make_shared< restbed::Resource > ();
     resource->set_path(route);
     resource->set_method_handler(http_word, callback);
     resource->set_error_handler( error_callback );
 
-    _service.publish(resource);
+    UmosapiService::Api::_service.publish(resource);
 }
 
-void UmosapiService::description(std::string description) {
-    _swagger["info"]["description"] = description;
+void UmosapiService::Api::description(std::string description) {
+    UmosapiService::Api::_swagger["info"]["description"] = description;
 }
 
-void UmosapiService::title(std::string title) {
-    _swagger["info"]["title"] = title;
+void UmosapiService::Api::title(std::string title) {
+    UmosapiService::Api::_swagger["info"]["title"] = title;
 }
 
-void UmosapiService::version(std::string version) {
-    _swagger["info"]["version"] = version;
+void UmosapiService::Api::version(std::string version) {
+    UmosapiService::Api::_swagger["info"]["version"] = version;
 }
 
-void UmosapiService::basePath(std::string basePath) {
-    _swagger["swagger"] = "2.0";
-    _swagger["basePath"] = basePath;
+void UmosapiService::Api::basePath(std::string basePath) {
+    UmosapiService::Api::_swagger["swagger"] = "2.0";
+    UmosapiService::Api::_swagger["basePath"] = basePath;
 }
 
-void UmosapiService::host(std::string host) {
-    _swagger["host"] = host;
+void UmosapiService::Api::host(std::string host) {
+    UmosapiService::Api::_swagger["host"] = host;
 }
 
-void UmosapiService::atag(std::string name, std::string description) {
+void UmosapiService::Api::atag(std::string name, std::string description) {
     struct tag the_tag;
     the_tag.name = name;
     the_tag.description = description;
 
-    _tags.push_back(the_tag);
-    _swagger["tags"].push_back({ {"name",the_tag.name},{"description", the_tag.description} });
+    UmosapiService::Api::_tags.push_back(the_tag);
+    UmosapiService::Api::_swagger["tags"].push_back({ {"name",the_tag.name},{"description", the_tag.description} });
 
 }
 
-void UmosapiService::scheme(std::string scheme) {
-    _swagger["schemes"].push_back(scheme);
+void UmosapiService::Api::scheme(std::string scheme) {
+    UmosapiService::Api::_swagger["schemes"].push_back(scheme);
 }
 
-void UmosapiService::set_path(std::string route) {
-    _resource = make_shared< Resource > ();
-    _resource->set_path(route);
+void UmosapiService::Api::set_path(std::string route) {
+    UmosapiService::Api::_resource = make_shared< restbed::Resource > ();
+    UmosapiService::Api::_resource->set_path(route);
     std::regex parameter(":.*?}");
     std::regex base_path("^/v2");
     auto tmp_route = std::regex_replace (route,parameter,"}");
     auto final_route = std::regex_replace (tmp_route,base_path,"");
-    _path = Path{final_route};
-    _swagger["paths"][final_route] = {};
+    UmosapiService::Api::_path = Path{final_route};
+    UmosapiService::Api::_swagger["paths"][final_route] = {};
 }
 
-void UmosapiService::set_method_handler(std::string http_word, const std::function< void ( const std::shared_ptr< Session > ) >& callback) {
-    _resource->set_method_handler(http_word, callback);
+void UmosapiService::Api::set_method_handler(std::string http_word, const std::function< void ( const std::shared_ptr< restbed::Session > ) >& callback) {
+    UmosapiService::Api::_resource->set_method_handler(http_word, callback);
     std::locale loc;
     for (auto& c : http_word) {
         c = tolower(c);
     }
-    _path.words.push_back(HttpWord{http_word});
-    _swagger["paths"][_path.name][http_word]["description"] = "";
-    _swagger["paths"][_path.name][http_word]["operationId"] = "";
-    _swagger["paths"][_path.name][http_word]["summary"] = "";
+    UmosapiService::Api::_path.words.push_back(HttpWord{http_word});
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][http_word]["description"] = "";
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][http_word]["operationId"] = "";
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][http_word]["summary"] = "";
 }
 
-void UmosapiService::set_error_handler(const std::function< void(int, const std::exception&, std::shared_ptr<restbed::Session>) >& error_callback) {
-    _resource->set_error_handler( error_callback );
+void UmosapiService::Api::set_error_handler(const std::function< void(int, const std::exception&, std::shared_ptr< restbed::Session >) >& error_callback) {
+    UmosapiService::Api::_resource->set_error_handler( error_callback );
 }
 
-void UmosapiService::publish() {
-    for (auto& http_word: _path.words) {
-        auto responses = _swagger["paths"][_path.name][http_word.name]["responses"];
+void UmosapiService::Api::publish() {
+    for (auto& http_word: UmosapiService::Api::_path.words) {
+        auto responses = UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][http_word.name]["responses"];
         if (responses.find("200") == responses.end()) {
-            _swagger["paths"][_path.name][http_word.name]["responses"]["200"]["description"] = "All is fine.";
+            UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][http_word.name]["responses"]["200"]["description"] = "All is fine.";
         }
     }
-    _service.publish(_resource);
+    UmosapiService::Api::_service.publish(_resource);
 }
 
-void UmosapiService::definition(std::string name, std::string type) {
-    _definition = Definition{name, type};
-    _definitions.defs.push_back(_definition);
-    _swagger["definitions"][name]["type"] = type;
+void UmosapiService::Api::definition(std::string name, std::string type) {
+    UmosapiService::Api::_definition = Definition{name, type};
+    UmosapiService::Api::_definitions.defs.push_back(_definition);
+    UmosapiService::Api::_swagger["definitions"][name]["type"] = type;
 }
 
-void UmosapiService::propertie(std::string name, std::string format, std::string type, std::string required) {
-    _definition.props.push_back(Propertie{name, format, type, required});
-    _swagger["definitions"][_definition.name]["properties"][name]["format"] = format;
-    _swagger["definitions"][_definition.name]["properties"][name]["type"] = type;
+void UmosapiService::Api::propertie(std::string name, std::string format, std::string type, std::string required) {
+    UmosapiService::Api::_definition.props.push_back(Propertie{name, format, type, required});
+    UmosapiService::Api::_swagger["definitions"][UmosapiService::Api::_definition.name]["properties"][name]["format"] = format;
+    UmosapiService::Api::_swagger["definitions"][UmosapiService::Api::_definition.name]["properties"][name]["type"] = type;
     if (required == "true") {
-        _swagger["definitions"][_definition.name]["required"].push_back(name);
+        UmosapiService::Api::_swagger["definitions"][UmosapiService::Api::_definition.name]["required"].push_back(name);
     }
 }
 
-void UmosapiService::consume(std::string consume) {
-    _swagger["paths"][_path.name][_path.words.back().name]["consumes"].push_back(consume);
+void UmosapiService::Api::consume(std::string consume) {
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["consumes"].push_back(consume);
 }
 
-void UmosapiService::produce(std::string produce) {
-    _swagger["paths"][_path.name][_path.words.back().name]["produces"].push_back(produce);
+void UmosapiService::Api::produce(std::string produce) {
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["produces"].push_back(produce);
 }
 
-void UmosapiService::parameter(std::string name, std::string description, std::string schema = "") {
+void UmosapiService::Api::parameter(std::string name, std::string description, std::string schema = "") {
     json parameter;
     parameter["name"] = name;
     parameter["description"] = description;
@@ -213,123 +202,125 @@ void UmosapiService::parameter(std::string name, std::string description, std::s
         parameter["in"] = "path";
     } else {
         parameter["in"] = "body";
-        for (auto& def: _definitions.defs) {
+        for (auto& def: UmosapiService::Api::_definitions.defs) {
             if (def.name == schema ) {
                 std::string schema_path = "#/definitions/";
                 parameter["schema"]["$ref"] = schema_path.append(schema);
             }
         }
     }
-    _swagger["paths"][_path.name][_path.words.back().name]["parameters"].push_back(parameter);
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["parameters"].push_back(parameter);
 }
 
-void UmosapiService::response(std::string http_code, std::string description, std::string definition) {
+void UmosapiService::Api::response(std::string http_code, std::string description, std::string definition) {
     std::string schema = "#/definitions/";
-    _swagger["paths"][_path.name][_path.words.back().name]["responses"][http_code]["description"] = description;
-    _swagger["paths"][_path.name][_path.words.back().name]["responses"][http_code]["schema"]["items"]["$ref"] = schema.append(definition);
-    _swagger["paths"][_path.name][_path.words.back().name]["responses"][http_code]["schema"]["type"] = "array";
-}
-
-void UmosapiService::swagger(std::string ui_path, std::string swagger_dir, std::string api_path) {
-    _resource = make_shared< Resource > ();
-    _resource->set_path(ui_path);
-    _resource->set_method_handler("GET", swaggerEndpoint);
-    _service.publish(_resource);
-
-    _resource = make_shared< Resource > ();
-    _resource->set_path(ui_path + "/{filename: .*}");
-    _resource->set_method_handler("GET", swaggerEndpointResources);
-    _service.publish(_resource);
-
-    _resource = make_shared< Resource > ();
-    _resource->set_path(api_path);
-    _resource->set_method_handler("GET", swaggerEndpointApi);
-    _service.publish(_resource);
-}
-
-
-void UmosapiService::createResource() {
-    basePath("/v2");
-    description("Umosapi rest api");
-    version("0.1");
-    title("UMOSAPI");
-    host("127.0.0.1:"+config["port"]);
-
-    swagger("/doc", config["swaggerui"], "/api");
-
-    atag("uobject", "Everything about your UObjec");
-
-    scheme("http");
-    scheme("https");
-
-    definition("UObject", "object");
-    propertie("id", "int64", "integer", "true");
-    propertie("value", "string", "object", "true");
-
-    definition("UObjectSended", "object");
-
-    set_path("/v2/ready");
-    set_method_handler("GET", is_ready);
-    produce("application/json");
-    publish();
-
-    set_path("/v2/{mcollection: .*}");
-    set_method_handler("GET", retrieveAll);
-    produce("application/json");
-    parameter("mcollection", "Name of the collection where the uobject are located");
-    set_error_handler(&resource_error_handler);
-    set_method_handler("POST", addUObject);
-    consume("application/json");
-    parameter("mcollection", "Name of the collection where the uobject are located");
-    parameter("body", "UObject to add", "UObjectSended");
-    set_error_handler(&resource_error_handler);
-    publish();
-
-    set_path("/v2/{mcollection: .*}/{oid: .*}");
-    set_method_handler("DELETE", deleteUObject);
-    produce("application/json");
-    parameter("mcollection", "Name of the collection where the uobject are located" );
-    parameter("oid", "MongoDB oid of the uobject");
-    set_error_handler(&resource_error_handler);
-    publish();
-
-    set_path("/v2/{mcollection: .*}/{key: .*}/{value: .*}");
-    set_method_handler("GET", searchUObjectByKeyValue);
-    produce("application/json");
-    parameter("mcollection", "Name of the collection where the uobject are located");
-    parameter("key", "Key of uobject to search, ex: kill or total.kill");
-    parameter("value", "Value of uobject to search, ex: 42");
-    set_error_handler(&resource_error_handler);
-    publish();
-
-    _service.set_error_handler( service_error_handler );
-}
-
-void UmosapiService::retrieveAll( const shared_ptr<Session> session ){
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["responses"][http_code]["description"] = description;
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["responses"][http_code]["schema"]["items"]["$ref"] = schema.append(definition);
+    UmosapiService::Api::_swagger["paths"][UmosapiService::Api::_path.name][UmosapiService::Api::_path.words.back().name]["responses"][http_code]["schema"]["type"] = "array";
+}
+
+void UmosapiService::Api::swagger(std::string ui_path, std::string swagger_dir, std::string api_path) {
+    UmosapiService::Api::_resource = make_shared< restbed::Resource > ();
+    UmosapiService::Api::_resource->set_path(ui_path);
+    UmosapiService::Api::_resource->set_method_handler("GET", swaggerEndpoint);
+    UmosapiService::Api::_service.publish(_resource);
+
+    UmosapiService::Api::_resource = make_shared< restbed::Resource > ();
+    UmosapiService::Api::_resource->set_path(ui_path + "/{filename: .*}");
+    UmosapiService::Api::_resource->set_method_handler("GET", swaggerEndpointResources);
+    UmosapiService::Api::_service.publish(_resource);
+
+    UmosapiService::Api::_resource = make_shared< restbed::Resource > ();
+    UmosapiService::Api::_resource->set_path(api_path);
+    UmosapiService::Api::_resource->set_method_handler("GET", swaggerEndpointApi);
+    UmosapiService::Api::_service.publish(_resource);
+}
+
+
+void UmosapiService::Api::createResource() {
+    UmosapiService::Api::basePath("/v2");
+    UmosapiService::Api::description("Umosapi rest api");
+    UmosapiService::Api::version("0.1");
+    UmosapiService::Api::title("UMOSAPI");
+    UmosapiService::Api::host("127.0.0.1:"+config["port"]);
+
+    UmosapiService::Api::swagger("/doc", config["swaggerui"], "/api");
+
+    UmosapiService::Api::atag("uobject", "Everything about your UObjec");
+
+    UmosapiService::Api::scheme("http");
+    UmosapiService::Api::scheme("https");
+
+    UmosapiService::Api::definition("UObject", "object");
+    UmosapiService::Api::propertie("id", "int64", "integer", "true");
+    UmosapiService::Api::propertie("value", "string", "object", "true");
+
+    UmosapiService::Api::definition("UObjectSended", "object");
+
+    UmosapiService::Api::set_path("/v2/ready");
+    UmosapiService::Api::set_method_handler("GET", is_ready);
+    UmosapiService::Api::produce("application/json");
+    UmosapiService::Api::publish();
+
+    UmosapiService::Api::set_path("/v2/{mcollection: .*}");
+    UmosapiService::Api::set_method_handler("GET", retrieveAll);
+    UmosapiService::Api::produce("application/json");
+    UmosapiService::Api::parameter("mcollection", "Name of the collection where the uobject are located");
+    UmosapiService::Api::set_error_handler(&resource_error_handler);
+    UmosapiService::Api::set_method_handler("POST", addUObject);
+    UmosapiService::Api::consume("application/json");
+    UmosapiService::Api::parameter("mcollection", "Name of the collection where the uobject are located");
+    UmosapiService::Api::parameter("body", "UObject to add", "UObjectSended");
+    UmosapiService::Api::set_error_handler(&resource_error_handler);
+    UmosapiService::Api::publish();
+
+    UmosapiService::Api::set_path("/v2/{mcollection: .*}/{oid: .*}");
+    UmosapiService::Api::set_method_handler("DELETE", deleteUObject);
+    UmosapiService::Api::produce("application/json");
+    UmosapiService::Api::parameter("mcollection", "Name of the collection where the uobject are located" );
+    UmosapiService::Api::parameter("oid", "MongoDB oid of the uobject");
+    UmosapiService::Api::set_error_handler(&resource_error_handler);
+    UmosapiService::Api::publish();
+
+    UmosapiService::Api::set_path("/v2/{mcollection: .*}/{key: .*}/{value: .*}");
+    UmosapiService::Api::set_method_handler("GET", searchUObjectByKeyValue);
+    UmosapiService::Api::produce("application/json");
+    UmosapiService::Api::parameter("mcollection", "Name of the collection where the uobject are located");
+    UmosapiService::Api::parameter("key", "Key of uobject to search, ex: kill or total.kill");
+    UmosapiService::Api::parameter("value", "Value of uobject to search, ex: 42");
+    UmosapiService::Api::set_error_handler(&resource_error_handler);
+    UmosapiService::Api::publish();
+
+    UmosapiService::Api::_service.set_error_handler( service_error_handler );
+}
+
+void UmosapiService::Api::retrieveAll( const shared_ptr< restbed::Session> session ){
+    UmosapiService::uobject uobject;
     auto jsonObjects = json_object_new_array();
     const auto& request = session->get_request( );
-    auto json_string = uobject::retrieveAll(request->get_path_parameter( "mcollection" ), jsonObjects);
+    auto json_string = uobject.retrieveAll(request->get_path_parameter( "mcollection" ), jsonObjects);
 
     session->close( OK, json_string, {
-        { "Content-Length", ::to_string(json_string.length()) },
+        { "Content-Length", std::to_string(json_string.length()) },
         { "Content-Type", "application/json" } 
     });
     json_object_put(jsonObjects);
 
 }
 
-void UmosapiService::addUObject( const shared_ptr<Session> session ){
+void UmosapiService::Api::addUObject( const shared_ptr< restbed::Session > session ){
     const auto request = session->get_request();
 
     size_t content_length = request->get_header( "Content-Length", 0 );
 
-    session->fetch( content_length, [ request ]( const shared_ptr< Session > session, const Bytes & body )
+    session->fetch( content_length, [ request ]( const shared_ptr< restbed::Session > session, const Bytes & body )
     {
+        UmosapiService::uobject uobject;
         auto jsonObject = json_object_new_object();
         char bodyData[body.size()+1];
         memset(bodyData, 0, sizeof(bodyData));
         snprintf(bodyData, sizeof(bodyData), "%.*s", ( int ) body.size( ), body.data());
-        auto json_string = uobject::add(request->get_path_parameter("mcollection"), jsonObject, bodyData);
+        auto json_string = uobject.add(request->get_path_parameter("mcollection"), jsonObject, bodyData);
         session->close( OK, json_string, {
             { "Content-Length", ::to_string(json_string.length()) },
             { "Content-Type", "application/json" } 
@@ -338,44 +329,46 @@ void UmosapiService::addUObject( const shared_ptr<Session> session ){
     } );
 }
 
-void UmosapiService::deleteUObject( const shared_ptr<Session> session ){
+void UmosapiService::Api::deleteUObject( const shared_ptr< restbed::Session > session ){
 
+    UmosapiService::uobject uobject;
     auto jsonObject = json_object_new_object();
     const auto request = session->get_request();
 
-    auto json_string = uobject::remove(request->get_path_parameter("mcollection"), request->get_path_parameter("oid"), jsonObject);
+    auto json_string = uobject.remove(request->get_path_parameter("mcollection"), request->get_path_parameter("oid"), jsonObject);
 
     session->close( OK, json_string, {
-        { "Content-Length", ::to_string(json_string.length()) },
+        { "Content-Length", std::to_string(json_string.length()) },
         { "Content-Type", "application/json" }
     });
     json_object_put(jsonObject);
 }
 
-void UmosapiService::searchUObjectByKeyValue( const shared_ptr<Session> session ){
+void UmosapiService::Api::searchUObjectByKeyValue( const shared_ptr< restbed::Session > session ){
+    UmosapiService::uobject uobject;
     auto jsonObject = json_object_new_array();
     const auto request = session->get_request();
 
-    auto json_string = uobject::searchKeyValue(request->get_path_parameter("mcollection"), request->get_path_parameter("key"), request->get_path_parameter("value"), jsonObject);
+    auto json_string = uobject.searchKeyValue(request->get_path_parameter("mcollection"), request->get_path_parameter("key"), request->get_path_parameter("value"), jsonObject);
 
     session->close( OK, json_string, {
-        { "Content-Length", ::to_string(json_string.length()) },
+        { "Content-Length", std::to_string(json_string.length()) },
         { "Content-Type", "application/json" }
     });
     json_object_put(jsonObject);
 }
 
-void UmosapiService::swaggerEndpoint( const shared_ptr<Session> session ){
+void UmosapiService::Api::swaggerEndpoint( const shared_ptr< restbed::Session > session ){
     const auto request = session->get_request();
 
     ifstream stream(config["swaggerui"] + "/index.html", ifstream::in );
 
     if ( stream.is_open() ) {
-        const string body = string( istreambuf_iterator< char >(stream), istreambuf_iterator< char>());
+        const std::string body = std::string( istreambuf_iterator< char >(stream), istreambuf_iterator< char>());
 
-        const multimap< string, string> headers {
+        const multimap< std::string, std::string> headers {
             { "Content-Type", "text/html" },
-            { "Content-Length", ::to_string( body.length() ) }
+            { "Content-Length", std::to_string( body.length() ) }
         };
         session->close(OK, body, headers);
     } else {
@@ -383,20 +376,20 @@ void UmosapiService::swaggerEndpoint( const shared_ptr<Session> session ){
     }
 }
 
-void UmosapiService::swaggerEndpointResources( const shared_ptr< Session > session )
+void UmosapiService::Api::swaggerEndpointResources( const shared_ptr< restbed::Session > session )
 {
     const auto request = session->get_request( );
-    const string filename = request->get_path_parameter( "filename" );
+    const std::string filename = request->get_path_parameter( "filename" );
 
     ifstream stream( config["swaggerui"] + "/" + filename, ifstream::in );
 
     if ( stream.is_open( ) )
     {
-        const string body = string( istreambuf_iterator< char >( stream ), istreambuf_iterator< char >( ) );
+        const std::string body = std::string( istreambuf_iterator< char >( stream ), istreambuf_iterator< char >( ) );
 
-        const multimap< string, string > headers
+        const multimap< std::string, std::string > headers
         {
-            { "Content-Length", ::to_string( body.length( ) ) }
+            { "Content-Length", std::to_string( body.length( ) ) }
         };
 
         session->close( OK, body, headers );
@@ -407,22 +400,22 @@ void UmosapiService::swaggerEndpointResources( const shared_ptr< Session > sessi
     }
 }
 
-void UmosapiService::swaggerEndpointApi( const shared_ptr< Session > session )
+void UmosapiService::Api::swaggerEndpointApi( const shared_ptr< restbed::Session > session )
 {
     const auto request = session->get_request( );
-    const string filename = request->get_path_parameter( "filename" );
-    const string path = request->get_path();
+    const std::string filename = request->get_path_parameter( "filename" );
+    const std::string path = request->get_path();
 
     ifstream stream( config["swaggerui"] + "/swagger.json", ifstream::in );
 
     if ( stream.is_open( ) )
     {
-        const string body = string( istreambuf_iterator< char >( stream ), istreambuf_iterator< char >( ) );
+        const std::string body = std::string( istreambuf_iterator< char >( stream ), istreambuf_iterator< char >( ) );
 
-        const multimap< string, string > headers
+        const multimap< std::string, std::string > headers
         {
             { "Content-Type", "application/json" },
-            { "Content-Length", ::to_string( body.length( ) ) }
+            { "Content-Length", std::to_string( body.length( ) ) }
         };
 
         session->close( OK, body, headers );
diff --git a/api/umosapi.h b/api/umosapi.h
index a1765d7..3cb2b47 100644
--- a/api/umosapi.h
+++ b/api/umosapi.h
@@ -16,6 +16,8 @@ using namespace std;
 
 using json = nlohmann::json;
 
+namespace UmosapiService {
+
 struct tag {
      std::string name;
      std::string description;
@@ -53,11 +55,11 @@ struct Paths {
     std::vector<Path> paths;
 };
 
-class UmosapiService {
+class Api {
     public:
 
-        UmosapiService();
-        virtual ~UmosapiService() {};
+        Api();
+        virtual ~Api() {};
 
         void init();
 
@@ -105,4 +107,5 @@ class UmosapiService {
         void swagger(std::string ui_path, std::string swagger_dir, std::string api_path);
 
 };
+}
 #endif
diff --git a/db/mongo_access.cpp b/db/mongo_access.cpp
index 56936f3..a19488e 100644
--- a/db/mongo_access.cpp
+++ b/db/mongo_access.cpp
@@ -1,9 +1,9 @@
 #include "mongo_access.h"
 
-mongo_access::mongo_access(void) {};
-mongo_access::~mongo_access(void) {};
+UmosapiService::mongo_access::mongo_access(void) {};
+UmosapiService::mongo_access::~mongo_access(void) {};
 
-void mongo_access::configure(mongocxx::uri uri) {
+void UmosapiService::mongo_access::configure(mongocxx::uri uri) {
     class noop_logger : public mongocxx::logger {
         public:
             virtual void operator()(mongocxx::log_level,
@@ -11,6 +11,6 @@ void mongo_access::configure(mongocxx::uri uri) {
                                     bsoncxx::stdx::string_view) noexcept {}
     };
 
-    _pool = bsoncxx::stdx::make_unique<mongocxx::pool>(std::move(uri));
-    _instance = bsoncxx::stdx::make_unique<mongocxx::instance>(bsoncxx::stdx::make_unique<noop_logger>());
+    UmosapiService::mongo_access::_pool = bsoncxx::stdx::make_unique<mongocxx::pool>(std::move(uri));
+    UmosapiService::mongo_access::_instance = bsoncxx::stdx::make_unique<mongocxx::instance>(bsoncxx::stdx::make_unique<noop_logger>());
 }
diff --git a/db/mongo_access.h b/db/mongo_access.h
index f03cece..a37bc1b 100644
--- a/db/mongo_access.h
+++ b/db/mongo_access.h
@@ -15,7 +15,7 @@
 
 #include <iostream>
 
-
+namespace UmosapiService {
 class mongo_access {
     public:
 
@@ -39,5 +39,6 @@ class mongo_access {
         std::unique_ptr<mongocxx::pool> _pool = nullptr;
 
 };
+}
 
 #endif
diff --git a/db/uobject.cpp b/db/uobject.cpp
index 25b13e6..38b472f 100644
--- a/db/uobject.cpp
+++ b/db/uobject.cpp
@@ -3,7 +3,9 @@
 using bsoncxx::builder::basic::kvp;
 using bsoncxx::builder::basic::make_document;
 
-std::string uobject::retrieveAll(std::string collection, struct json_object* jsonObjects) {
+UmosapiService::uobject::uobject() {}
+
+std::string UmosapiService::uobject::retrieveAll(std::string collection, struct json_object* jsonObjects) {
 
     auto conn = mongo.get_connection();
 
@@ -18,7 +20,7 @@ std::string uobject::retrieveAll(std::string collection, struct json_object* jso
     return json_object_to_json_string_ext(jsonObjects, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);
 }
 
-std::string uobject::add(std::string collection, struct json_object* jsonObject, const char * body) {
+std::string UmosapiService::uobject::add(std::string collection, struct json_object* jsonObject, const char * body) {
     auto conn = mongo.get_connection();
 
     auto coll = (*conn)[config["mongo_db"]][collection];
@@ -77,7 +79,7 @@ std::string uobject::add(std::string collection, struct json_object* jsonObject,
     return json_object_to_json_string_ext(jsonObject, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY);
 }
 
-std::string uobject::remove(std::string collection, std::string oid, struct json_object* jsonObject) {
+std::string UmosapiService::uobject::remove(std::string collection, std::string oid, struct json_object* jsonObject) {
     auto conn = mongo.get_connection();
 
     auto coll = (*conn)[config["mongo_db"]][collection];
@@ -109,7 +111,7 @@ std::string uobject::remove(std::string collection, std::string oid, struct json
     }
 }
 
-std::string uobject::searchKeyValue(std::string collection, std::string key, std::string value, struct json_object* jsonArray) {
+std::string UmosapiService::uobject::searchKeyValue(std::string collection, std::string key, std::string value, struct json_object* jsonArray) {
     auto conn = mongo.get_connection();
 
     auto coll = (*conn)[config["mongo_db"]][collection];
diff --git a/db/uobject.h b/db/uobject.h
index 0533661..2abf7dd 100644
--- a/db/uobject.h
+++ b/db/uobject.h
@@ -19,11 +19,19 @@
 #include "../shared.h"
 #include "../db/mongo_access.h"
 
-namespace uobject {
+namespace UmosapiService {
+
+class uobject {
+    public:
+
+    uobject();
+    virtual ~uobject() {};
+
     std::string retrieveAll(std::string collection, struct json_object* jsonObjects);
     std::string add(std::string collection, struct json_object* jsonObjects, const char * body);
     std::string remove(std::string collection, std::string oid, struct json_object* jsonObjects);
     std::string searchKeyValue(std::string collection, std::string key, std::string value, struct json_object* jsonArray);
-}
+};
 
+}
 #endif
diff --git a/main.cpp b/main.cpp
index 9cf4127..dd3b794 100644
--- a/main.cpp
+++ b/main.cpp
@@ -12,8 +12,6 @@
 
 std::map<std::string, std::string> config;
 
-using namespace std;
-
 int main(int argc, char *argv[]) {
 
     string config_path = "";
@@ -73,7 +71,7 @@ int main(int argc, char *argv[]) {
     umosapi.start(config["swaggerui"]);
     */
 
-    UmosapiService umosapi;
+    UmosapiService::Api umosapi;
     umosapi.init();
     umosapi.start(std::stoi(config["port"]), thr);
 
diff --git a/shared.h b/shared.h
index 7ba7006..5ee3d78 100644
--- a/shared.h
+++ b/shared.h
@@ -5,6 +5,6 @@
 #include "db/mongo_access.h"
 
 extern std::map<std::string, std::string> config;
-extern mongo_access mongo;
+extern UmosapiService::mongo_access mongo;
 
 #endif