IT4Change/gradido
3
0
Fork 0
mirror of https://github.com/IT4Change/gradido.git synced 2025-12-13 07:45:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

restructure json request handler

Browse Source
This commit is contained in:
Dario 2020-03-21 18:25:11 +01:00
parent 061122f219
commit e1c470524a
12 changed files with 323 additions and 542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
src/cpp/JSONInterface/JsonAdminEmailVerificationResend.cpp
View File

@ -8,11 +8,12 @@
#include "../controller/User.h"
#include "../controller/EmailVerificationCode.h"
#include "../lib/DataTypeConverter.h"
Poco::JSON::Object* JsonAdminEmailVerificationResend::handle(Poco::Dynamic::Var params)
{
std::string email;
int session_id = 0;
Poco::JSON::Object* result = new Poco::JSON::Object;
bool parameterReaded = false;
// if is json object
if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
@ -28,10 +29,7 @@ Poco::JSON::Object* JsonAdminEmailVerificationResend::handle(Poco::Dynamic::Var
parameterReaded = true;
}
catch (Poco::Exception& ex) {
printf("[JsonGetRunningUserTasks::handle] try to use params as jsonObject: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "json exception");
result->set("details", ex.displayText());
return stateError("json exception", ex.displayText());
}
}
else if (params.isStruct()) {
@ -49,116 +47,61 @@ Poco::JSON::Object* JsonAdminEmailVerificationResend::handle(Poco::Dynamic::Var
}
else if (it->first == "session_id") {
try {
session_id = stoi(it->second);
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
auto numberParseResult = DataTypeConverter::strToInt(it->second, session_id);
if (DataTypeConverter::NUMBER_PARSE_OKAY != numberParseResult) {
return stateError("error parsing session_id", DataTypeConverter::numberParseStateToString(numberParseResult));
}
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
return stateError("error parsing query params, Poco Error", ex.displayText());
}
}
}
parameterReaded = true;
}
else if (params.isArray()) {
result->set("state", "error");
result->set("msg", "array not implemented yet");
if (!parameterReaded) {
return stateError("error reading parameter");
}
else if (params.isList()) {
result->set("state", "error");
result->set("msg", "list not implemented yet");
if ("" == email || 0 == session_id) {
return stateError("missing parameter");
}
else if (params.isString()) {
result->set("state", "error");
result->set("msg", "string not implemented yet");
}
else if (params.isDeque()) {
result->set("state", "error");
result->set("msg", "deque not implemented yet");
}
else {
result->set("state", "error");
result->set("msg", "format not implemented");
result->set("details", std::string(params.type().name()));
auto sm = SessionManager::getInstance();
auto em = EmailManager::getInstance();
auto session = sm->getSession(session_id);
if (!session) {
return stateError("session not found");
}
if (parameterReaded && email != "" && session_id != 0) {
auto sm = SessionManager::getInstance();
auto em = EmailManager::getInstance();
auto session = sm->getSession(session_id);
if (session) {
auto user = session->getNewUser();
if (!user.isNull()) {
auto userModel = user->getModel();
if (userModel->getRole() == model::table::ROLE_ADMIN) {
auto receiverUser = controller::User::create();
if (1 == receiverUser->load(email)) {
if (!receiverUser->getModel()->isEmailChecked()) {
auto emailVerification = controller::EmailVerificationCode::create(receiverUser->getModel()->getID(), model::table::EMAIL_OPT_IN_REGISTER);
if (!emailVerification.isNull()) {
em->addEmail(new model::Email(emailVerification, receiverUser, model::EMAIL_ADMIN_USER_VERIFICATION_CODE_RESEND));
result->set("state", "success");
}
else {
result->set("state", "error");
result->set("msg", "no email verification code found");
}
}
else {
result->set("state", "error");
result->set("msg", "account already active");
}
}
else {
result->set("state", "error");
result->set("msg", "receiver user not found");
}
}
else {
result->set("state", "error");
result->set("msg", "user isn't admin");
}
}
else {
result->set("state", "error");
result->set("msg", "session hasn't valid user");
}
}
else {
result->set("state", "error");
result->set("msg", "session not found");
}
auto user = session->getNewUser();
if(user.isNull()) {
return stateError("session hasn't valid user");
}
//result->set("runningTasks", tasksJson);
}
else if (parameterReaded) {
result->set("state", "error");
result->set("msg", "empty email or session_id");
}
else {
result->set("state", "error");
result->set("msg", "error reading parameter");
auto userModel = user->getModel();
if(model::table::ROLE_ADMIN != userModel->getRole()) {
return stateError("user isn't admin");
}
return result;
auto receiverUser = controller::User::create();
if (1 != receiverUser->load(email)) {
return stateError("receiver user not found");
}
if (receiverUser->getModel()->isEmailChecked()) {
return stateError("account already active");
}
auto emailVerification = controller::EmailVerificationCode::create(receiverUser->getModel()->getID(), model::table::EMAIL_OPT_IN_REGISTER);
if (emailVerification.isNull()) {
return stateError("no email verification code found");
}
em->addEmail(new model::Email(emailVerification, receiverUser, model::EMAIL_ADMIN_USER_VERIFICATION_CODE_RESEND));
return stateSuccess();
}

107
src/cpp/JSONInterface/JsonCreateUser.cpp
View File

@ -5,112 +5,15 @@
#include "../SingletonManager/SingletonTaskObserver.h"
#include "../SingletonManager/ErrorManager.h"
#include "../lib/DataTypeConverter.h"
Poco::JSON::Object* JsonCreateUser::handle(Poco::Dynamic::Var params)
{
int session_id = 0;
Poco::JSON::Object* result = new Poco::JSON::Object;
/*result->set("state", "debugging");
result->set("msg", "deactivate for debugging");
return result;
*/
if (params.isStruct()) {
session_id = params["session_id"];
//std::string miau = params["miau"];
}
else if (params.isVector()) {
try {
const Poco::URI::QueryParameters queryParams = params.extract<Poco::URI::QueryParameters>();
for (auto it = queryParams.begin(); it != queryParams.end(); it++) {
if (it->first == "session_id") {
session_id = stoi(it->second);
break;
}
}
//auto var = params[0];
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
}
}
if (session_id) {
auto sm = SessionManager::getInstance();
auto observer = SingletonTaskObserver::getInstance();
auto session = sm->getSession(session_id);
if (session) {
auto userNew = session->getNewUser();
auto user = session->getUser();
if (user.isNull()) {
result->set("state", "not found");
result->set("msg", "Session didn't contain user");
return result;
}
auto userModel = userNew->getModel();
if (userModel.isNull()) {
result->set("state", "not found");
result->set("msg", "user is empty");
return result;
}//*/
result->set("state", "success");
result->set("clientIP", session->getClientIp().toString());
try {
result->set("user", userNew->getJson());
}
catch (Poco::Exception ex) {
auto em = ErrorManager::getInstance();
em->addError(new ParamError("JsonGetLogin::handle", "poco exception calling userModel->getJson: ", ex.displayText().data()));
em->sendErrorsAsEmail();
}
catch (...) {
auto em = ErrorManager::getInstance();
em->addError(new Error("JsonGetLogin::handle", "generic exception calling userModel->getJson: "));
em->sendErrorsAsEmail();
}
result->set("Transaction.pending", session->getProcessingTransactionCount());
auto executing = observer->getTaskCount(userModel->getEmail(), TASK_OBSERVER_SIGN_TRANSACTION);
if (executing < 0) {
executing = 0;
}
result->set("Transaction.executing", executing);
//printf("pending: %d\n", session->getProcessingTransactionCount());
return result;
}
else {
result->set("state", "not found");
result->set("msg", "session not found");
return result;
}
}
else {
result->set("state", "error");
result->set("msg", "empty session id");
}
result->set("state", "debugging");
result->set("msg", "empty implementation");
return result;
}

131
src/cpp/JSONInterface/JsonGetLogin.cpp
View File

@ -5,16 +5,14 @@
#include "../SingletonManager/SingletonTaskObserver.h"
#include "../SingletonManager/ErrorManager.h"
#include "../lib/DataTypeConverter.h"
Poco::JSON::Object* JsonGetLogin::handle(Poco::Dynamic::Var params)
{
int session_id = 0;
Poco::JSON::Object* result = new Poco::JSON::Object;
/*result->set("state", "debugging");
result->set("msg", "deactivate for debugging");
return result;
*/
auto sm = SessionManager::getInstance();
auto observer = SingletonTaskObserver::getInstance();
if (params.isStruct()) {
session_id = params["session_id"];
@ -25,92 +23,61 @@ Poco::JSON::Object* JsonGetLogin::handle(Poco::Dynamic::Var params)
const Poco::URI::QueryParameters queryParams = params.extract<Poco::URI::QueryParameters>();
for (auto it = queryParams.begin(); it != queryParams.end(); it++) {
if (it->first == "session_id") {
session_id = stoi(it->second);
auto numberParseResult = DataTypeConverter::strToInt(it->second, session_id);
if (DataTypeConverter::NUMBER_PARSE_OKAY != numberParseResult) {
return stateError("error parsing session_id", DataTypeConverter::numberParseStateToString(numberParseResult));
}
break;
}
}
//auto var = params[0];
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
return stateError("error parsing query params, Poco Error", ex.displayText());
}
}
if (session_id) {
auto sm = SessionManager::getInstance();
auto observer = SingletonTaskObserver::getInstance();
auto session = sm->getSession(session_id);
if (session) {
auto userNew = session->getNewUser();
auto user = session->getUser();
if (user.isNull()) {
result->set("state", "not found");
result->set("msg", "Session didn't contain user");
return result;
}
auto userModel = userNew->getModel();
if(userModel.isNull()) {
result->set("state", "not found");
result->set("msg", "user is empty");
return result;
}//*/
result->set("state", "success");
result->set("clientIP", session->getClientIp().toString());
try {
result->set("user", userNew->getJson());
}
catch (Poco::Exception ex) {
auto em = ErrorManager::getInstance();
em->addError(new ParamError("JsonGetLogin::handle", "poco exception calling userModel->getJson: ", ex.displayText().data()));
em->sendErrorsAsEmail();
}
catch (...) {
auto em = ErrorManager::getInstance();
em->addError(new Error("JsonGetLogin::handle", "generic exception calling userModel->getJson: "));
em->sendErrorsAsEmail();
}
result->set("Transaction.pending", session->getProcessingTransactionCount());
auto executing = observer->getTaskCount(userModel->getEmail(), TASK_OBSERVER_SIGN_TRANSACTION);
if (executing < 0) {
executing = 0;
}
result->set("Transaction.executing", executing);
//printf("pending: %d\n", session->getProcessingTransactionCount());
return result;
}
else {
result->set("state", "not found");
result->set("msg", "session not found");
return result;
}
if (!session_id) {
return stateError("empty session id");
}
else {
result->set("state", "error");
result->set("msg", "empty session id");
auto session = sm->getSession(session_id);
if (!session) {
return customStateError("not found", "session not found");
}
auto userNew = session->getNewUser();
auto user = session->getUser();
if (user.isNull()) {
return customStateError("not found", "Session didn't contain user");
}
auto userModel = userNew->getModel();
if(userModel.isNull()) {
return customStateError("not found", "User is empty");
}
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "success");
result->set("clientIP", session->getClientIp().toString());
try {
result->set("user", userNew->getJson());
}
catch (Poco::Exception ex) {
auto em = ErrorManager::getInstance();
em->addError(new ParamError("JsonGetLogin::handle", "poco exception calling userModel->getJson: ", ex.displayText().data()));
em->sendErrorsAsEmail();
}
catch (...) {
auto em = ErrorManager::getInstance();
em->addError(new Error("JsonGetLogin::handle", "generic exception calling userModel->getJson: "));
em->sendErrorsAsEmail();
}
result->set("Transaction.pending", session->getProcessingTransactionCount());
auto executing = observer->getTaskCount(userModel->getEmail(), TASK_OBSERVER_SIGN_TRANSACTION);
if (executing < 0) {
executing = 0;
}
result->set("Transaction.executing", executing);
//printf("pending: %d\n", session->getProcessingTransactionCount());
return result;
}

63
src/cpp/JSONInterface/JsonGetRunningUserTasks.cpp
View File

@ -6,7 +6,7 @@
Poco::JSON::Object* JsonGetRunningUserTasks::handle(Poco::Dynamic::Var params)
{
std::string email;
Poco::JSON::Object* result = new Poco::JSON::Object;
bool parameterReaded = false;
// if is json object
if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
@ -21,10 +21,7 @@ Poco::JSON::Object* JsonGetRunningUserTasks::handle(Poco::Dynamic::Var params)
parameterReaded = true;
}
catch (Poco::Exception& ex) {
printf("[JsonGetRunningUserTasks::handle] try to use params as jsonObject: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "json exception");
result->set("details", ex.displayText());
return stateError("json exception", ex.displayText());
}
}
else if (params.isStruct()) {
@ -42,48 +39,30 @@ Poco::JSON::Object* JsonGetRunningUserTasks::handle(Poco::Dynamic::Var params)
}
parameterReaded = true;
}
else if (params.isArray()) {
result->set("state", "error");
result->set("msg", "array not implemented yet");
}
else if (params.isList()) {
result->set("state", "error");
result->set("msg", "list not implemented yet");
}
else if (params.isString()) {
result->set("state", "error");
result->set("msg", "string not implemented yet");
}
else if (params.isDeque()) {
result->set("state", "error");
result->set("msg", "deque not implemented yet");
}
else {
result->set("state", "error");
result->set("msg", "format not implemented");
result->set("details", std::string(params.type().name()));
return stateError("format not implemented", std::string(params.type().name()));
}
if (!parameterReaded) {
return stateError("parameter couldn't parsed");
}
if ("" == email) {
return stateError("empty email");
}
if (parameterReaded && email != "") {
auto ob = SingletonTaskObserver::getInstance();
auto tasks = ob->getTasksCount(email);
Poco::JSON::Object tasksJson;
if (tasks.size() > 0) {
for (int i = 0; i < TASK_OBSERVER_COUNT; i++) {
if (tasks[i] > 0) {
std::string typeName = SingletonTaskObserver::TaskObserverTypeToString(static_cast<TaskObserverType>(i));
tasksJson.set(typeName, tasks[i]);
}
auto ob = SingletonTaskObserver::getInstance();
auto tasks = ob->getTasksCount(email);
Poco::JSON::Object tasksJson;
if (tasks.size() > 0) {
for (int i = 0; i < TASK_OBSERVER_COUNT; i++) {
if (tasks[i] > 0) {
std::string typeName = SingletonTaskObserver::TaskObserverTypeToString(static_cast<TaskObserverType>(i));
tasksJson.set(typeName, tasks[i]);
}
}
result->set("state", "success");
result->set("runningTasks", tasksJson);
}
else if(parameterReaded) {
result->set("state", "error");
result->set("msg", "empty email");
}
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "success");
result->set("runningTasks", tasksJson);
return result;
}

171
src/cpp/JSONInterface/JsonGetUserInfos.cpp
View File

@ -1,12 +1,24 @@
#include "JsonGetUserInfos.h"
#include "../lib/DataTypeConverter.h"
#include "../SingletonManager/SessionManager.h"
#include "../controller/User.h"
#include "../controller/EmailVerificationCode.h"
Poco::JSON::Object* JsonGetUserInfos::handle(Poco::Dynamic::Var params)
{
/*
'session_id' => $session_id,
'email' => $email,
'ask' => ['EmailOptIn.Register']
*/
// incoming
int session_id = 0;
std::string searchString;
Poco::JSON::Object* result = new Poco::JSON::Object;
std::string email;
Poco::Dynamic::Var ask;
auto sm = SessionManager::getInstance();
// if is json object
if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
@ -16,110 +28,67 @@ Poco::JSON::Object* JsonGetUserInfos::handle(Poco::Dynamic::Var params)
/// not available for the given type.
/// Throws InvalidAccessException if Var is empty.
try {
paramJsonObject->get("search").convert(searchString);
paramJsonObject->get("email").convert(email);
paramJsonObject->get("session_id").convert(session_id);
ask = paramJsonObject->get("ask");
}
catch (Poco::Exception& ex) {
printf("[JsonGetUsers::handle] try to use params as jsonObject: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "json exception");
result->set("details", ex.displayText());
return result;
return stateError("json exception", ex.displayText());
}
}
else if (params.isStruct()) {
session_id = params["session_id"];
searchString = params["search"].toString();
//std::string miau = params["miau"];
}
else if (params.isVector()) {
try {
const Poco::URI::QueryParameters queryParams = params.extract<Poco::URI::QueryParameters>();
for (auto it = queryParams.begin(); it != queryParams.end(); it++) {
if (it->first == "session_id") {
session_id = stoi(it->second);
}
else if (it->first == "search") {
searchString = it->second;
}
}
//auto var = params[0];
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
}
}
if (session_id) {
auto sm = SessionManager::getInstance();
auto session = sm->getSession(session_id);
//Session* session = nullptr;
if (session) {
auto user = session->getNewUser();
if (user.isNull()) {
result->set("state", "not found");
result->set("msg", "Session didn't contain user");
return result;
}
else if (searchString == "") {
result->set("state", "not found");
result->set("msg", "search string is empty");
return result;
}
else if (user->getModel()->getRole() != model::table::ROLE_ADMIN) {
result->set("state", "wrong role");
result->set("msg", "User hasn't correct role");
return result;
}
auto results = controller::User::search(searchString);
if (results.size() > 0) {
result->set("state", "success");
//Poco::JSON::Object jsonResultObject;
Poco::JSON::Array jsonUsersArray;
for (auto it = results.begin(); it != results.end(); it++) {
jsonUsersArray.add((*it)->getJson());
(*it)->release();
}
results.clear();
result->set("users", jsonUsersArray);
}
}
else {
result->set("state", "not found");
result->set("msg", "session not found");
}
}
else {
result->set("state", "error");
result->set("msg", "empty session id");
return stateError("parameter format unknown");
}
return result;
if (!session_id) {
return stateError("session_id invalid");
}
auto session = sm->getSession(session_id);
if (!session) {
return customStateError("not found", "session not found");
}
auto user = controller::User::create();
if (1 != user->load(email)) {
return customStateError("not found", "user not found");
}
auto userModel = user->getModel();
if (ask.isArray()) {
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "success");
Poco::JSON::Array jsonErrorsArray;
Poco::JSON::Object jsonUser;
for (auto it = ask.begin(); it != ask.end(); it++) {
auto parameter = *it;
if (parameter.isString()) {
std::string parameterString;
try {
parameter.convert(parameterString);
if (parameterString == "EmailOptIn.Register") {
try {
auto emailVerificationCode = controller::EmailVerificationCode::load(
userModel->getID(), model::table::EMAIL_OPT_IN_REGISTER
);
jsonUser.set("verificationCode", std::to_string(emailVerificationCode->getModel()->getCode()));
}
catch (...) {
}
}
}
catch (Poco::Exception& ex) {
jsonErrorsArray.add("ask parameter invalid");
}
}
}
result->set("errors", jsonErrorsArray);
result->set("userData", jsonUser);
return result;
}
else {
return stateError("ask isn't a array");
}
}

8
src/cpp/JSONInterface/JsonGetUserInfos.h
View File

@ -3,6 +3,14 @@
#include "JsonRequestHandler.h"
/*!
* @author Dario Rekowski
* @date 2020-03-21
* @brief call to get more infos about user
*
* works only for admins
*/
class JsonGetUserInfos : public JsonRequestHandler
{
public:

122
src/cpp/JSONInterface/JsonGetUsers.cpp
View File

@ -5,12 +5,14 @@
#include "../SingletonManager/SessionManager.h"
#include "../controller/User.h"
#include "../lib/DataTypeConverter.h"
Poco::JSON::Object* JsonGetUsers::handle(Poco::Dynamic::Var params)
{
int session_id = 0;
std::string searchString;
Poco::JSON::Object* result = new Poco::JSON::Object;
// if is json object
if (params.type() == typeid(Poco::JSON::Object::Ptr)) {
Poco::JSON::Object::Ptr paramJsonObject = params.extract<Poco::JSON::Object::Ptr>();
@ -24,11 +26,7 @@ Poco::JSON::Object* JsonGetUsers::handle(Poco::Dynamic::Var params)
paramJsonObject->get("session_id").convert(session_id);
}
catch (Poco::Exception& ex) {
printf("[JsonGetUsers::handle] try to use params as jsonObject: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "json exception");
result->set("details", ex.displayText());
return result;
return stateError("json exception", ex.displayText());
}
}
else if (params.isStruct()) {
@ -41,7 +39,10 @@ Poco::JSON::Object* JsonGetUsers::handle(Poco::Dynamic::Var params)
const Poco::URI::QueryParameters queryParams = params.extract<Poco::URI::QueryParameters>();
for (auto it = queryParams.begin(); it != queryParams.end(); it++) {
if (it->first == "session_id") {
session_id = stoi(it->second);
auto numberParseResult = DataTypeConverter::strToInt(it->second, session_id);
if (DataTypeConverter::NUMBER_PARSE_OKAY != numberParseResult) {
return stateError("error parsing session_id", DataTypeConverter::numberParseStateToString(numberParseResult));
}
}
else if (it->first == "search") {
searchString = it->second;
@ -49,81 +50,50 @@ Poco::JSON::Object* JsonGetUsers::handle(Poco::Dynamic::Var params)
}
//auto var = params[0];
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
return stateError("error parsing query params, Poco Error", ex.displayText());
}
}
if (session_id) {
auto sm = SessionManager::getInstance();
auto session = sm->getSession(session_id);
//Session* session = nullptr;
if (session) {
auto user = session->getNewUser();
if (user.isNull()) {
result->set("state", "not found");
result->set("msg", "Session didn't contain user");
return result;
}
else if (searchString == "") {
result->set("state", "not found");
result->set("msg", "search string is empty");
return result;
}
else if (user->getModel()->getRole() != model::table::ROLE_ADMIN) {
result->set("state", "wrong role");
result->set("msg", "User hasn't correct role");
return result;
}
auto results = controller::User::search(searchString);
if (results.size() > 0) {
result->set("state", "success");
//Poco::JSON::Object jsonResultObject;
Poco::JSON::Array jsonUsersArray;
for (auto it = results.begin(); it != results.end(); it++) {
jsonUsersArray.add((*it)->getJson());
(*it)->release();
}
results.clear();
result->set("users", jsonUsersArray);
}
}
else {
result->set("state", "not found");
result->set("msg", "session not found");
}
if (!session_id) {
return stateError("empty session id");
}
else {
result->set("state", "error");
result->set("msg", "empty session id");
auto sm = SessionManager::getInstance();
auto session = sm->getSession(session_id);
if (!session) {
return customStateError("not found", "Session not found");
}
auto user = session->getNewUser();
if (user.isNull()) {
return customStateError("not found", "Session didn't contain user");
}
else if (searchString == "") {
return customStateError("not found", "Search string is empty");
}
else if (user->getModel()->getRole() != model::table::ROLE_ADMIN) {
return customStateError("wrong role", "User hasn't correct role");
}
auto results = controller::User::search(searchString);
if (!results.size()) {
return stateSuccess();
}
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "success");
//Poco::JSON::Object jsonResultObject;
Poco::JSON::Array jsonUsersArray;
for (auto it = results.begin(); it != results.end(); it++) {
jsonUsersArray.add((*it)->getJson());
(*it)->release();
}
results.clear();
result->set("users", jsonUsersArray);
return result;
}

45
src/cpp/JSONInterface/JsonRequestHandler.cpp
View File

@ -8,7 +8,7 @@
#include "Poco/JSON/Parser.h"
#include "../lib/DataTypeConverter.h"
void JsonRequestHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
{
@ -28,16 +28,7 @@ void JsonRequestHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Po
if (method == "POST" || method == "PUT") {
// extract parameter from request
Poco::Dynamic::Var parsedResult = parseJsonWithErrorPrintFile(request_stream);
//Poco::JSON::Parser jsonParser;
/*try {
auto params = jsonParser.parse(request_stream);
// call logic
json_result = handle(params);
}
catch (Poco::Exception& ex) {
printf("[JsonRequestHandler::handleRequest] Exception: %s\n", ex.displayText().data());
}*/
if (parsedResult.size() != 0) {
json_result = handle(parsedResult);
}
@ -88,4 +79,34 @@ Poco::Dynamic::Var JsonRequestHandler::parseJsonWithErrorPrintFile(std::istream&
return Poco::Dynamic::Var();
}
return Poco::Dynamic::Var();
}
}
Poco::JSON::Object* JsonRequestHandler::stateError(const char* msg, std::string details)
{
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "error");
result->set("msg", msg);
if (details != "") {
result->set("details", details);
}
return result;
}
Poco::JSON::Object* JsonRequestHandler::stateSuccess()
{
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", "success");
return result;
}
Poco::JSON::Object* JsonRequestHandler::customStateError(const char* state, const char* msg, std::string details/* = ""*/)
{
Poco::JSON::Object* result = new Poco::JSON::Object;
result->set("state", state);
result->set("msg", msg);
if (details != "") {
result->set("details", details);
}
return result;
}

5
src/cpp/JSONInterface/JsonRequestHandler.h
View File

@ -10,6 +10,7 @@
class JsonRequestHandler : public Poco::Net::HTTPRequestHandler
{
public:
void handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response);
virtual Poco::JSON::Object* handle(Poco::Dynamic::Var params) = 0;
@ -17,6 +18,10 @@ public:
static Poco::Dynamic::Var parseJsonWithErrorPrintFile(std::istream& request_stream, ErrorList* errorHandler = nullptr, const char* functionName = nullptr);
protected:
Poco::JSON::Object* mResultJson;
static Poco::JSON::Object* stateError(const char* msg, std::string details = "");
static Poco::JSON::Object* customStateError(const char* state, const char* msg, std::string details = "");
static Poco::JSON::Object* stateSuccess();
};

4
src/cpp/JSONInterface/JsonRequestHandlerFactory.cpp
View File

@ -10,6 +10,7 @@
#include "JsonGetRunningUserTasks.h"
#include "JsonGetUsers.h"
#include "JsonAdminEmailVerificationResend.h"
#include "JsonGetUserInfos.h"
JsonRequestHandlerFactory::JsonRequestHandlerFactory()
: mRemoveGETParameters("^/([a-zA-Z0-9_-]*)"), mLogging(Poco::Logger::get("requestLog"))
@ -44,6 +45,9 @@ Poco::Net::HTTPRequestHandler* JsonRequestHandlerFactory::createRequestHandler(c
else if (url_first_part == "/adminEmailVerificationResend") {
return new JsonAdminEmailVerificationResend;
}
else if (url_first_part == "/JsonGetUserInfos") {
return new JsonGetUserInfos;
}
return new JsonUnknown;
}

50
src/cpp/lib/DataTypeConverter.cpp
View File

@ -2,35 +2,37 @@
namespace DataTypeConverter
{
int strToInt(const std::string& input)
NumberParseState strToInt(const std::string& input, int& result)
{
try {
return stoi(input);
result = stoi(input);
return NUMBER_PARSE_OKAY;
}
catch (const std::invalid_argument& ia) {
result->set("state", "error");
result->set("msg", "error parsing query params, invalid argument: ");
result->set("details", ia.what());
return result;
catch (const std::invalid_argument& ia)
{
printf("[strToInt] exception: invalid argument: %s\n", ia.what());
return NUMBER_PARSE_INVALID_ARGUMENT;
}
catch (const std::out_of_range& oor) {
result->set("state", "error");
result->set("msg", "error parsing query params, Out of Range error: ");
result->set("details", oor.what());
return result;
catch (const std::out_of_range& oor)
{
printf("[strToInt] exception: out or range: %s\n", oor.what());
return NUMBER_PARSE_OUT_OF_RANGE;
}
catch (const std::logic_error & ler) {
result->set("state", "error");
result->set("msg", "error parsing query params, Logical error: ");
result->set("details", ler.what());
return result;
}
catch (Poco::Exception& ex) {
//printf("[JsonGetLogin::handle] exception: %s\n", ex.displayText().data());
result->set("state", "error");
result->set("msg", "error parsing query params, Poco Error");
result->set("details", ex.displayText());
return result;
catch (const std::logic_error & ler)
{
printf("[strToInt] exception: logical error: %s\n", ler.what());
return NUMBER_PARSE_LOGIC_ERROR;
}
}
const char* numberParseStateToString(NumberParseState state)
{
switch (state) {
case NUMBER_PARSE_OKAY: return "okay";
case NUMBER_PARSE_INVALID_ARGUMENT: return "invalid argument";
case NUMBER_PARSE_OUT_OF_RANGE: return "out of range";
case NUMBER_PARSE_LOGIC_ERROR: return "logical error";
}
return "<unknown>";
}
}

12
src/cpp/lib/DataTypeConverter.h
View File

@ -5,7 +5,17 @@
namespace DataTypeConverter {
int strToInt(const std::string& input);
enum NumberParseState
{
NUMBER_PARSE_OKAY = 0,
NUMBER_PARSE_INVALID_ARGUMENT,
NUMBER_PARSE_OUT_OF_RANGE,
NUMBER_PARSE_LOGIC_ERROR
};
NumberParseState strToInt(const std::string& input, int& result);
const char* numberParseStateToString(NumberParseState state);
};
#endif // __GRADIDO_LOGIN_SERVER_LIB_DATA_TYPE_CONVERTER_H