Initial commit

CMakeLists_template.txt

+cmake_minimum_required(VERSION 3.5)
+project(server CXX)
+set(CMAKE_BUILD_TYPE Debug)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+# set the 4 following parameters
+set(AROLIOS_CORE_LIB_DIR /usr/local/arolios/lib)
+set(AROLIOS_CORE_INCLUDE_DIR /usr/local/arolios/include)
+set (XERCES_LIB_DIR /usr/lib/x86_64-linux-gnu)
+set (ANTLR_LIB_DIR /usr/local/antlr4-cpp-runtime-4.13.0/dist)
+
+include(CheckIncludeFileCXX)
+
+check_include_file_cxx(any HAS_ANY)
+check_include_file_cxx(string_view HAS_STRING_VIEW)
+check_include_file_cxx(coroutine HAS_COROUTINE)
+if (NOT "${CMAKE_CXX_STANDARD}" STREQUAL "")
+    # Do nothing
+elseif (HAS_ANY AND HAS_STRING_VIEW AND HAS_COROUTINE)
+    set(CMAKE_CXX_STANDARD 20)
+elseif (HAS_ANY AND HAS_STRING_VIEW)
+    set(CMAKE_CXX_STANDARD 17)
+else ()
+    set(CMAKE_CXX_STANDARD 14)
+endif ()
+
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_executable(${PROJECT_NAME} src/main.cpp)
+
+
+# ##############################################################################
+# If you include the drogon source code locally in your project, use this method
+# to add drogon 
+# add_subdirectory(drogon) 
+# target_link_libraries(${PROJECT_NAME} PRIVATE drogon)
+#
+# and comment out the following lines
+set(PostgreSQL_ADDITIONAL_VERSIONS "16.1" "16")
+find_package(PostgreSQL)
+find_package(Drogon CONFIG REQUIRED)
+
+
+#target_link_libraries(${PROJECT_NAME} PRIVATE Drogon::Drogon jsoncpp_object jsoncpp_static JsonCpp::JsonCpp
+target_link_libraries(${PROJECT_NAME} PRIVATE Drogon::Drogon 
+${AROLIOS_CORE_LIB_DIR}/libbase.so
+${AROLIOS_CORE_LIB_DIR}/libmodel.so
+${AROLIOS_CORE_LIB_DIR}/libmttr.so
+${AROLIOS_CORE_LIB_DIR}/libtqry.so
+#/home/philippe/WS2/lib/libbcrypt.so
+${XERCES_LIB_DIR}/libxerces-c-3.2.so
+${ANTLR_LIB_DIR}/libantlr4-runtime.so)
+# ##############################################################################
+
+if (CMAKE_CXX_STANDARD LESS 17)
+    # With C++14, use boost to support any, string_view and filesystem
+    message(STATUS "use c++14")
+    find_package(Boost 1.61.0 REQUIRED)
+    target_link_libraries(${PROJECT_NAME} PUBLIC Boost::boost)
+elseif (CMAKE_CXX_STANDARD LESS 20)
+    message(STATUS "use c++17")
+else ()
+    message(STATUS "use c++20")
+endif ()
+
+aux_source_directory(src/controllers CTL_SRC)
+aux_source_directory(src/filters FILTER_SRC)
+aux_source_directory(src/plugins PLUGIN_SRC)
+aux_source_directory(src/svrutils SVRU_SRC)
+
+
+
+target_include_directories(${PROJECT_NAME}
+                           PRIVATE 
+                                    src/controllers
+                                    src/filters
+                                    src/plugins
+                                    src/svrutils
+                                    ${AROLIOS_CORE_INCLUDE_DIR}
+                                   ${JSONCPP_INCLUDE_DIRS})
+
+                                         
+target_sources(${PROJECT_NAME}
+               PRIVATE
+               ${CTL_SRC}
+               ${FILTER_SRC}
+               ${PLUGIN_SRC}
+               ${SVRU_SRC})
+               
+
+

CODE_OF_CONDUCT.md

+../core/CODE_OF_CONDUCT.md
\ No newline at end of file

CONTRIBUTING.md

+../core/CONTRIBUTING.md
\ No newline at end of file

README.md

+
+See the [french version](./README_fr.md)

README_fr.md

+# Aperçu général
+
+**AROLIOS** est un projet de logiciels **open source** pour **gérer les données** utilisées dans un domaine métier ou tout autre activité .
+
+**AROLIOS** apporte une réponse à toutes celles et ceux qui recherchent une solution ayant une ou plusieurs des particularités suivantes :
+
+* la définition des types de données selon la vue du domaine métier ou de l'activité,
+* les fonctions de base de gestion de données,
+* l'import/export de données en masse,
+* le multilinguisme pour les types de données et les données texte,
+* une mise en oeuvre très rapide sans besoin de programmation,
+* l'intégration dans le système d'information facilitée par une interface de programmation,
+* l'accès sécurisé pour tous les utilisateurs via les technologies Web,
+* des modifications/extensions possibles sans dépendre d'un fournisseur unique
+
+Les fonctions de gestion de données sont **génériques**, c'est-à-dire indépendantes du type de données.
+
+Une fois vos types de données définis, **aucune programmation** n'est nécessaire, **aucun code supplémentaire n'est généré**, vous pouvez de suite **créer, rechercher, consulter, modifier, supprimer** des données.
+
+Le projet **AROLIOS** est composé actuellement de trois logiciels:
+* **AROLIOS Core** est le logiciel comprenant plusieurs bibliothèques de programmes implémentant les fonctionnalités ainsi qu'un programme  pour initialiser la base de données.
+* **AROLIOS Server** est le logiciel agissant comme serveur Web et implémentant une interface de programmation (l'API AROLIOS) en faisant appel à AROLIOS Core
+* **AROLIOS WebUI** est le logiciel interagissant avec l'utilisateur, s'exécutant dans son navigateur Web et communiquant avec un serveur implémentant l'API AROLIOS.  
+
+
+# Documentation
+
+Voir la documentation [ici](https://lab.frogg.it/philcoicadan/arolios-doc)
+
+# Assistance
+
+Si vous constatez une anomalie ou si vous avez une suggestion d'amélioration, ouvrez un ticket dans ce projet. Pour toute autre demande, vous pouvez envoyer une courriel à [cette adresse](mailto:philcoicadan@arolios.org).
+
+
+# Contribution
+
+Voir le fichier CONTRIBUTING.md
+
+# Licence
+
+AROLIOS Server est publié sous licence GNU AGPL (identifiant SPDX: AGPL-3.0-or-later).
+Voir le fichier COPYING
+

data/config_template.json

+/* This is a JSON format configuration file
+ */
+{
+    /*
+    //ssl:The global ssl files setting
+    "ssl": {
+        "cert": "../../trantor/trantor/tests/server.pem",
+        "key": "../../trantor/trantor/tests/server.pem"
+    }, */
+    "listeners": [
+        { 
+            "address": "0.0.0.0",
+            "port": 443,
+            "https": true,
+            //cert,key: Cert file path and key file path, empty by default,
+            //if empty, use the global setting
+            "cert": "",
+            "key": "",
+            //use_old_tls: enable the TLS1.0/1.1, false by default
+            "use_old_tls": false
+        }
+    ], 
+    "db_clients": [
+        {
+            //name: Name of the client,'default' by default
+            //"name":"default",
+            //rdbms: Server type, postgresql,mysql or sqlite3, "postgresql" by default
+            "rdbms": "postgresql",
+            //host: Server address,localhost by default
+            "host": "127.0.0.1",
+            //port: Server port, 5432 by default
+            "port": 5432,
+            //dbname: Database name
+            "dbname" : "",
+            //user: 'postgres' by default
+            "user" : "",
+            //passwd: '' by default
+            "passwd": "",
+            //is_fast: false by default, if it is true, the client is faster but user can't call
+            //any synchronous interface of it.
+            "is_fast": false,
+            //client_encoding: The character set used by the client. it is empty string by default which 
+            //means use the default character set.
+            //"client_encoding": "",
+            //connection_number: 1 by default, if the 'is_fast' is true, the number is the number of  
+            //connections per IO thread, otherwise it is the total number of all connections.  
+            "connection_number": 1
+        } 
+    ], 
+    "app": {
+        //threads_num: The number of IO threads, 1 by default, if the value is set to 0, the number of threads
+        //is the number of CPU cores
+        "threads_num": 10,
+        //enable_session: False by default
+        "enable_session": true,
+        //session_timeout: 0,
+        "session_timeout": 1200,
+        //session_same_site: "Null" by default
+        "session_same_site": "None",
+        //document_root: Root path of HTTP document, defaut path is ./
+        "document_root": "./",
+        //home_page: Set the HTML file of the home page, the default value is "index.html"
+        //If there isn't any handler registered to the path "/", the home page file in the "document_root" is send to clients as a response
+        //to the request for "/".
+        "home_page": "index.html",
+        //use_implicit_page: enable implicit pages if true, true by default
+        "use_implicit_page": true,
+        //implicit_page: Set the file which would the server access in a directory that a user accessed.
+        //For example, by default, http://localhost/a-directory resolves to http://localhost/a-directory/index.html.
+        "implicit_page": "index.html",
+        //static_file_headers: Headers for static files
+        /*"static_file_headers": [
+          {
+                "name": "field-name",
+                "value": "field-value"
+          }
+        ],*/
+        //upload_path: The path to save the uploaded file. "uploads" by default. 
+        //If the path isn't prefixed with /, ./ or ../,
+        //it is relative path of document_root path
+        "upload_path": "uploads",
+        /* file_types:
+         * HTTP download file types,The file types supported by drogon
+         * by default are "html", "js", "css", "xml", "xsl", "txt", "svg",
+         * "ttf", "otf", "woff2", "woff" , "eot", "png", "jpg", "jpeg",
+         * "gif", "bmp", "ico", "icns", etc. */
+        "file_types": [
+            "gif",
+            "png",
+            "jpg",
+            "js",
+            "css",
+            "html",
+            "ico",
+            "swf",
+            "xap",
+            "apk",
+            "cur",
+            "xml"
+        ],
+        //locations: An array of locations of static files for GET requests.
+        "locations": [
+            {
+                //uri_prefix: The URI prefix of the location prefixed with "/", the default value is "" that disables the location.
+                //"uri_prefix": "/.well-known/acme-challenge/",
+                //default_content_type: The default content type of the static files without
+                //an extension. empty string by default.
+                "default_content_type": "text/plain",
+                //alias: The location in file system, if it is prefixed with "/", it 
+                //presents an absolute path, otherwise it presents a relative path to 
+                //the document_root path. 
+                //The default value is "" which means use the document root path as the location base path.
+                "alias": "",
+                //is_case_sensitive: indicates whether the URI prefix is case sensitive.
+                "is_case_sensitive": false,
+                //allow_all: true by default. If it is set to false, only static files with a valid extension can be accessed.
+                "allow_all": true,
+                //is_recursive: true by default. If it is set to false, files in sub directories can't be accessed.
+                "is_recursive": true,
+                //filters: string array, the filters applied to the location.
+                "filters": []
+            }
+        ],
+        //max_connections: maximum connections number,100000 by default
+        "max_connections": 100000,
+        //max_connections_per_ip: maximum connections number per clinet,0 by default which means no limit
+        "max_connections_per_ip": 0,
+        //Load_dynamic_views: False by default, when set to true, drogon
+        //compiles and loads dynamically "CSP View Files" in directories defined
+        //by "dynamic_views_path"
+        "load_dynamic_views": false,
+        //dynamic_views_path: If the path isn't prefixed with /, ./ or ../,
+        //it is relative path of document_root path
+        "dynamic_views_path": [
+            "./views"
+        ],
+        //dynamic_views_output_path: Default by an empty string which means the output path of source 
+        //files is the path where the csp files locate. If the path isn't prefixed with /, it is relative 
+        //path of the current working directory.
+        "dynamic_views_output_path": "",
+        //enable_unicode_escaping_in_json: true by default, enable unicode escaping in json.
+        "enable_unicode_escaping_in_json": true,
+        //float_precision_in_json: set precision of float number in json. 
+        "float_precision_in_json": {
+            //precision: 0 by default, 0 means use the default precision of the jsoncpp lib. 
+            "precision": 0,
+            //precision_type: must be "significant" or "decimal", defaults to "significant" that means 
+            //setting max number of significant digits in string, "decimal" means setting max number of 
+            //digits after "." in string
+            "precision_type": "significant"
+        },
+        //log: Set log output, drogon output logs to stdout by default
+        "log": {
+            //log_path: Log file path,empty by default,in which case,logs are output to the stdout
+            //"log_path": "./",
+            //logfile_base_name: Log file base name,empty by default which means drogon names logfile as
+            //drogon.log ...
+            "logfile_base_name": "",
+            //log_size_limit: 100000000 bytes by default,
+            //When the log file size reaches "log_size_limit", the log file is switched.
+            "log_size_limit": 100000000,
+            //log_level: "DEBUG" by default,options:"TRACE","DEBUG","INFO","WARN"
+            //The TRACE level is only valid when built in DEBUG mode.
+            "log_level": "DEBUG"
+        },
+        //run_as_daemon: False by default
+        "run_as_daemon": false,
+        //relaunch_on_error: False by default, if true, the program will be restart by the parent after exiting;
+        "relaunch_on_error": false,
+        //use_sendfile: True by default, if true, the program 
+        //uses sendfile() system-call to send static files to clients;
+        "use_sendfile": true,
+        //use_gzip: True by default, use gzip to compress the response body's content;
+        "use_gzip": true,
+        //use_brotli: False by default, use brotli to compress the response body's content;
+        "use_brotli": false,
+        //static_files_cache_time: 5 (seconds) by default, the time in which the static file response is cached,
+        //0 means cache forever, the negative value means no cache
+        "static_files_cache_time": 5,
+        //simple_controllers_map: Used to configure mapping from path to simple controller
+        //"simple_controllers_map": [
+            /*{
+                "path": "/path/name",
+                "controller": "controllerClassName",
+                "http_methods": [
+                    "get",
+                    "post"
+                ],
+                "filters": [
+                    "FilterClassName"
+                ]
+            }*/
+        //],
+        //idle_connection_timeout: Defaults to 60 seconds, the lifetime 
+        //of the connection without read or write
+        "idle_connection_timeout": 60,
+        //server_header_field: Set the 'Server' header field in each response sent by drogon,
+        //empty string by default with which the 'Server' header field is set to "Server: drogon/versionstring\r\n"
+        "server_header_field": "",
+        //enable_server_header: Set true to force drogon to add a 'Server' header to each HTTP response. The default 
+        //value is true.
+        "enable_server_header": true,
+        //enable_date_header: Set true to force drogon to add a 'Date' header to each HTTP response. The default 
+        //value is true.
+        "enable_date_header": true,
+        //keepalive_requests: Set the maximum number of requests that can be served through one keep-alive connection. 
+        //After the maximum number of requests are made, the connection is closed.
+        //The default value of 0 means no limit.
+        "keepalive_requests": 0,
+        //pipelining_requests: Set the maximum number of unhandled requests that can be cached in pipelining buffer. 
+        //After the maximum number of requests are made, the connection is closed.
+        //The default value of 0 means no limit.
+        "pipelining_requests": 0,
+        //gzip_static: If it is set to true, when the client requests a static file, drogon first finds the compressed 
+        //file with the extension ".gz" in the same path and send the compressed file to the client.
+        //The default value of gzip_static is true.
+        "gzip_static": true,
+        //br_static: If it is set to true, when the client requests a static file, drogon first finds the compressed 
+        //file with the extension ".br" in the same path and send the compressed file to the client.
+        //The default value of br_static is true.
+        "br_static": true,
+        //client_max_body_size: Set the maximum body size of HTTP requests received by drogon. The default value is "1M".
+        //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+        "client_max_body_size": "1M",
+        //max_memory_body_size: Set the maximum body size in memory of HTTP requests received by drogon. The default value is "64K" bytes.
+        //If the body size of a HTTP request exceeds this limit, the body is stored to a temporary file for processing.
+        //Setting it to "" means no limit.
+        "client_max_memory_body_size": "64K",
+        //client_max_websocket_message_size: Set the maximum size of messages sent by WebSocket client. The default value is "128K".
+        //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+        "client_max_websocket_message_size": "128K",
+        //reuse_port: Defaults to false, users can run multiple processes listening on the same port at the same time.
+        "reuse_port": false
+    },
+    //plugins: Define all plugins running in the application
+    "plugins": [
+        /*{
+            //name: The class name of the plugin
+            //"name": "drogon::plugin::SecureSSLRedirector",
+            //dependencies: Plugins that the plugin depends on. It can be commented out
+            "dependencies": [],
+            //config: The configuration of the plugin. This json object is the parameter to initialize the plugin.
+            //It can be commented out
+            "config": {
+                "ssl_redirect_exempt": [
+                    ".*\\.jpg"
+                ],
+                "secure_ssl_host": "localhost:8849"
+            } 
+        } */
+        {
+            //name: The class name of the plugin
+            "name": "arolios::plugin::Object_model",
+            //dependencies: Plugins that the plugin depends on. It can be commented out
+            "dependencies": [],
+            //config: The configuration of the plugin. This json object is the parameter to initialize the plugin.
+            //It can be commented out
+            "config": {      
+            }
+        },
+        {
+            //name: The class name of the plugin
+            "name": "arolios::plugin::App_server",
+            //dependencies: Plugins that the plugin depends on. It can be commented out
+            "dependencies": ["arolios::plugin::Object_model"],
+            //config: The configuration of the plugin. This json object is the parameter to initialize the plugin.
+            //It can be commented out
+            "config": { 
+               //"ip_domain_origins": "http://localhost:3000 http://localhost:5173"
+                "ip_domain_origins" : ""
+            }
+        },
+        {
+            //name: The class name of the plugin
+            "name": "arolios::plugin::User_access_control",
+            //dependencies: Plugins that the plugin depends on. It can be commented out
+            "dependencies": ["arolios::plugin::App_server"],
+            //config: The configuration of the plugin. This json object is the parameter to initialize the plugin.
+            //It can be commented out
+            "config": { }
+        }
+    ],
+    //custom_config: custom configuration for users. This object can be get by the app().getCustomConfig() method. 
+    "custom_config": {}
+}

src/controllers/App_domains.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/App_domains.h>
+#include "Base_resource.tpp"
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr ;
+
+template void Base_resource::list<qry::App_domains_list>(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction,  std::string&& p_lang  ) const ;
+
+  template void Base_resource::create<mttr::App_domain_create>(const HttpRequestPtr &req,
+              std::function<void(const HttpResponsePtr &)> &&callback) const;
+ 
+   template void Base_resource::deletion<mttr::App_domain_delete>(const HttpRequestPtr &req,
+                std::function<void(const HttpResponsePtr &)> &&callback,
+                std::string &&p_item_id) const;
\ No newline at end of file

src/controllers/App_users.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/App_users.h>
+#include "Base_resource.tpp"
+
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr ;
+
+template void Base_resource::list<qry::App_users_list>(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction,  std::string&& p_lang  ) const ;
+
+  template void Base_resource::create<mttr::App_user_create>(const HttpRequestPtr &req,
+              std::function<void(const HttpResponsePtr &)> &&callback) const;
+ 
+   template void Base_resource::deletion<mttr::App_user_delete>(const HttpRequestPtr &req,
+                std::function<void(const HttpResponsePtr &)> &&callback,
+                std::string &&p_item_id) const;
\ No newline at end of file

src/controllers/Apps.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <drogon/HttpAppFramework.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <model/App_config_loader.h>
+#include <ctlr/Apps.h>
+#include "Base_resource.tpp"
+
+
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr ;
+
+template void Base_resource::list<qry::Apps_list>(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction,  std::string&& p_lang  ) const ;
+
+  template void Base_resource::create<mttr::App_create>(const HttpRequestPtr &req,
+              std::function<void(const HttpResponsePtr &)> &&callback) const;
+ 
+   template void Base_resource::update<mttr::App_update>(const HttpRequestPtr &req,
+                std::function<void(const HttpResponsePtr &)> &&callback,
+                std::string &&p_item_id) const;
+
+template void Base_resource::deletion<mttr::App_delete>(const HttpRequestPtr &req,
+                std::function<void(const HttpResponsePtr &)> &&callback,
+                std::string &&p_item_id) const;
+
+
+ 
+
+void Apps::load_config(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_app_id) const {
+     
+    
+
+    MultiPartParser fileUpload;
+
+    if ( fileUpload.parse ( req ) != 0 || fileUpload.getFiles().size() != 1 ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( "Must only be one file" );
+        resp->setStatusCode ( k403Forbidden );
+        callback ( resp );
+        return;
+    }
+
+    try {
+        auto &file = fileUpload.getFiles() [0];
+        auto md5 = file.getMd5();
+        auto len = file.fileLength();
+        auto ext = file.getFileExtension ();
+        auto name = file.getFileName();
+        auto type = file.getFileType ();
+
+        
+
+        file.save();
+        std::cout << "INFO: The uploaded file has been saved to the ./uploads "
+                 "directory";
+        
+ 
+        // the app name is the app identifier
+        const std::string app_name = util::String::standardize(p_app_id);
+
+        model::App_config_loader app_loader;
+        app_loader.execute ( app_name, drogon::app().getUploadPath() + '/' + name );
+
+
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setStatusCode(k200OK);
+        resp->setContentTypeCode(CT_TEXT_HTML);
+        resp->setBody ("App config loaded successfully");
+        //resp->setBody ("The server has calculated the file's MD5 hash to be " + md5 );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    } 
+    catch ( const std::exception&  e  ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what());
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+
+}

src/controllers/Associations.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Associations.h>
+#include "Classifiers.tpp"
+
+
+
+
+namespace arolios::ctlr {
+
+template class Classifiers<omm::Association> ;
+}
+
+
+
+
+

src/controllers/Auth.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Auth.h>
+#include <drogon/HttpAppFramework.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <plugin/User_access_control.h>
+#include <common/User.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <svru/About.h>
+#include <mttr/User_change_password.h>
+#include <appcfg/App.h>
+#include <ctime>
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+void Auth::login ( const HttpRequestPtr& req,std::function<void ( const HttpResponsePtr & ) > &&callback ) {
+
+    auto app_ptr = common::Singleton<common::App_info>::instance().object();
+    auto user_ac = common::Singleton<common::UAC_info>::instance().object();
+
+    auto input = req->getJsonObject();
+    if ( input ) {
+        auto identifier = ( *input ) ["username"].asString();
+        auto pwd = ( *input ) ["password"].asString();
+
+        
+
+
+        const auto user = user_ac->retrieve ( identifier , pwd) ;
+        if ( user ) {
+
+
+                const auto token = drogon::utils::getUuid();
+
+                req->session()->insert ( "token", token );
+                req->session()->insert ( "user", user );
+
+                const std::time_t now = std::time(nullptr);
+                
+                std::cout << "time: " << std::put_time(std::localtime(&now),"%x %X") << ", user: " << user->identifier() << " logged in" << std::endl;
+
+                Json::Value ret;
+                ret ["token"] = token;
+                
+                ret ["user"] = Json::Value(Json::objectValue);
+                ret ["user"]["identifier"] = user->identifier();
+                ret ["user"] ["role"] = user_ac->string_cast(user->app_role());
+                
+                ret ["app"] = Json::Value(Json::objectValue);
+                ret ["app"] ["name"] = app_ptr->app()->name();
+                ret ["app"] ["isDefault"] = (app_ptr->app()->id() == app_ptr->default_app_id()) ;
+                ret ["app"] ["defaultLanguage"] = app_ptr->default_language()->code();
+
+                ret ["about"] = svru::About::notice_text();
+                auto resp = HttpResponse::newHttpJsonResponse ( ret );
+                svru::Response::add_allow_headers (resp, req) ;
+
+                callback ( resp );
+                return;
+
+        } else {
+            auto resp = HttpResponse::newHttpResponse();
+            resp->setBody ( "Username and/or Password not valid" );
+            resp->setStatusCode ( k401Unauthorized );
+            svru::Response::add_allow_headers (resp, req) ;
+
+            callback ( resp );
+            return ;
+        }
+
+    } else {
+        auto resp = HttpResponse::newHttpResponse();
+
+        resp->setStatusCode ( k401Unauthorized );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return ;
+    }
+}
+
+void Auth::logout ( const HttpRequestPtr& req,std::function<void ( const HttpResponsePtr & ) > &&callback ) {
+
+    
+    auto user = req->session()->get<std::shared_ptr<common::User>>("user");
+    if (user != nullptr) {
+  
+        const std::time_t now = std::time(nullptr);
+                
+        std::cout << "time: " << std::put_time(std::localtime(&now), "%x %X") << ", user: " << user->identifier() << " logged out" << std::endl;
+    }
+
+    req->session()->clear();
+
+
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setStatusCode ( k200OK );
+    svru::Response::add_allow_headers (resp, req) ;
+
+    callback ( resp );
+    return ;
+
+
+
+}
+
+void Auth::change_password (const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback) {
+    
+    
+
+    try {
+
+        std::shared_ptr<common::User> user = req->session()->get<std::shared_ptr<common::User>> ( "user" );
+        auto resp = HttpResponse::newHttpResponse();
+
+        if ( user ) {
+            auto json_ptr = req->jsonObject() ;
+
+            mttr::User_change_password ucp ( user, *json_ptr );
+            ucp.execute ();
+
+            if ( ucp.return_code () == qry::Return_code::OK ) {
+                resp->setStatusCode ( k202Accepted );
+                resp->setContentTypeCode ( CT_TEXT_HTML );
+                resp->setBody ( "User password updated " );
+            } else {
+                resp->setStatusCode ( k422UnprocessableEntity );
+                resp->setContentTypeCode ( CT_TEXT_HTML );
+                resp->setBody ( "User password updating failed " );
+            }
+        } else {
+            resp->setStatusCode ( k404NotFound );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "User not found " );
+        }
+
+        svru::Response::add_allow_headers ( resp, req ) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers ( resp, req ) ;
+
+        callback ( resp );
+        return;
+    }
+}

src/controllers/Base_resource.tpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Base_resource.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <util/String.h>
+#include <qry/Util.h>
+#include <qry/Return_code.h>
+#include <drogon/HttpAppFramework.h>
+#include <common/Object_model_info.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+
+
+
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+
+template < typename TC> void Base_resource::create(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback) const {
+
+    try {
+
+
+
+        auto resp = HttpResponse::newHttpResponse();
+        auto json_ptr = req->jsonObject() ;
+
+        TC ac ( *json_ptr );
+        ac.execute ();
+
+        if ( ac.return_code () == qry::Return_code::OK ) {
+
+            resp = HttpResponse::newHttpJsonResponse ( ac.return_json() );
+        } else {
+            resp->setStatusCode ( k500InternalServerError );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Resource creation failed " );
+        }
+        
+        svru::Response::add_allow_headers (resp, req) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+}
+    
+
+template <typename TL> void Base_resource::list (const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction,  std::string&& p_lang  ) const {
+
+    try {
+
+       auto app_ptr = common::Singleton<common::App_info>::instance().object();
+       
+        auto lang = app_ptr->get_language_by_code(p_lang);
+
+        const auto list_params = svru::Request::check_list_params (p_sort, p_direction,p_limit,p_offset, true);
+       
+       
+        
+
+        auto resp = HttpResponse::newHttpResponse();
+
+        TL al ( list_params.offset_, list_params.limit_, list_params.sort_, list_params.direction_, lang) ;
+        al.execute ();
+
+        if ( al.return_code () == qry::Return_code::OK ) {
+            const Json::Value & json = al.return_json();
+
+            resp = HttpResponse::newHttpJsonResponse ( json );
+
+        } else {
+            resp->setStatusCode ( k500InternalServerError );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Resource list failed " );
+        }
+        
+        svru::Response::add_allow_headers (resp, req) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+};
+
+template <typename TU> void Base_resource::read(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_elem_id, std::string&& p_usage,  std::string&& p_lang ) const{
+
+            auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+            auto elem_id = svru::Request::check_element_id (p_elem_id);
+
+    
+        
+        try {
+
+
+        auto lang = app_ptr->get_language_by_code(util::String::standardize (p_lang));
+        
+        auto && usage = ( p_usage.length() == 0 ) ? "ro" : util::String::standardize ( p_usage );
+        if ( usage != "ro" && usage != "rfu" ) {
+            std::cout << "WARNING: read mode " << usage << "is unknown, default mode (read only) is applied" << std::endl;
+            usage = "ro";
+        }
+
+        qry::Util::Read_mode read_mode = qry::Util::convert_read_mode ( usage );
+
+
+        auto resp = HttpResponse::newHttpResponse();
+
+        TU ar ( elem_id, read_mode, lang);
+        ar.execute ();
+
+        if ( ar.return_code () == qry::Return_code::OK ) {
+                const Json::Value & json = ar.return_json();
+
+                resp = HttpResponse::newHttpJsonResponse ( json );
+
+        } else {
+            resp->setStatusCode ( k500InternalServerError );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Resource reading failed " );
+        }
+        
+        svru::Response::add_allow_headers (resp, req) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+};
+
+
+template <typename TU> void Base_resource::update(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_elem_id) const{
+
+            auto elem_id = svru::Request::check_element_id (p_elem_id);
+
+    
+        
+        try {
+
+
+
+        auto resp = HttpResponse::newHttpResponse();
+        auto json_ptr = req->jsonObject() ;
+        const int upd_count = json_ptr->get("upd_count",0).asInt();
+        TU au ( elem_id, *json_ptr , upd_count);
+        au.execute ();
+
+        if ( au.return_code () == qry::Return_code::OK ) {
+            resp->setStatusCode ( k202Accepted );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "App updated " );
+        } else {
+            resp->setStatusCode ( k422UnprocessableEntity );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "App updating failed " );
+        }
+        
+        svru::Response::add_allow_headers (resp, req) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+};
+
+
+template <typename TD> void Base_resource::deletion (const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_elem_id) const{
+    
+
+    auto elem_id = svru::Request::check_element_id (p_elem_id);
+
+    
+          
+    try {
+
+
+
+        auto resp = HttpResponse::newHttpResponse();
+        TD ad (elem_id);
+        ad.execute ();
+
+        if ( ad.return_code () == qry::Return_code::OK ) {
+            resp->setStatusCode ( k202Accepted );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Resource deleted " );
+        } else {
+            resp->setStatusCode ( k422UnprocessableEntity );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Resource deletion failed " );
+        }
+        
+        svru::Response::add_allow_headers (resp, req) ;
+
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+}
+

src/controllers/Classes.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Classes.h>
+#include "Classifiers.tpp"
+
+
+
+
+namespace arolios::ctlr {
+
+template class Classifiers<omm::Class> ;
+}
+
+
+
+

src/controllers/Classifiers.tpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Classifiers.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <common/Object_model_info.h>
+#include <drogon/HttpAppFramework.h>
+#include <drogon/HttpRequest.h>
+#include <drogon/HttpResponse.h>
+#include <drogon/utils/Utilities.h>
+#include <json/json.h>
+#include <qry/Classifier_properties_list.h>
+#include <qry/Classifier_instances_list.h>
+#include <qry/Classifiers_list.h>
+#include <qry/Instance_filter.h>
+#include <util/String.h>
+#include <qry/Return_code.h>
+#include <mttr/Class_instance_association_create.h>
+#include <mttr/Classifier_instance_create.h>
+#include <memory>
+#include <mttr/Classifier_instance_delete.h>
+#include <mttr/Classifier_instance_update.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+
+
+
+
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+template <typename T>
+void Classifiers<T>::list_instances(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback,
+    std::string &&p_elem, std::string &&p_offset, std::string &&p_limit,
+    std::string &&p_sort, std::string &&p_direction, std::string &&p_filters,
+    std::string &&p_prop_list, std::string &&p_lang) const {
+
+
+  auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+  try {
+
+    auto om_ptr = common::Singleton<common::Object_model_info>::instance().object();
+
+
+    auto lang = app_ptr->get_language_by_code(util::String::standardize(p_lang));
+
+   
+
+    auto list_params =
+        svru::Request::check_list_params(p_sort, p_direction, p_limit, p_offset);
+
+    auto prop_list = svru::Request::check_prop_list_mode(p_prop_list);
+
+  
+
+    auto filters = qry::Instance_filter::make_fts_filters(p_filters);
+
+    // add filter to select only active (non-deleted) instances
+    const std::shared_ptr<const qry::Instance_filter> td_filter =
+        std::make_shared<qry::Instance_filter>("trashed_date", "=", "'epoch'");
+    filters.push_back(td_filter);
+
+    auto resp = HttpResponse::newHttpResponse();
+
+
+    const std::shared_ptr<T> elem = svru::Request::is_id( p_elem) ?
+        om_ptr->find_domain_element_by_id<T> (p_elem):
+        app_ptr->find_domain_element_by_full_name<T>(p_elem);
+
+
+    if (elem) {
+     
+      qry::Classifier_instances_list<T> q(
+          elem, list_params.offset_, list_params.limit_,
+          list_params.sort_, list_params.direction_, filters, prop_list, lang);
+
+      q.execute();
+
+      if (q.return_code() == qry::Return_code::OK) {
+        const Json::Value &json = q.return_json();
+
+        resp = HttpResponse::newHttpJsonResponse(json);
+
+
+      } else {
+        resp->setStatusCode(k500InternalServerError);
+        resp->setContentTypeCode(CT_TEXT_HTML);
+        resp->setBody("Instances list failed ");
+      }
+    } else {
+      resp->setStatusCode(k400BadRequest);
+      resp->setContentTypeCode(CT_TEXT_HTML);
+      resp->setBody("Classifier not found ");
+    }
+
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+  catch (const std::exception &e) {
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setBody(e.what());
+     
+    resp->setStatusCode(k500InternalServerError);
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+}
+
+template <typename T>
+void Classifiers<T>::create_instance(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback,
+    std::string &&p_elem) const {
+
+
+  auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+  try {
+
+    auto om_ptr = common::Singleton<common::Object_model_info>::instance().object();
+
+    const std::shared_ptr<T> elem = svru::Request::is_id( p_elem) ?
+        om_ptr->find_domain_element_by_id<T> (p_elem):
+        app_ptr->find_domain_element_by_full_name<T>(p_elem);
+
+
+    auto resp = HttpResponse::newHttpResponse();
+    
+
+    auto json_ptr = req->jsonObject();
+    
+    if (elem) {
+      if (!elem->is_abstract()) {
+        std::shared_ptr<omm::Table> elem_lo = elem->table();
+        if (elem_lo) {
+          // additional table for association (binary association N-M)
+          const std::unordered_map<std::string, std::shared_ptr<const Json::Value>>
+              import_cache;
+          mttr::Classifier_instance_create ic(elem,*json_ptr,
+                                              import_cache);
+          ic.execute();
+
+          if (ic.return_code() == qry::Return_code::OK) {
+            resp = HttpResponse::newHttpJsonResponse(ic.return_json());
+          } else {
+            resp->setStatusCode(k500InternalServerError);
+            resp->setContentTypeCode(CT_TEXT_HTML);
+            resp->setBody("Classifier instance creation failed ");
+          }
+        } else { // no table (binary association 1-N or 1-1), one class instance
+                 // must be updated
+          const std::unordered_map<std::string, std::shared_ptr<const Json::Value>>
+              import_cache;
+          const auto assoc = std::dynamic_pointer_cast<const omm::Association>(elem);
+          mttr::Class_instance_association_create iac(assoc, *json_ptr,
+                                                      import_cache);
+          iac.execute();
+
+          if (iac.return_code() == qry::Return_code::OK) {
+
+            resp = HttpResponse::newHttpJsonResponse(iac.return_json());
+          } else {
+            resp->setStatusCode(k500InternalServerError);
+            resp->setContentTypeCode(CT_TEXT_HTML);
+            resp->setBody("Association instance creation failed ");
+          }
+        }
+      } else {
+        resp->setStatusCode(k400BadRequest);
+        resp->setContentTypeCode(CT_TEXT_HTML);
+        resp->setBody("Classifier is abstract, creation not applicable");
+      }
+    } else {
+      resp->setStatusCode(k400BadRequest);
+      resp->setContentTypeCode(CT_TEXT_HTML);
+      resp->setBody("Classifier not found ");
+    }
+
+    // }
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+    catch (const std::exception &e) {
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setBody(e.what());
+     
+    resp->setStatusCode(k500InternalServerError);
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+}
+
+template <typename T>
+void Classifiers<T>::list(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback,
+    std::string &&p_offset, std::string &&p_limit, std::string &&p_sort,
+    std::string &&p_direction, std::string &&p_lang) const {
+
+
+
+
+  const auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+  try {
+
+
+    auto lang = app_ptr->get_language_by_code(util::String::standardize(p_lang));
+
+    auto list_params =
+        svru::Request::check_list_params(p_sort, p_direction, p_limit, p_offset);
+
+     
+
+    auto resp = HttpResponse::newHttpResponse();
+
+    const auto domains = app_ptr->list_user_domains();
+
+    qry::Classifiers_list<T> al(domains, list_params.offset_,
+                                list_params.limit_, list_params.sort_,
+                                list_params.direction_, lang);
+    al.execute();
+
+    if (al.return_code() == qry::Return_code::OK) {
+      const Json::Value &json = al.return_json();
+
+      resp = HttpResponse::newHttpJsonResponse(json);
+
+
+    } else {
+      resp->setStatusCode(k500InternalServerError);
+      resp->setContentTypeCode(CT_TEXT_HTML);
+      resp->setBody("List of classifiers failed ");
+    }
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+  catch (const std::exception &e) {
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setBody(e.what());
+     
+    resp->setStatusCode(k500InternalServerError);
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+}
+
+template <typename T>
+void Classifiers<T>::list_properties(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback,
+    std::string &&p_elem, std::string &&p_offset, std::string &&p_limit,
+    std::string &&p_sort, std::string &&p_direction, std::string &&p_context,
+    std::string &&p_lang) const {
+
+
+  auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+  try {
+
+    auto om_ptr = common::Singleton<common::Object_model_info>::instance().object();
+
+    const auto lang = app_ptr->get_language_by_code(p_lang);
+
+    const auto list_params =
+        svru::Request::check_list_params(p_sort, p_direction, p_limit, p_offset);
+
+        auto ctx = p_context;
+    if (ctx.empty()) {
+      ctx = "IDS";
+    } else {
+      std::transform(
+          ctx.begin(), ctx.end(), ctx.begin(),
+          [](unsigned char c) -> unsigned char { return std::toupper(c); });
+    }
+
+    if (ctx != "IDS" && ctx != "LIST" && ctx != "READ" && ctx != "CREATE" &&
+        ctx != "UPDATE") {
+      std::cout << "WARNING: context " << ctx
+                << "is unknown, default mode (ids) is applied" << std::endl;;
+      ctx = "IDS";
+    }
+
+ 
+
+    auto resp = HttpResponse::newHttpResponse();
+    
+
+    const std::shared_ptr<T> elem = svru::Request::is_id( p_elem) ?
+        om_ptr->find_domain_element_by_id<T> (p_elem):
+        app_ptr->find_domain_element_by_full_name<T>(p_elem);
+
+
+    if (elem) {
+
+
+      qry::Classifier_properties_list q(
+          elem, list_params.offset_, list_params.limit_,
+          list_params.sort_, list_params.direction_, ctx, lang);
+
+      q.execute();
+
+      if (q.return_code() == qry::Return_code::OK) {
+        const Json::Value &json = q.return_json();
+
+        resp = HttpResponse::newHttpJsonResponse(json);
+
+
+      } else {
+        resp->setStatusCode(k500InternalServerError);
+        resp->setContentTypeCode(CT_TEXT_HTML);
+        resp->setBody("Properties list failed ");
+      }
+    } else {
+      resp->setStatusCode(k400BadRequest);
+      resp->setContentTypeCode(CT_TEXT_HTML);
+      resp->setBody("Classifier not found ");
+    }
+
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+  catch (const std::exception &e) {
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setBody(e.what());
+     
+    resp->setStatusCode(k500InternalServerError);
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+}

src/controllers/Domains.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Domains.h>
+#include <json/json.h>
+#include <qry/Domains_list.h>
+#include <qry/Classifiers_list.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <common/Object_model_info.h>
+#include <util/String.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+
+
+void Domains::list(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback , std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction, std::string&& p_lang ) const {
+
+	
+            
+    const auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+    try {
+ 
+        auto lang = app_ptr->get_language_by_code(util::String::standardize(p_lang));
+        
+        const auto list_params = svru::Request::check_list_params (p_sort, p_direction, p_limit, p_offset, false);
+       
+      
+        auto resp = HttpResponse::newHttpResponse();
+
+
+        qry::Domains_list dl  (
+        list_params.offset_, list_params.limit_, list_params.sort_, list_params.direction_, lang);
+        dl.execute();
+
+        if ( dl.return_code () == qry::Return_code::OK ) {
+            const Json::Value & json = dl.return_json();
+
+            resp = HttpResponse::newHttpJsonResponse ( json );
+
+        } else {
+            resp->setStatusCode ( k500InternalServerError );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Domains list failed " );
+        }
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+         
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+
+}
+
+
+
+template <typename T> void Domains::list_classifiers(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_pk_name, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction, std::string&& p_lang ) const {
+
+	
+    
+                
+    const auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+    try {
+        auto lang = app_ptr->get_language_by_code(p_lang);
+        
+        const auto list_params = svru::Request::check_list_params (p_sort, p_direction, p_limit, p_offset, false);
+        
+       
+        auto resp = HttpResponse::newHttpResponse();
+        
+        
+        const std::shared_ptr<const omm::Package> pk = svru::Request::is_id(p_pk_name) ?
+        app_ptr->find_domain_by_id( p_pk_name ) :
+        app_ptr->find_domain_by_name( util::String::standardize ( p_pk_name ) );
+        
+        
+        if ( pk ) {
+            
+            const std::vector<std::shared_ptr<const omm::Package>> pk_vec { pk } ;
+
+            qry::Classifiers_list<T> cl ( pk_vec, list_params.offset_, list_params.limit_, list_params.sort_, list_params.direction_, lang);
+            cl.execute();
+
+            if ( cl.return_code () == qry::Return_code::OK ) {
+                const Json::Value & json = cl.return_json();
+
+                resp = HttpResponse::newHttpJsonResponse ( json );
+
+            } else {
+                resp->setStatusCode ( k500InternalServerError );
+                resp->setContentTypeCode ( CT_TEXT_HTML );
+                resp->setBody ( "Domain elements list failed " );
+            }
+
+        } else {
+            resp->setStatusCode ( k400BadRequest );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Domain not found " );
+        }
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+         
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    
+	
+}
+
+namespace arolios::ctlr {
+template void Domains::list_classifiers<omm::Class>(const HttpRequestPtr &req, std::function<void (const HttpResponsePtr &)> &&callback, std::string &&p_pk_name, std::string &&p_offset, std::string &&p_limit, std::string &&p_sort, std::string &&p_direction, std::string &&p_lang) const;
+template void Domains::list_classifiers<omm::Association>(const HttpRequestPtr &req, std::function<void (const HttpResponsePtr &)> &&callback, std::string &&p_pk_name, std::string &&p_offset, std::string &&p_limit, std::string &&p_sort, std::string &&p_direction, std::string &&p_lang) const;
+template void Domains::list_classifiers<omm::Enumeration>(const HttpRequestPtr &req, std::function<void (const HttpResponsePtr &)> &&callback, std::string &&p_pk_name, std::string &&p_offset, std::string &&p_limit, std::string &&p_sort, std::string &&p_direction, std::string &&p_lang) const;
+
+}
\ No newline at end of file

src/controllers/Enumerations.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Enumerations.h>
+#include <json/json.h>
+#include <common/Object_model_info.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <drogon/utils/Utilities.h>
+#include <drogon/HttpRequest.h>
+#include <drogon/HttpResponse.h>
+#include <drogon/HttpAppFramework.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <util/String.h>
+#include <qry/Return_code.h>
+#include <qry/Enumeration_values_list.h>
+#include <qry/Classifiers_list.h>
+#include <omm/Enumeration.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+
+
+
+
+
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+
+
+void Enumerations::list(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback,
+    std::string &&p_offset, std::string &&p_limit, std::string &&p_sort,
+    std::string &&p_direction, std::string &&p_lang) const {
+
+  
+
+
+  const auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+  try {
+
+
+    auto lang = app_ptr->get_language_by_code(util::String::standardize(p_lang));
+
+    auto list_params =
+        svru::Request::check_list_params(p_sort, p_direction, p_limit, p_offset);
+
+        
+
+        auto resp = HttpResponse::newHttpResponse();
+
+    const auto domains = app_ptr->list_user_domains();
+
+    qry::Classifiers_list<omm::Enumeration> al( domains, list_params.offset_,
+                                list_params.limit_, list_params.sort_,
+                                list_params.direction_, lang);
+    al.execute();
+
+    if (al.return_code() == qry::Return_code::OK) {
+      const Json::Value &json = al.return_json();
+
+      resp = HttpResponse::newHttpJsonResponse(json);
+
+
+    } else {
+      resp->setStatusCode(k500InternalServerError);
+      resp->setContentTypeCode(CT_TEXT_HTML);
+      resp->setBody("List of Enumerations failed ");
+    }
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+  catch (const std::exception &e) {
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setBody(e.what());
+     
+    resp->setStatusCode(k500InternalServerError);
+    svru::Response::add_allow_headers(resp, req);
+
+    callback(resp);
+    return;
+  }
+}
+
+void Enumerations::values(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback, std::string&& p_enum, std::string&& p_offset, std::string&& p_limit, std::string&& p_sort, std::string&& p_direction, std::string&& p_lang ) const {
+
+    
+
+    auto app_ptr = common::Singleton<common::App_info>::instance().object();
+    
+    try {
+        auto om_ptr = common::Singleton<common::Object_model_info>::instance().object();
+        auto lang = app_ptr->get_language_by_code(p_lang);
+
+        const auto list_params =
+            svru::Request::check_list_params(p_sort, p_direction, p_limit, p_offset);
+        
+ 
+
+        auto resp = HttpResponse::newHttpResponse();
+       
+        const std::shared_ptr<omm::Enumeration> enum_ptr = svru::Request::is_id( p_enum) ?
+        om_ptr->find_domain_element_by_id<omm::Enumeration> (p_enum):
+        app_ptr->find_domain_element_by_full_name<omm::Enumeration>(p_enum);
+       
+        if (enum_ptr ) {
+            qry::Enumeration_values_list  evl ( enum_ptr, list_params.offset_, list_params.limit_,
+          list_params.sort_, list_params.direction_, lang) ;
+       
+            evl.execute (); 
+             
+            if ( evl.return_code () == qry::Return_code::OK ) {
+                const Json::Value & json = evl.return_json();
+
+                resp = HttpResponse::newHttpJsonResponse ( json );
+
+
+            } else {
+                resp->setStatusCode ( k500InternalServerError );
+                resp->setContentTypeCode ( CT_TEXT_HTML );
+                resp->setBody ( "Values list failed " );
+            }
+        } else {
+            resp->setStatusCode ( k400BadRequest );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "Enumeration not found " );
+        }
+
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+         
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    
+}
+

src/controllers/Languages.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Languages.h>
+#include <json/json.h>
+#include <common/App_info.h>
+#include <common/Singleton.h>
+#include <common/Object_model_info.h>
+#include <util/String.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+#include <qry/Languages_list.h>
+#include <qry/Instance_filter.h>
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+void Languages::list ( const HttpRequestPtr& req,std::function<void ( const HttpResponsePtr & ) > &&callback, std::string&& p_filters) const {
+    
+  
+            
+    const auto app_ptr = common::Singleton<common::App_info>::instance().object();
+
+    try {
+
+        
+        std::string sort = "code";
+
+
+        std::string dir = "ASC";
+
+        std::string offset = "";
+        std::string limit = "";
+
+        auto filters = qry::Instance_filter::make_language_filters(p_filters);
+        
+        
+        auto resp = HttpResponse::newHttpResponse();
+        
+         qry::Languages_list ll  ( offset, limit, sort, dir, filters, app_ptr->default_language());
+        ll.execute();
+
+        if ( ll.return_code () == qry::Return_code::OK ) {
+            const Json::Value & json = ll.return_json();
+
+            resp = HttpResponse::newHttpJsonResponse ( json );
+
+
+        } else {
+            resp->setStatusCode ( k500InternalServerError );
+            resp->setContentTypeCode ( CT_TEXT_HTML );
+            resp->setBody ( "languages list failed " );
+        }
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+    catch ( const std::exception&  e ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what() );
+         
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+
+}

src/controllers/Models.cpp

+/*
+ *
+ * Copyright (C) 2024 Philippe Coicadan. All rights reserved.
+ * License: AGPL-3.0-or-later
+ *
+ */
+#include <ctlr/Models.h>
+#include <json/json.h>
+#include <model/Model_loader.h>
+#include <svru/Request.h>
+#include <svru/Response.h>
+
+
+
+
+using namespace arolios;
+using namespace arolios::ctlr;
+
+
+void Models::load(const HttpRequestPtr& req,std::function<void (const HttpResponsePtr &)> &&callback) const {
+
+    
+
+    MultiPartParser fileUpload;
+
+    if ( fileUpload.parse ( req ) != 0 || fileUpload.getFiles().size() != 1 ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( "Only one file is expected" );
+        resp->setStatusCode ( k403Forbidden );
+        svru::Response::add_allow_headers (resp, req) ;
+        callback ( resp );
+        return;
+    }
+
+    try {
+        auto &file = fileUpload.getFiles() [0];
+        auto md5 = file.getMd5();
+        auto len = file.fileLength();
+        auto ext = file.getFileExtension ();
+        auto name = file.getFileName();
+        auto type = file.getFileType ();
+
+        
+
+        file.save();
+        std::cout << "INFO: The uploaded file has been saved to the ./uploads "
+                 "directory";
+
+        model::Model_loader mdl_loader;
+        mdl_loader.execute ( drogon::app().getUploadPath() + '/' + name );
+
+
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setStatusCode(k200OK);
+        resp->setContentTypeCode(CT_TEXT_HTML);
+        resp->setBody ("Model loaded successfully");
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    } 
+    catch ( const std::exception&  e  ) {
+        auto resp = HttpResponse::newHttpResponse();
+        resp->setBody ( e.what());
+         
+        resp->setStatusCode ( k500InternalServerError );
+        svru::Response::add_allow_headers (resp, req) ;
+
+        callback ( resp );
+        return;
+    }
+
+}
+