https://telecominfraproject.atlassian.net/browse/WIFI-12068

Signed-off-by: stephb9959 <stephane.bourque@gmail.com>

src/RESTAPI/RESTAPI_action_links.cpp

@@ -7,321 +7,351 @@
 
 #include "RESTAPI_action_links.h"
 #include "StorageService.h"
-#include "framework/RESTAPI_PartHandler.h"
 #include "framework/OpenAPIRequests.h"
+#include "framework/RESTAPI_PartHandler.h"
 
 #include "Daemon.h"
 
 namespace OpenWifi {
 
 #if defined(TIP_CERT_SERVICE)
-    bool ProcessExternalActionLinks(RESTAPIHandler &handler,const std::string &Id, const std::string &Action);
+	bool ProcessExternalActionLinks(RESTAPIHandler &handler, const std::string &Id,
+									const std::string &Action);
 #endif
 
-    void RESTAPI_action_links::DoGet() {
+	void RESTAPI_action_links::DoGet() {
 
-        auto Action = GetParameter("action","");
-        auto Id = GetParameter("id","");
+		auto Action = GetParameter("action", "");
+		auto Id = GetParameter("id", "");
 
 #if defined(TIP_CERT_SERVICE)
-        if(!OpenWifi::ProcessExternalActionLinks(*this,Id,Action)) {
-            return;
-        }
+		if (!OpenWifi::ProcessExternalActionLinks(*this, Id, Action)) {
+			return;
+		}
 #endif
 
-        SecurityObjects::ActionLink Link;
-        if(!StorageService()->ActionLinksDB().GetActionLink(Id,Link))
-            return DoReturnA404();
+		SecurityObjects::ActionLink Link;
+		if (!StorageService()->ActionLinksDB().GetActionLink(Id, Link))
+			return DoReturnA404();
 
-        if(Action=="password_reset")
-            return RequestResetPassword(Link);
-        else if(Action=="sub_password_reset")
-            return RequestSubResetPassword(Link);
-        else if(Action=="email_verification")
-            return DoEmailVerification(Link);
-        else if(Action=="sub_email_verification")
-            return DoSubEmailVerification(Link);
-        else if(Action=="signup_verification")
-            return DoNewSubVerification(Link);
-        else
-            return DoReturnA404();
-    }
+		if (Action == "password_reset")
+			return RequestResetPassword(Link);
+		else if (Action == "sub_password_reset")
+			return RequestSubResetPassword(Link);
+		else if (Action == "email_verification")
+			return DoEmailVerification(Link);
+		else if (Action == "sub_email_verification")
+			return DoSubEmailVerification(Link);
+		else if (Action == "signup_verification")
+			return DoNewSubVerification(Link);
+		else
+			return DoReturnA404();
+	}
 
-    void RESTAPI_action_links::DoPost() {
-        auto Action = GetParameter("action","");
+	void RESTAPI_action_links::DoPost() {
+		auto Action = GetParameter("action", "");
 
-        if(Action=="password_reset")
-            return CompleteResetPassword();
-        else if(Action=="sub_password_reset")
-            return CompleteResetPassword();
-        else if(Action=="signup_completion")
-            return CompleteSubVerification();
-        else if(Action=="email_invitation")
-            return CompleteEmailInvitation();
-        else
-            return DoReturnA404();
-    }
+		if (Action == "password_reset")
+			return CompleteResetPassword();
+		else if (Action == "sub_password_reset")
+			return CompleteResetPassword();
+		else if (Action == "signup_completion")
+			return CompleteSubVerification();
+		else if (Action == "email_invitation")
+			return CompleteEmailInvitation();
+		else
+			return DoReturnA404();
+	}
 
-    void RESTAPI_action_links::AddGlobalVars(Types::StringPairVec & Vars) {
-        Vars.push_back(std::make_pair("USER_HELPER_EMAIL",AuthService()->HelperEmail()));
-        Vars.push_back(std::make_pair("SUB_HELPER_EMAIL",AuthService()->SubHelperEmail()));
-        Vars.push_back(std::make_pair("GLOBAL_USER_HELPER_EMAIL",AuthService()->GlobalHelperEmail()));
-        Vars.push_back(std::make_pair("GLOBAL_SUB_HELPER_EMAIL",AuthService()->GlobalSubHelperEmail()));
-        Vars.push_back(std::make_pair("USER_HELPER_SITE",AuthService()->HelperSite()));
-        Vars.push_back(std::make_pair("SUB_HELPER_SITE",AuthService()->SubHelperSite()));
-        Vars.push_back(std::make_pair("USER_SYSTEM_LOGIN",AuthService()->SystemLoginSite()));
-        Vars.push_back(std::make_pair("SUB_SYSTEM_LOGIN",AuthService()->SubSystemLoginSite()));
-        Vars.push_back(std::make_pair("USER_SIGNATURE",AuthService()->UserSignature()));
-        Vars.push_back(std::make_pair("SUB_SIGNATURE",AuthService()->SubSignature()));
-    }
+	void RESTAPI_action_links::AddGlobalVars(Types::StringPairVec &Vars) {
+		Vars.push_back(std::make_pair("USER_HELPER_EMAIL", AuthService()->HelperEmail()));
+		Vars.push_back(std::make_pair("SUB_HELPER_EMAIL", AuthService()->SubHelperEmail()));
+		Vars.push_back(
+			std::make_pair("GLOBAL_USER_HELPER_EMAIL", AuthService()->GlobalHelperEmail()));
+		Vars.push_back(
+			std::make_pair("GLOBAL_SUB_HELPER_EMAIL", AuthService()->GlobalSubHelperEmail()));
+		Vars.push_back(std::make_pair("USER_HELPER_SITE", AuthService()->HelperSite()));
+		Vars.push_back(std::make_pair("SUB_HELPER_SITE", AuthService()->SubHelperSite()));
+		Vars.push_back(std::make_pair("USER_SYSTEM_LOGIN", AuthService()->SystemLoginSite()));
+		Vars.push_back(std::make_pair("SUB_SYSTEM_LOGIN", AuthService()->SubSystemLoginSite()));
+		Vars.push_back(std::make_pair("USER_SIGNATURE", AuthService()->UserSignature()));
+		Vars.push_back(std::make_pair("SUB_SIGNATURE", AuthService()->SubSignature()));
+	}
 
-    void RESTAPI_action_links::RequestResetPassword(SecurityObjects::ActionLink &Link) {
-        Logger_.information(fmt::format("REQUEST-PASSWORD-RESET({}): For ID={}", Request->clientAddress().toString(), Link.userId));
-        Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset.html"};
-        Types::StringPairVec    FormVars{ {"UUID", Link.id},
-                                          {"PASSWORD_VALIDATION", AuthService()->PasswordValidationExpression()}};
-        AddGlobalVars(FormVars);
-        SendHTMLFileBack(FormFile,FormVars);
-    }
+	void RESTAPI_action_links::RequestResetPassword(SecurityObjects::ActionLink &Link) {
+		Logger_.information(fmt::format("REQUEST-PASSWORD-RESET({}): For ID={}",
+										Request->clientAddress().toString(), Link.userId));
+		Poco::File FormFile{Daemon()->AssetDir() + "/password_reset.html"};
+		Types::StringPairVec FormVars{
+			{"UUID", Link.id},
+			{"PASSWORD_VALIDATION", AuthService()->PasswordValidationExpression()}};
+		AddGlobalVars(FormVars);
+		SendHTMLFileBack(FormFile, FormVars);
+	}
 
-    void RESTAPI_action_links::DoNewSubVerification(SecurityObjects::ActionLink &Link) {
-        Logger_.information(fmt::format("REQUEST-SUB-SIGNUP({}): For ID={}", Request->clientAddress().toString(), Link.userId));
-        Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_signup_verification.html"};
-        Types::StringPairVec    FormVars{ {"UUID", Link.id},
-                                          {"PASSWORD_VALIDATION", AuthService()->PasswordValidationExpression()}};
-        AddGlobalVars(FormVars);
-        SendHTMLFileBack(FormFile,FormVars);
-    }
+	void RESTAPI_action_links::DoNewSubVerification(SecurityObjects::ActionLink &Link) {
+		Logger_.information(fmt::format("REQUEST-SUB-SIGNUP({}): For ID={}",
+										Request->clientAddress().toString(), Link.userId));
+		Poco::File FormFile{Daemon()->AssetDir() + "/sub_signup_verification.html"};
+		Types::StringPairVec FormVars{
+			{"UUID", Link.id},
+			{"PASSWORD_VALIDATION", AuthService()->PasswordValidationExpression()}};
+		AddGlobalVars(FormVars);
+		SendHTMLFileBack(FormFile, FormVars);
+	}
 
-    void RESTAPI_action_links::CompleteResetPassword() {
-        //  form has been posted...
-        RESTAPI_PartHandler PartHandler;
-        Poco::Net::HTMLForm Form(*Request, Request->stream(), PartHandler);
-        if (!Form.empty()) {
+	void RESTAPI_action_links::CompleteResetPassword() {
+		//  form has been posted...
+		RESTAPI_PartHandler PartHandler;
+		Poco::Net::HTMLForm Form(*Request, Request->stream(), PartHandler);
+		if (!Form.empty()) {
 
-            auto Password1 = Form.get("password1","bla");
-            auto Password2 = Form.get("password2","blu");
-            auto Id = Form.get("id","");
-            auto now = OpenWifi::Now();
+			auto Password1 = Form.get("password1", "bla");
+			auto Password2 = Form.get("password2", "blu");
+			auto Id = Form.get("id", "");
+			auto now = OpenWifi::Now();
 
-            SecurityObjects::ActionLink Link;
-            if(!StorageService()->ActionLinksDB().GetActionLink(Id,Link))
-                return DoReturnA404();
+			SecurityObjects::ActionLink Link;
+			if (!StorageService()->ActionLinksDB().GetActionLink(Id, Link))
+				return DoReturnA404();
 
-            if(now > Link.expires) {
-                StorageService()->ActionLinksDB().CancelAction(Id);
-                return DoReturnA404();
-            }
+			if (now > Link.expires) {
+				StorageService()->ActionLinksDB().CancelAction(Id);
+				return DoReturnA404();
+			}
 
-            if(Password1!=Password2 || !AuthService()->ValidatePassword(Password2) || !AuthService()->ValidatePassword(Password1)) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "For some reason, the passwords entered do not match or they do not comply with"
-                                                                 " accepted password creation restrictions. Please consult our on-line help"
-                                                                 " to look at the our password policy. If you would like to contact us, please mention"
-                                                                 " id(" + Id + ")"}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			if (Password1 != Password2 || !AuthService()->ValidatePassword(Password2) ||
+				!AuthService()->ValidatePassword(Password1)) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/password_reset_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT",
+					 "For some reason, the passwords entered do not match or they do not comply "
+					 "with"
+					 " accepted password creation restrictions. Please consult our on-line help"
+					 " to look at the our password policy. If you would like to contact us, please "
+					 "mention"
+					 " id(" +
+						 Id + ")"}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            SecurityObjects::UserInfo   UInfo;
+			SecurityObjects::UserInfo UInfo;
 
-            bool Found = Link.userAction ? StorageService()->UserDB().GetUserById(Link.userId,UInfo) : StorageService()->SubDB().GetUserById(Link.userId,UInfo);
-            if(!Found) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "This request does not contain a valid user ID. Please contact your system administrator."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			bool Found = Link.userAction
+							 ? StorageService()->UserDB().GetUserById(Link.userId, UInfo)
+							 : StorageService()->SubDB().GetUserById(Link.userId, UInfo);
+			if (!Found) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/password_reset_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT", "This request does not contain a valid user ID. Please contact "
+								   "your system administrator."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            if(UInfo.blackListed || UInfo.suspended) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "Please contact our system administrators. We have identified an error in your account that must be resolved first."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			if (UInfo.blackListed || UInfo.suspended) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/password_reset_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT", "Please contact our system administrators. We have identified "
+								   "an error in your account that must be resolved first."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            bool GoodPassword = Link.userAction ? AuthService()->SetPassword(Password1,UInfo) : AuthService()->SetSubPassword(Password1,UInfo);
-            if(!GoodPassword) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "You cannot reuse one of your recent passwords."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			bool GoodPassword = Link.userAction ? AuthService()->SetPassword(Password1, UInfo)
+												: AuthService()->SetSubPassword(Password1, UInfo);
+			if (!GoodPassword) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/password_reset_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id}, {"ERROR_TEXT", "You cannot reuse one of your recent passwords."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            UInfo.modified = OpenWifi::Now();
-            if(Link.userAction)
-                StorageService()->UserDB().UpdateUserInfo(UInfo.email,Link.userId,UInfo);
-            else
-                StorageService()->SubDB().UpdateUserInfo(UInfo.email,Link.userId,UInfo);
+			UInfo.modified = OpenWifi::Now();
+			if (Link.userAction)
+				StorageService()->UserDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
+			else
+				StorageService()->SubDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
 
-            Poco::File  FormFile{ Daemon()->AssetDir() + "/password_reset_success.html"};
-            Types::StringPairVec    FormVars{ {"UUID", Id},
-                                              {"USERNAME", UInfo.email},
-                                              {"ACTION_LINK",MicroService::instance().GetUIURI()}};
-            AddGlobalVars(FormVars);
-            StorageService()->ActionLinksDB().CompleteAction(Id);
-            SendHTMLFileBack(FormFile,FormVars);
-        } else {
-            DoReturnA404();
-        }
-    }
+			Poco::File FormFile{Daemon()->AssetDir() + "/password_reset_success.html"};
+			Types::StringPairVec FormVars{{"UUID", Id},
+										  {"USERNAME", UInfo.email},
+										  {"ACTION_LINK", MicroService::instance().GetUIURI()}};
+			AddGlobalVars(FormVars);
+			StorageService()->ActionLinksDB().CompleteAction(Id);
+			SendHTMLFileBack(FormFile, FormVars);
+		} else {
+			DoReturnA404();
+		}
+	}
 
-    void RESTAPI_action_links::CompleteSubVerification() {
-        RESTAPI_PartHandler PartHandler;
-        Poco::Net::HTMLForm Form(*Request, Request->stream(), PartHandler);
+	void RESTAPI_action_links::CompleteSubVerification() {
+		RESTAPI_PartHandler PartHandler;
+		Poco::Net::HTMLForm Form(*Request, Request->stream(), PartHandler);
 
-        if (!Form.empty()) {
-            auto Password1 = Form.get("password1","bla");
-            auto Password2 = Form.get("password2","blu");
-            auto Id = Form.get("id","");
-            auto now = OpenWifi::Now();
+		if (!Form.empty()) {
+			auto Password1 = Form.get("password1", "bla");
+			auto Password2 = Form.get("password2", "blu");
+			auto Id = Form.get("id", "");
+			auto now = OpenWifi::Now();
 
-            SecurityObjects::ActionLink Link;
-            if(!StorageService()->ActionLinksDB().GetActionLink(Id,Link)) {
-                return DoReturnA404();
-            }
+			SecurityObjects::ActionLink Link;
+			if (!StorageService()->ActionLinksDB().GetActionLink(Id, Link)) {
+				return DoReturnA404();
+			}
 
-            if(now > Link.expires) {
-                StorageService()->ActionLinksDB().CancelAction(Id);
-                return DoReturnA404();
-            }
+			if (now > Link.expires) {
+				StorageService()->ActionLinksDB().CancelAction(Id);
+				return DoReturnA404();
+			}
 
-            if(Password1!=Password2 || !AuthService()->ValidateSubPassword(Password1)) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_password_reset_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "For some reason, the passwords entered do not match or they do not comply with"
-                                                                 " accepted password creation restrictions. Please consult our on-line help"
-                                                                 " to look at the our password policy. If you would like to contact us, please mention"
-                                                                 " id(" + Id + ")"}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			if (Password1 != Password2 || !AuthService()->ValidateSubPassword(Password1)) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/sub_password_reset_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT",
+					 "For some reason, the passwords entered do not match or they do not comply "
+					 "with"
+					 " accepted password creation restrictions. Please consult our on-line help"
+					 " to look at the our password policy. If you would like to contact us, please "
+					 "mention"
+					 " id(" +
+						 Id + ")"}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            SecurityObjects::UserInfo   UInfo;
-            bool Found = StorageService()->SubDB().GetUserById(Link.userId,UInfo);
-            if(!Found) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "This request does not contain a valid user ID. Please contact your system administrator."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			SecurityObjects::UserInfo UInfo;
+			bool Found = StorageService()->SubDB().GetUserById(Link.userId, UInfo);
+			if (!Found) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT", "This request does not contain a valid user ID. Please contact "
+								   "your system administrator."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            if(UInfo.blackListed || UInfo.suspended) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "Please contact our system administrators. We have identified an error in your account that must be resolved first."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			if (UInfo.blackListed || UInfo.suspended) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id},
+					{"ERROR_TEXT", "Please contact our system administrators. We have identified "
+								   "an error in your account that must be resolved first."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            bool GoodPassword = AuthService()->SetSubPassword(Password1,UInfo);
-            if(!GoodPassword) {
-                Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
-                Types::StringPairVec    FormVars{ {"UUID", Id},
-                                                  {"ERROR_TEXT", "You cannot reuse one of your recent passwords."}};
-                AddGlobalVars(FormVars);
-                return SendHTMLFileBack(FormFile,FormVars);
-            }
+			bool GoodPassword = AuthService()->SetSubPassword(Password1, UInfo);
+			if (!GoodPassword) {
+				Poco::File FormFile{Daemon()->AssetDir() + "/sub_signup_verification_error.html"};
+				Types::StringPairVec FormVars{
+					{"UUID", Id}, {"ERROR_TEXT", "You cannot reuse one of your recent passwords."}};
+				AddGlobalVars(FormVars);
+				return SendHTMLFileBack(FormFile, FormVars);
+			}
 
-            UInfo.modified = OpenWifi::Now();
-            UInfo.changePassword = false;
-            UInfo.lastEmailCheck = OpenWifi::Now();
-            UInfo.waitingForEmailCheck = false;
-            UInfo.validated = OpenWifi::Now();
+			UInfo.modified = OpenWifi::Now();
+			UInfo.changePassword = false;
+			UInfo.lastEmailCheck = OpenWifi::Now();
+			UInfo.waitingForEmailCheck = false;
+			UInfo.validated = OpenWifi::Now();
 
-            StorageService()->SubDB().UpdateUserInfo(UInfo.email,Link.userId,UInfo);
+			StorageService()->SubDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
 
-            Poco::File  FormFile{ Daemon()->AssetDir() + "/sub_signup_verification_success.html"};
-            Types::StringPairVec    FormVars{ {"UUID", Id},
-                                              {"USERNAME", UInfo.email} };
-            StorageService()->ActionLinksDB().CompleteAction(Id);
+			Poco::File FormFile{Daemon()->AssetDir() + "/sub_signup_verification_success.html"};
+			Types::StringPairVec FormVars{{"UUID", Id}, {"USERNAME", UInfo.email}};
+			StorageService()->ActionLinksDB().CompleteAction(Id);
 
-            //  Send the update to the provisioning service
-            Poco::JSON::Object  Body;
-            auto RawSignup = Poco::StringTokenizer(UInfo.signingUp,":");
-            Body.set("signupUUID", RawSignup.count()==1 ? UInfo.signingUp : RawSignup[1]);
-            OpenAPIRequestPut   ProvRequest(uSERVICE_PROVISIONING,"/api/v1/signup",
-                                            {
-                                                {"signupUUID", RawSignup.count()==1 ? UInfo.signingUp : RawSignup[1]} ,
-                                                {"operation", "emailVerified"}
-                                            },
-                                            Body,30000);
-            Logger().information(fmt::format("({}): Completed subscriber e-mail verification and password.",UInfo.email));
-            Poco::JSON::Object::Ptr Response;
-            auto Status = ProvRequest.Do(Response);
-            std::stringstream ooo;
-            if(Response!= nullptr)
-                Response->stringify(ooo);
-            Logger().information(fmt::format("({}): Completed subscriber e-mail verification. Provisioning notified, Error={}.",
-                                             UInfo.email, Status));
-            AddGlobalVars(FormVars);
-            SendHTMLFileBack(FormFile,FormVars);
-            Logger().information(fmt::format("({}): Completed subscriber e-mail verification. FORM notified.",UInfo.email));
-        } else {
-            DoReturnA404();
-        }
-    }
+			//  Send the update to the provisioning service
+			Poco::JSON::Object Body;
+			auto RawSignup = Poco::StringTokenizer(UInfo.signingUp, ":");
+			Body.set("signupUUID", RawSignup.count() == 1 ? UInfo.signingUp : RawSignup[1]);
+			OpenAPIRequestPut ProvRequest(
+				uSERVICE_PROVISIONING, "/api/v1/signup",
+				{{"signupUUID", RawSignup.count() == 1 ? UInfo.signingUp : RawSignup[1]},
+				 {"operation", "emailVerified"}},
+				Body, 30000);
+			Logger().information(fmt::format(
+				"({}): Completed subscriber e-mail verification and password.", UInfo.email));
+			Poco::JSON::Object::Ptr Response;
+			auto Status = ProvRequest.Do(Response);
+			std::stringstream ooo;
+			if (Response != nullptr)
+				Response->stringify(ooo);
+			Logger().information(fmt::format(
+				"({}): Completed subscriber e-mail verification. Provisioning notified, Error={}.",
+				UInfo.email, Status));
+			AddGlobalVars(FormVars);
+			SendHTMLFileBack(FormFile, FormVars);
+			Logger().information(fmt::format(
+				"({}): Completed subscriber e-mail verification. FORM notified.", UInfo.email));
+		} else {
+			DoReturnA404();
+		}
+	}
 
-    void RESTAPI_action_links::DoEmailVerification(SecurityObjects::ActionLink &Link) {
-        auto now = OpenWifi::Now();
+	void RESTAPI_action_links::DoEmailVerification(SecurityObjects::ActionLink &Link) {
+		auto now = OpenWifi::Now();
 
-        if(now > Link.expires) {
-            StorageService()->ActionLinksDB().CancelAction(Link.id);
-            return DoReturnA404();
-        }
+		if (now > Link.expires) {
+			StorageService()->ActionLinksDB().CancelAction(Link.id);
+			return DoReturnA404();
+		}
 
-        SecurityObjects::UserInfo UInfo;
-        bool Found = Link.userAction ? StorageService()->UserDB().GetUserById(Link.userId,UInfo) : StorageService()->SubDB().GetUserById(Link.userId,UInfo);
-        if (!Found) {
-            Types::StringPairVec FormVars{{"UUID",       Link.id},
-                                          {"ERROR_TEXT", "This does not appear to be a valid email verification link.."}};
-            Poco::File FormFile{Daemon()->AssetDir() + "/email_verification_error.html"};
-            AddGlobalVars(FormVars);
-            return SendHTMLFileBack(FormFile, FormVars);
-        }
+		SecurityObjects::UserInfo UInfo;
+		bool Found = Link.userAction ? StorageService()->UserDB().GetUserById(Link.userId, UInfo)
+									 : StorageService()->SubDB().GetUserById(Link.userId, UInfo);
+		if (!Found) {
+			Types::StringPairVec FormVars{
+				{"UUID", Link.id},
+				{"ERROR_TEXT", "This does not appear to be a valid email verification link.."}};
+			Poco::File FormFile{Daemon()->AssetDir() + "/email_verification_error.html"};
+			AddGlobalVars(FormVars);
+			return SendHTMLFileBack(FormFile, FormVars);
+		}
 
-        Logger_.information(fmt::format("EMAIL-VERIFICATION(%s): For ID={}", Request->clientAddress().toString(),
-                                        UInfo.email));
-        UInfo.waitingForEmailCheck = false;
-        UInfo.validated = true;
-        UInfo.lastEmailCheck = OpenWifi::Now();
-        UInfo.validationDate = OpenWifi::Now();
-        UInfo.modified  = OpenWifi::Now();
-        if(Link.userAction)
-            StorageService()->UserDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
-        else
-            StorageService()->SubDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
-        Types::StringPairVec FormVars{{"UUID",     Link.id},
-                                      {"USERNAME", UInfo.email},
-                                      {"ACTION_LINK",MicroService::instance().GetUIURI()}};
-        Poco::File FormFile{Daemon()->AssetDir() + "/email_verification_success.html"};
-        AddGlobalVars(FormVars);
-        StorageService()->ActionLinksDB().CompleteAction(Link.id);
-        SendHTMLFileBack(FormFile, FormVars);
-    }
+		Logger_.information(fmt::format("EMAIL-VERIFICATION(%s): For ID={}",
+										Request->clientAddress().toString(), UInfo.email));
+		UInfo.waitingForEmailCheck = false;
+		UInfo.validated = true;
+		UInfo.lastEmailCheck = OpenWifi::Now();
+		UInfo.validationDate = OpenWifi::Now();
+		UInfo.modified = OpenWifi::Now();
+		if (Link.userAction)
+			StorageService()->UserDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
+		else
+			StorageService()->SubDB().UpdateUserInfo(UInfo.email, Link.userId, UInfo);
+		Types::StringPairVec FormVars{{"UUID", Link.id},
+									  {"USERNAME", UInfo.email},
+									  {"ACTION_LINK", MicroService::instance().GetUIURI()}};
+		Poco::File FormFile{Daemon()->AssetDir() + "/email_verification_success.html"};
+		AddGlobalVars(FormVars);
+		StorageService()->ActionLinksDB().CompleteAction(Link.id);
+		SendHTMLFileBack(FormFile, FormVars);
+	}
 
-    void RESTAPI_action_links::DoReturnA404() {
-        Types::StringPairVec FormVars;
-        Poco::File FormFile{Daemon()->AssetDir() + "/404_error.html"};
-        AddGlobalVars(FormVars);
-        SendHTMLFileBack(FormFile, FormVars);
-    }
+	void RESTAPI_action_links::DoReturnA404() {
+		Types::StringPairVec FormVars;
+		Poco::File FormFile{Daemon()->AssetDir() + "/404_error.html"};
+		AddGlobalVars(FormVars);
+		SendHTMLFileBack(FormFile, FormVars);
+	}
 
-    void RESTAPI_action_links::CompleteEmailInvitation() {
-        /// TODO:
-    }
+	void RESTAPI_action_links::CompleteEmailInvitation() {
+		/// TODO:
+	}
 
-    void RESTAPI_action_links::RequestSubResetPassword([[maybe_unused]] SecurityObjects::ActionLink &Link) {
+	void RESTAPI_action_links::RequestSubResetPassword(
+		[[maybe_unused]] SecurityObjects::ActionLink &Link) {}
 
-    }
+	void RESTAPI_action_links::DoSubEmailVerification(
+		[[maybe_unused]] SecurityObjects::ActionLink &Link) {}
 
-    void RESTAPI_action_links::DoSubEmailVerification([[maybe_unused]] SecurityObjects::ActionLink &Link) {
-
-    }
-
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_action_links.h

@@ -7,34 +7,32 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_action_links : public RESTAPIHandler {
-    public:
-        RESTAPI_action_links(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-             std::vector<std::string>{
-                                        Poco::Net::HTTPRequest::HTTP_GET,
-                                        Poco::Net::HTTPRequest::HTTP_POST,
-                                        Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                        Server,
-                                        TransactionId,
-                                        Internal,
-                                        false,
-                                        true, RateLimit{.Interval=1000,.MaxCalls=10}) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/actionLink"}; };
-        void RequestResetPassword(SecurityObjects::ActionLink &Link);
-        void RequestSubResetPassword(SecurityObjects::ActionLink &Link);
-        void CompleteResetPassword();
-        void CompleteSubVerification();
-        void DoEmailVerification(SecurityObjects::ActionLink &Link);
-        void DoSubEmailVerification(SecurityObjects::ActionLink &Link);
-        void DoReturnA404();
-        void DoNewSubVerification(SecurityObjects::ActionLink &Link);
-        void CompleteEmailInvitation();
-        static void AddGlobalVars(Types::StringPairVec & Vars);
+	class RESTAPI_action_links : public RESTAPIHandler {
+	  public:
+		RESTAPI_action_links(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							 RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							 bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal, false, true,
+							 RateLimit{.Interval = 1000, .MaxCalls = 10}) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/actionLink"}; };
+		void RequestResetPassword(SecurityObjects::ActionLink &Link);
+		void RequestSubResetPassword(SecurityObjects::ActionLink &Link);
+		void CompleteResetPassword();
+		void CompleteSubVerification();
+		void DoEmailVerification(SecurityObjects::ActionLink &Link);
+		void DoSubEmailVerification(SecurityObjects::ActionLink &Link);
+		void DoReturnA404();
+		void DoNewSubVerification(SecurityObjects::ActionLink &Link);
+		void CompleteEmailInvitation();
+		static void AddGlobalVars(Types::StringPairVec &Vars);
 
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_apiKey_handler.cpp

@@ -7,152 +7,159 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_apiKey_handler::DoGet() {
-        std::string     user_uuid = GetBinding("uuid","");
-        if(user_uuid.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        if(user_uuid!=UserInfo_.userinfo.id && UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+	void RESTAPI_apiKey_handler::DoGet() {
+		std::string user_uuid = GetBinding("uuid", "");
+		if (user_uuid.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		if (user_uuid != UserInfo_.userinfo.id &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        SecurityObjects::ApiKeyEntryList    List;
-        if(DB_.GetRecords(0,500, List.apiKeys, fmt::format(" userUuid='{}' ", user_uuid))) {
-            for(auto &key:List.apiKeys) {
-                Sanitize(UserInfo_, key);
-            }
-            Poco::JSON::Object  Answer;
-            List.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-        return NotFound();
-    }
+		SecurityObjects::ApiKeyEntryList List;
+		if (DB_.GetRecords(0, 500, List.apiKeys, fmt::format(" userUuid='{}' ", user_uuid))) {
+			for (auto &key : List.apiKeys) {
+				Sanitize(UserInfo_, key);
+			}
+			Poco::JSON::Object Answer;
+			List.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+		return NotFound();
+	}
 
-    void RESTAPI_apiKey_handler::DoDelete() {
-        std::string     user_uuid = GetBinding("uuid","");
-        if(user_uuid.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+	void RESTAPI_apiKey_handler::DoDelete() {
+		std::string user_uuid = GetBinding("uuid", "");
+		if (user_uuid.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        if(user_uuid!=UserInfo_.userinfo.id && UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (user_uuid != UserInfo_.userinfo.id &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(user_uuid!=UserInfo_.userinfo.id) {
-            if(!StorageService()->UserDB().Exists("id",user_uuid)) {
-                return NotFound();
-            }
-        }
+		if (user_uuid != UserInfo_.userinfo.id) {
+			if (!StorageService()->UserDB().Exists("id", user_uuid)) {
+				return NotFound();
+			}
+		}
 
-        std::string ApiKeyId= GetParameter("keyUuid","");
-        if(ApiKeyId.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		std::string ApiKeyId = GetParameter("keyUuid", "");
+		if (ApiKeyId.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        SecurityObjects::ApiKeyEntry    ApiKey;
-        if(StorageService()->ApiKeyDB().GetRecord("id",ApiKeyId,ApiKey)) {
-            if(ApiKey.userUuid==user_uuid) {
-                AuthService()->RemoveTokenSystemWide(ApiKey.apiKey);
-                DB_.DeleteRecord("id", ApiKeyId);
-                return OK();
-            }
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        return NotFound();
-    }
+		SecurityObjects::ApiKeyEntry ApiKey;
+		if (StorageService()->ApiKeyDB().GetRecord("id", ApiKeyId, ApiKey)) {
+			if (ApiKey.userUuid == user_uuid) {
+				AuthService()->RemoveTokenSystemWide(ApiKey.apiKey);
+				DB_.DeleteRecord("id", ApiKeyId);
+				return OK();
+			}
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		return NotFound();
+	}
 
-    void RESTAPI_apiKey_handler::DoPost() {
-        std::string     user_uuid = GetBinding("uuid","");
+	void RESTAPI_apiKey_handler::DoPost() {
+		std::string user_uuid = GetBinding("uuid", "");
 
-        if(user_uuid.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		if (user_uuid.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        if(user_uuid!=UserInfo_.userinfo.id && UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (user_uuid != UserInfo_.userinfo.id &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(user_uuid!=UserInfo_.userinfo.id) {
-            //  Must verify if the user exists
-            if(!StorageService()->UserDB().Exists("id",user_uuid)) {
-                return BadRequest(RESTAPI::Errors::UserMustExist);
-            }
-        }
+		if (user_uuid != UserInfo_.userinfo.id) {
+			//  Must verify if the user exists
+			if (!StorageService()->UserDB().Exists("id", user_uuid)) {
+				return BadRequest(RESTAPI::Errors::UserMustExist);
+			}
+		}
 
-        SecurityObjects::ApiKeyEntry    NewKey;
-        if(!NewKey.from_json(ParsedBody_)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
-        NewKey.lastUse = 0 ;
+		SecurityObjects::ApiKeyEntry NewKey;
+		if (!NewKey.from_json(ParsedBody_)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
+		NewKey.lastUse = 0;
 
-        if(!Utils::IsAlphaNumeric(NewKey.name) || NewKey.name.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		if (!Utils::IsAlphaNumeric(NewKey.name) || NewKey.name.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        Poco::toLowerInPlace(NewKey.name);
-        NewKey.userUuid = user_uuid;
-        if(NewKey.expiresOn < Utils::Now()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		Poco::toLowerInPlace(NewKey.name);
+		NewKey.userUuid = user_uuid;
+		if (NewKey.expiresOn < Utils::Now()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        //  does a key of that name already exit for this user?
-        SecurityObjects::ApiKeyEntryList    ExistingList;
-        if(DB_.GetRecords(0,500, ExistingList.apiKeys, fmt::format(" userUuid='{}' ", user_uuid))) {
-            if(std::find_if(ExistingList.apiKeys.begin(),ExistingList.apiKeys.end(), [NewKey](const SecurityObjects::ApiKeyEntry &E) -> bool {
-                return E.name==NewKey.name;
-            })!=ExistingList.apiKeys.end()) {
-                return BadRequest(RESTAPI::Errors::ApiKeyNameAlreadyExists);
-            }
-        }
+		//  does a key of that name already exit for this user?
+		SecurityObjects::ApiKeyEntryList ExistingList;
+		if (DB_.GetRecords(0, 500, ExistingList.apiKeys,
+						   fmt::format(" userUuid='{}' ", user_uuid))) {
+			if (std::find_if(ExistingList.apiKeys.begin(), ExistingList.apiKeys.end(),
+							 [NewKey](const SecurityObjects::ApiKeyEntry &E) -> bool {
+								 return E.name == NewKey.name;
+							 }) != ExistingList.apiKeys.end()) {
+				return BadRequest(RESTAPI::Errors::ApiKeyNameAlreadyExists);
+			}
+		}
 
-        if(ExistingList.apiKeys.size()>=10) {
-            return BadRequest(RESTAPI::Errors::TooManyApiKeys);
-        }
+		if (ExistingList.apiKeys.size() >= 10) {
+			return BadRequest(RESTAPI::Errors::TooManyApiKeys);
+		}
 
-        NewKey.id = MicroServiceCreateUUID();
-        NewKey.userUuid = user_uuid;
-        NewKey.salt = std::to_string(Utils::Now());
-        NewKey.apiKey = Utils::ComputeHash(NewKey.salt, UserInfo_.userinfo.id, UserInfo_.webtoken.access_token_ );
-        NewKey.created = Utils::Now();
+		NewKey.id = MicroServiceCreateUUID();
+		NewKey.userUuid = user_uuid;
+		NewKey.salt = std::to_string(Utils::Now());
+		NewKey.apiKey = Utils::ComputeHash(NewKey.salt, UserInfo_.userinfo.id,
+										   UserInfo_.webtoken.access_token_);
+		NewKey.created = Utils::Now();
 
-        if(DB_.CreateRecord(NewKey)) {
-            Poco::JSON::Object  Answer;
-            NewKey.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-        return BadRequest(RESTAPI::Errors::RecordNotCreated);
-    }
+		if (DB_.CreateRecord(NewKey)) {
+			Poco::JSON::Object Answer;
+			NewKey.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+		return BadRequest(RESTAPI::Errors::RecordNotCreated);
+	}
 
-    void RESTAPI_apiKey_handler::DoPut() {
-        std::string     user_uuid = GetBinding("uuid","");
-        if(user_uuid.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        if(user_uuid!=UserInfo_.userinfo.id && UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
-        SecurityObjects::ApiKeyEntry    NewKey;
-        if(!NewKey.from_json(ParsedBody_)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+	void RESTAPI_apiKey_handler::DoPut() {
+		std::string user_uuid = GetBinding("uuid", "");
+		if (user_uuid.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		if (user_uuid != UserInfo_.userinfo.id &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
+		SecurityObjects::ApiKeyEntry NewKey;
+		if (!NewKey.from_json(ParsedBody_)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        SecurityObjects::ApiKeyEntry    ExistingKey;
-        if(!DB_.GetRecord("id",NewKey.id,ExistingKey)) {
-            return BadRequest(RESTAPI::Errors::ApiKeyDoesNotExist);
-        }
+		SecurityObjects::ApiKeyEntry ExistingKey;
+		if (!DB_.GetRecord("id", NewKey.id, ExistingKey)) {
+			return BadRequest(RESTAPI::Errors::ApiKeyDoesNotExist);
+		}
 
-        if(ExistingKey.userUuid!=user_uuid) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+		if (ExistingKey.userUuid != user_uuid) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        AssignIfPresent(ParsedBody_,"description",ExistingKey.description);
+		AssignIfPresent(ParsedBody_, "description", ExistingKey.description);
 
-        if(DB_.UpdateRecord("id",ExistingKey.id,ExistingKey)) {
-            Poco::JSON::Object  Answer;
-            ExistingKey.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-        BadRequest(RESTAPI::Errors::RecordNotUpdated);
-    }
+		if (DB_.UpdateRecord("id", ExistingKey.id, ExistingKey)) {
+			Poco::JSON::Object Answer;
+			ExistingKey.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+		BadRequest(RESTAPI::Errors::RecordNotUpdated);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_apiKey_handler.h

@@ -4,31 +4,29 @@
 
 #pragma once
 
-#include "framework/RESTAPI_Handler.h"
 #include "StorageService.h"
+#include "framework/RESTAPI_Handler.h"
 namespace OpenWifi {
-    class RESTAPI_apiKey_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_apiKey_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>{
-                                         Poco::Net::HTTPRequest::HTTP_GET,
-                                         Poco::Net::HTTPRequest::HTTP_PUT,
-                                         Poco::Net::HTTPRequest::HTTP_POST,
-                                         Poco::Net::HTTPRequest::HTTP_DELETE,
-                                         Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                 Server,
-                                 TransactionId,
-                                 Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/apiKey/{uuid}"}; };
-    private:
-        ApiKeyDB     &DB_=StorageService()->ApiKeyDB();
+	class RESTAPI_apiKey_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_apiKey_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/apiKey/{uuid}"}; };
 
-        void DoGet() final;
-        void DoPut() final;
-        void DoPost() final;
-        void DoDelete() final;
-
-    };
-}
+	  private:
+		ApiKeyDB &DB_ = StorageService()->ApiKeyDB();
 
+		void DoGet() final;
+		void DoPut() final;
+		void DoPost() final;
+		void DoDelete() final;
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_asset_server.cpp

@@ -3,23 +3,23 @@
 //
 
 #include "RESTAPI_asset_server.h"
+#include "Daemon.h"
 #include "Poco/File.h"
 #include "framework/ow_constants.h"
-#include "Daemon.h"
 
 namespace OpenWifi {
-    void RESTAPI_asset_server::DoGet() {
-        Poco::File  AssetFile;
+	void RESTAPI_asset_server::DoGet() {
+		Poco::File AssetFile;
 
-        if(Request->getURI().find("/favicon.ico") != std::string::npos) {
-            AssetFile = Daemon()->AssetDir() + "/favicon.ico";
-        } else {
-            std::string AssetName = GetBinding(RESTAPI::Protocol::ID, "");
-            AssetFile = Daemon()->AssetDir() + "/" + AssetName;
-        }
-        if(!AssetFile.isFile()) {
-            return NotFound();
-        }
-        SendFile(AssetFile);
-    }
-}
+		if (Request->getURI().find("/favicon.ico") != std::string::npos) {
+			AssetFile = Daemon()->AssetDir() + "/favicon.ico";
+		} else {
+			std::string AssetName = GetBinding(RESTAPI::Protocol::ID, "");
+			AssetFile = Daemon()->AssetDir() + "/" + AssetName;
+		}
+		if (!AssetFile.isFile()) {
+			return NotFound();
+		}
+		SendFile(AssetFile);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_asset_server.h

@@ -7,28 +7,26 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_asset_server : public RESTAPIHandler {
-    public:
-        RESTAPI_asset_server(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {Poco::Net::HTTPRequest::HTTP_POST,
-                                          Poco::Net::HTTPRequest::HTTP_GET,
-                                          Poco::Net::HTTPRequest::HTTP_PUT,
-                                          Poco::Net::HTTPRequest::HTTP_DELETE,
-                                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                          Server,
-                                          TransactionId,
-                                          Internal, false) {}
-        static auto PathName() { return std::list<std::string>{"/wwwassets/{id}" ,
-                                                                                         "/favicon.ico"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-
-    private:
-
-    };
-}
+	class RESTAPI_asset_server : public RESTAPIHandler {
+	  public:
+		RESTAPI_asset_server(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							 RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							 bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal, false) {}
+		static auto PathName() {
+			return std::list<std::string>{"/wwwassets/{id}", "/favicon.ico"};
+		};
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
 
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_avatar_handler.cpp

@@ -5,79 +5,85 @@
 #include <fstream>
 #include <iostream>
 
+#include "Poco/CountingStream.h"
+#include "Poco/Net/HTMLForm.h"
 #include "RESTAPI_avatar_handler.h"
 #include "StorageService.h"
-#include "Poco/Net/HTMLForm.h"
-#include "Poco/CountingStream.h"
 #include "framework/MicroServiceFuncs.h"
 
 namespace OpenWifi {
 
-    void AvatarPartHandler::handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream) {
-        FileType_ = Header.get(RESTAPI::Protocol::CONTENTTYPE, RESTAPI::Protocol::UNSPECIFIED);
-        if (Header.has(RESTAPI::Protocol::CONTENTDISPOSITION)) {
-            std::string Disposition;
-            Poco::Net::NameValueCollection Parameters;
-            Poco::Net::MessageHeader::splitParameters(Header[RESTAPI::Protocol::CONTENTDISPOSITION], Disposition, Parameters);
-            Name_ = Parameters.get(RESTAPI::Protocol::NAME, RESTAPI::Protocol::UNNAMED);
-        }
-        Poco::CountingInputStream InputStream(Stream);
-        Poco::StreamCopier::copyStream(InputStream, OutputStream_);
-        Length_ = OutputStream_.str().size();
-    };
+	void AvatarPartHandler::handlePart(const Poco::Net::MessageHeader &Header,
+									   std::istream &Stream) {
+		FileType_ = Header.get(RESTAPI::Protocol::CONTENTTYPE, RESTAPI::Protocol::UNSPECIFIED);
+		if (Header.has(RESTAPI::Protocol::CONTENTDISPOSITION)) {
+			std::string Disposition;
+			Poco::Net::NameValueCollection Parameters;
+			Poco::Net::MessageHeader::splitParameters(Header[RESTAPI::Protocol::CONTENTDISPOSITION],
+													  Disposition, Parameters);
+			Name_ = Parameters.get(RESTAPI::Protocol::NAME, RESTAPI::Protocol::UNNAMED);
+		}
+		Poco::CountingInputStream InputStream(Stream);
+		Poco::StreamCopier::copyStream(InputStream, OutputStream_);
+		Length_ = OutputStream_.str().size();
+	};
 
-    void RESTAPI_avatar_handler::DoPost() {
-        std::string Id = UserInfo_.userinfo.id;
-        SecurityObjects::UserInfo UInfo;
+	void RESTAPI_avatar_handler::DoPost() {
+		std::string Id = UserInfo_.userinfo.id;
+		SecurityObjects::UserInfo UInfo;
 
-        std::stringstream SS;
-        AvatarPartHandler partHandler(Id, Logger_, SS);
-        Poco::Net::HTMLForm form(*Request, Request->stream(), partHandler);
-        Poco::JSON::Object Answer;
+		std::stringstream SS;
+		AvatarPartHandler partHandler(Id, Logger_, SS);
+		Poco::Net::HTMLForm form(*Request, Request->stream(), partHandler);
+		Poco::JSON::Object Answer;
 
-        if (!partHandler.Name().empty() && partHandler.Length()< MicroServiceConfigGetInt("openwifi.avatar.maxsize",2000000)) {
-            Answer.set(RESTAPI::Protocol::AVATARID, Id);
-            Answer.set(RESTAPI::Protocol::ERRORCODE, 0);
-            Logger_.information(fmt::format("Uploaded avatar: {} Type: {}", partHandler.Name(), partHandler.ContentType()));
-            StorageService()->AvatarDB().SetAvatar(UserInfo_.userinfo.email,
-                                 Id, SS.str(), partHandler.ContentType(), partHandler.Name());
-            StorageService()->UserDB().SetAvatar(Id,"1");
-            Logger().information(fmt::format("Adding avatar for {}",UserInfo_.userinfo.email));
-        } else {
-            Answer.set(RESTAPI::Protocol::AVATARID, Id);
-            Answer.set(RESTAPI::Protocol::ERRORCODE, 13);
-            Answer.set(RESTAPI::Protocol::ERRORTEXT, "Avatar upload could not complete.");
-        }
-        ReturnObject(Answer);
-    }
+		if (!partHandler.Name().empty() &&
+			partHandler.Length() < MicroServiceConfigGetInt("openwifi.avatar.maxsize", 2000000)) {
+			Answer.set(RESTAPI::Protocol::AVATARID, Id);
+			Answer.set(RESTAPI::Protocol::ERRORCODE, 0);
+			Logger_.information(fmt::format("Uploaded avatar: {} Type: {}", partHandler.Name(),
+											partHandler.ContentType()));
+			StorageService()->AvatarDB().SetAvatar(UserInfo_.userinfo.email, Id, SS.str(),
+												   partHandler.ContentType(), partHandler.Name());
+			StorageService()->UserDB().SetAvatar(Id, "1");
+			Logger().information(fmt::format("Adding avatar for {}", UserInfo_.userinfo.email));
+		} else {
+			Answer.set(RESTAPI::Protocol::AVATARID, Id);
+			Answer.set(RESTAPI::Protocol::ERRORCODE, 13);
+			Answer.set(RESTAPI::Protocol::ERRORTEXT, "Avatar upload could not complete.");
+		}
+		ReturnObject(Answer);
+	}
 
-    void RESTAPI_avatar_handler::DoGet() {
-        std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
-        if (Id.empty()) {
-            return NotFound();
-        }
+	void RESTAPI_avatar_handler::DoGet() {
+		std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
+		if (Id.empty()) {
+			return NotFound();
+		}
 
-        std::string Type, Name, AvatarContent;
-        if (!StorageService()->AvatarDB().GetAvatar(UserInfo_.userinfo.email, Id, AvatarContent, Type, Name)) {
-            return NotFound();
-        }
-        Logger().information(fmt::format("Retrieving avatar for {}, size:{}",UserInfo_.userinfo.email,AvatarContent.size()));
-        return SendFileContent(AvatarContent, Type, Name);
-    }
+		std::string Type, Name, AvatarContent;
+		if (!StorageService()->AvatarDB().GetAvatar(UserInfo_.userinfo.email, Id, AvatarContent,
+													Type, Name)) {
+			return NotFound();
+		}
+		Logger().information(fmt::format("Retrieving avatar for {}, size:{}",
+										 UserInfo_.userinfo.email, AvatarContent.size()));
+		return SendFileContent(AvatarContent, Type, Name);
+	}
 
-    void RESTAPI_avatar_handler::DoDelete() {
-        std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
+	void RESTAPI_avatar_handler::DoDelete() {
+		std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
 
-        if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && Id!=UserInfo_.userinfo.id) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT && Id != UserInfo_.userinfo.id) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if (!StorageService()->AvatarDB().DeleteAvatar(UserInfo_.userinfo.email, Id)) {
-            return NotFound();
-        }
+		if (!StorageService()->AvatarDB().DeleteAvatar(UserInfo_.userinfo.email, Id)) {
+			return NotFound();
+		}
 
-        Logger().information(fmt::format("Deleted avatar for {}",UserInfo_.userinfo.email));
-        StorageService()->UserDB().SetAvatar(Id,"");
-        OK();
-    }
-}
+		Logger().information(fmt::format("Deleted avatar for {}", UserInfo_.userinfo.email));
+		StorageService()->UserDB().SetAvatar(Id, "");
+		OK();
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_avatar_handler.h

@@ -3,51 +3,47 @@
 //
 #pragma once
 
-#include "framework/RESTAPI_Handler.h"
 #include "Poco/Net/PartHandler.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 
-    class AvatarPartHandler : public Poco::Net::PartHandler {
-    public:
-        AvatarPartHandler(std::string Id, Poco::Logger &Logger, std::stringstream & ofs) :
-                Id_(std::move(Id)),
-                Logger_(Logger),
-                OutputStream_(ofs){
-        }
-        void handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream);
-        [[nodiscard]] uint64_t Length() const { return Length_; }
-        [[nodiscard]] std::string &Name() { return Name_; }
-        [[nodiscard]] std::string &ContentType() { return FileType_; }
+	class AvatarPartHandler : public Poco::Net::PartHandler {
+	  public:
+		AvatarPartHandler(std::string Id, Poco::Logger &Logger, std::stringstream &ofs)
+			: Id_(std::move(Id)), Logger_(Logger), OutputStream_(ofs) {}
+		void handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream);
+		[[nodiscard]] uint64_t Length() const { return Length_; }
+		[[nodiscard]] std::string &Name() { return Name_; }
+		[[nodiscard]] std::string &ContentType() { return FileType_; }
 
-    private:
-        uint64_t        Length_ = 0;
-        std::string     FileType_;
-        std::string     Name_;
-        std::string     Id_;
-        Poco::Logger    &Logger_;
-        std::stringstream &OutputStream_;
+	  private:
+		uint64_t Length_ = 0;
+		std::string FileType_;
+		std::string Name_;
+		std::string Id_;
+		Poco::Logger &Logger_;
+		std::stringstream &OutputStream_;
 
-        inline Poco::Logger & Logger() { return Logger_; };
-    };
+		inline Poco::Logger &Logger() { return Logger_; };
+	};
 
-    class RESTAPI_avatar_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_avatar_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>{
-                                         Poco::Net::HTTPRequest::HTTP_GET,
-                                         Poco::Net::HTTPRequest::HTTP_POST,
-                                         Poco::Net::HTTPRequest::HTTP_DELETE,
-                                         Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                         Server,
-                                         TransactionId,
-                                         Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/avatar/{id}"}; };
+	class RESTAPI_avatar_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_avatar_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/avatar/{id}"}; };
 
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final;
-        void DoPut() final {};
-    };
-}
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final;
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_db_helpers.h

@@ -8,13 +8,15 @@
 
 namespace OpenWifi {
 
-    inline void Sanitize([[maybe_unused]] const SecurityObjects::UserInfoAndPolicy &User, SecurityObjects::UserInfo & U) {
-        U.currentPassword.clear();
-        U.lastPasswords.clear();
-        U.oauthType.clear();
-    }
+	inline void Sanitize([[maybe_unused]] const SecurityObjects::UserInfoAndPolicy &User,
+						 SecurityObjects::UserInfo &U) {
+		U.currentPassword.clear();
+		U.lastPasswords.clear();
+		U.oauthType.clear();
+	}
 
-    inline void Sanitize([[maybe_unused]] const SecurityObjects::UserInfoAndPolicy &User, SecurityObjects::ApiKeyEntry & U) {
-        U.salt.clear();
-    }
-}
+	inline void Sanitize([[maybe_unused]] const SecurityObjects::UserInfoAndPolicy &User,
+						 SecurityObjects::ApiKeyEntry &U) {
+		U.salt.clear();
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_email_handler.cpp

@@ -9,26 +9,23 @@
 #include "framework/ow_constants.h"
 
 namespace OpenWifi {
-    void RESTAPI_email_handler::DoPost() {
-        const auto & Obj = ParsedBody_;
-        if (Obj->has("subject") &&
-            Obj->has("from") &&
-            Obj->has("text") &&
-            Obj->has("recipients") &&
-            Obj->isArray("recipients")) {
+	void RESTAPI_email_handler::DoPost() {
+		const auto &Obj = ParsedBody_;
+		if (Obj->has("subject") && Obj->has("from") && Obj->has("text") && Obj->has("recipients") &&
+			Obj->isArray("recipients")) {
 
-            Poco::JSON::Array::Ptr Recipients = Obj->getArray("recipients");
-            auto Recipient = Recipients->get(0).toString();
-            MessageAttributes Attrs;
-            Attrs[RECIPIENT_EMAIL] = Recipient;
-            Attrs[SUBJECT] = Obj->get("subject").toString();
-            Attrs[TEXT] = Obj->get("text").toString();
-            Attrs[SENDER] = Obj->get("from").toString();
-            if(SMTPMailerService()->SendMessage(Recipient, "password_reset.txt", Attrs, false)) {
-                return OK();
-            }
-            return ReturnStatus(Poco::Net::HTTPResponse::HTTP_SERVICE_UNAVAILABLE);
-        }
-        BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-    }
-}
+			Poco::JSON::Array::Ptr Recipients = Obj->getArray("recipients");
+			auto Recipient = Recipients->get(0).toString();
+			MessageAttributes Attrs;
+			Attrs[RECIPIENT_EMAIL] = Recipient;
+			Attrs[SUBJECT] = Obj->get("subject").toString();
+			Attrs[TEXT] = Obj->get("text").toString();
+			Attrs[SENDER] = Obj->get("from").toString();
+			if (SMTPMailerService()->SendMessage(Recipient, "password_reset.txt", Attrs, false)) {
+				return OK();
+			}
+			return ReturnStatus(Poco::Net::HTTPResponse::HTTP_SERVICE_UNAVAILABLE);
+		}
+		BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_email_handler.h

@@ -7,19 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_email_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_email_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
-                                                  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                                  Server,
-                                                  TransactionId,
-                                                  Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/email"};}
-        void DoGet() final {};
-        void DoPost() final;
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
+	class RESTAPI_email_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_email_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							  RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							  bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/email"}; }
+		void DoGet() final{};
+		void DoPost() final;
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_oauth2_handler.cpp

@@ -9,170 +9,176 @@
 #include "Poco/JSON/Parser.h"
 
 #include "AuthService.h"
-#include "RESTAPI_oauth2_handler.h"
 #include "MFAServer.h"
-#include "framework/ow_constants.h"
-#include "framework/MicroService.h"
-#include "StorageService.h"
 #include "RESTAPI_db_helpers.h"
+#include "RESTAPI_oauth2_handler.h"
+#include "StorageService.h"
+#include "framework/MicroService.h"
+#include "framework/ow_constants.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_oauth2_handler::DoGet() {
-        bool Expired = false, Contacted = false;
-        if (!IsAuthorized(Expired, Contacted)) {
-            if (Expired)
-                return UnAuthorized(RESTAPI::Errors::EXPIRED_TOKEN);
-            return UnAuthorized(RESTAPI::Errors::INVALID_TOKEN);
-        }
-        if (GetBoolParameter(RESTAPI::Protocol::ME)) {
-            Logger_.information(fmt::format("REQUEST-ME({}): Request for {}", Request->clientAddress().toString(),
-                                            UserInfo_.userinfo.email));
-            Poco::JSON::Object Me;
-            SecurityObjects::UserInfo ReturnedUser = UserInfo_.userinfo;
-            Sanitize(UserInfo_, ReturnedUser);
-            ReturnedUser.to_json(Me);
-            return ReturnObject(Me);
-        }
-        BadRequest(RESTAPI::Errors::UnrecognizedRequest);
-    }
+	void RESTAPI_oauth2_handler::DoGet() {
+		bool Expired = false, Contacted = false;
+		if (!IsAuthorized(Expired, Contacted)) {
+			if (Expired)
+				return UnAuthorized(RESTAPI::Errors::EXPIRED_TOKEN);
+			return UnAuthorized(RESTAPI::Errors::INVALID_TOKEN);
+		}
+		if (GetBoolParameter(RESTAPI::Protocol::ME)) {
+			Logger_.information(fmt::format("REQUEST-ME({}): Request for {}",
+											Request->clientAddress().toString(),
+											UserInfo_.userinfo.email));
+			Poco::JSON::Object Me;
+			SecurityObjects::UserInfo ReturnedUser = UserInfo_.userinfo;
+			Sanitize(UserInfo_, ReturnedUser);
+			ReturnedUser.to_json(Me);
+			return ReturnObject(Me);
+		}
+		BadRequest(RESTAPI::Errors::UnrecognizedRequest);
+	}
 
-    void RESTAPI_oauth2_handler::DoDelete() {
-        auto Token = GetBinding(RESTAPI::Protocol::TOKEN, "");
-        std::string SessionToken;
-        try {
-            Poco::Net::OAuth20Credentials Auth(*Request);
-            if (Auth.getScheme() == "Bearer") {
-                SessionToken = Auth.getBearerToken();
-            }
-        } catch (const Poco::Exception &E) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        if (Token.empty() || (Token != SessionToken)) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+	void RESTAPI_oauth2_handler::DoDelete() {
+		auto Token = GetBinding(RESTAPI::Protocol::TOKEN, "");
+		std::string SessionToken;
+		try {
+			Poco::Net::OAuth20Credentials Auth(*Request);
+			if (Auth.getScheme() == "Bearer") {
+				SessionToken = Auth.getBearerToken();
+			}
+		} catch (const Poco::Exception &E) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		if (Token.empty() || (Token != SessionToken)) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        AuthService()->Logout(Token);
-        return ReturnStatus(Poco::Net::HTTPResponse::HTTP_NO_CONTENT, true);
-    }
+		AuthService()->Logout(Token);
+		return ReturnStatus(Poco::Net::HTTPResponse::HTTP_NO_CONTENT, true);
+	}
 
 	void RESTAPI_oauth2_handler::DoPost() {
 
-        const auto & Obj = ParsedBody_;
-        if(Obj == nullptr) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		const auto &Obj = ParsedBody_;
+		if (Obj == nullptr) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        auto userId = GetS(RESTAPI::Protocol::USERID, Obj);
-        auto password = GetS(RESTAPI::Protocol::PASSWORD, Obj);
-        auto newPassword = GetS(RESTAPI::Protocol::NEWPASSWORD, Obj);
-        auto refreshToken = GetS("refreshToken", Obj);
-        auto grant_type = GetParameter("grant_type");
+		auto userId = GetS(RESTAPI::Protocol::USERID, Obj);
+		auto password = GetS(RESTAPI::Protocol::PASSWORD, Obj);
+		auto newPassword = GetS(RESTAPI::Protocol::NEWPASSWORD, Obj);
+		auto refreshToken = GetS("refreshToken", Obj);
+		auto grant_type = GetParameter("grant_type");
 
-        Poco::toLowerInPlace(userId);
+		Poco::toLowerInPlace(userId);
 
-        if(!refreshToken.empty() && grant_type == "refresh_token") {
-            SecurityObjects::UserInfoAndPolicy UInfo;
-            if(AuthService()->RefreshUserToken(*Request, refreshToken, UInfo)) {
-                Poco::JSON::Object  Answer;
-                UInfo.webtoken.to_json(Answer);
-                return ReturnObject(Answer);
-            } else {
-                return UnAuthorized(RESTAPI::Errors::CANNOT_REFRESH_TOKEN);
-            }
-        }
+		if (!refreshToken.empty() && grant_type == "refresh_token") {
+			SecurityObjects::UserInfoAndPolicy UInfo;
+			if (AuthService()->RefreshUserToken(*Request, refreshToken, UInfo)) {
+				Poco::JSON::Object Answer;
+				UInfo.webtoken.to_json(Answer);
+				return ReturnObject(Answer);
+			} else {
+				return UnAuthorized(RESTAPI::Errors::CANNOT_REFRESH_TOKEN);
+			}
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::REQUIREMENTS)) {
-            Logger_.information(fmt::format("POLICY-REQUEST({}): Request.", Request->clientAddress().toString()));
-            Poco::JSON::Object  Answer;
-            Answer.set(RESTAPI::Protocol::PASSWORDPATTERN, AuthService()->PasswordValidationExpression());
-            Answer.set(RESTAPI::Protocol::ACCESSPOLICY, AuthService()->GetAccessPolicy());
-            Answer.set(RESTAPI::Protocol::PASSWORDPOLICY, AuthService()->GetPasswordPolicy());
-            return ReturnObject(Answer);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::REQUIREMENTS)) {
+			Logger_.information(
+				fmt::format("POLICY-REQUEST({}): Request.", Request->clientAddress().toString()));
+			Poco::JSON::Object Answer;
+			Answer.set(RESTAPI::Protocol::PASSWORDPATTERN,
+					   AuthService()->PasswordValidationExpression());
+			Answer.set(RESTAPI::Protocol::ACCESSPOLICY, AuthService()->GetAccessPolicy());
+			Answer.set(RESTAPI::Protocol::PASSWORDPOLICY, AuthService()->GetPasswordPolicy());
+			return ReturnObject(Answer);
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::FORGOTPASSWORD)) {
-            SecurityObjects::UserInfo UInfo1;
-            auto UserExists = StorageService()->UserDB().GetUserByEmail(userId,UInfo1);
-            if(UserExists) {
-                Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}", Request->clientAddress().toString(), userId));
-                SecurityObjects::ActionLink NewLink;
+		if (GetBoolParameter(RESTAPI::Protocol::FORGOTPASSWORD)) {
+			SecurityObjects::UserInfo UInfo1;
+			auto UserExists = StorageService()->UserDB().GetUserByEmail(userId, UInfo1);
+			if (UserExists) {
+				Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}",
+												Request->clientAddress().toString(), userId));
+				SecurityObjects::ActionLink NewLink;
 
-                NewLink.action = OpenWifi::SecurityObjects::LinkActions::FORGOT_PASSWORD;
-                NewLink.id = MicroService::CreateUUID();
-                NewLink.userId = UInfo1.id;
-                NewLink.created = OpenWifi::Now();
-                NewLink.expires = NewLink.created + (24*60*60);
-                NewLink.userAction = true;
-                StorageService()->ActionLinksDB().CreateAction(NewLink);
+				NewLink.action = OpenWifi::SecurityObjects::LinkActions::FORGOT_PASSWORD;
+				NewLink.id = MicroService::CreateUUID();
+				NewLink.userId = UInfo1.id;
+				NewLink.created = OpenWifi::Now();
+				NewLink.expires = NewLink.created + (24 * 60 * 60);
+				NewLink.userAction = true;
+				StorageService()->ActionLinksDB().CreateAction(NewLink);
 
-                Poco::JSON::Object ReturnObj;
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                UInfo.webtoken.userMustChangePassword = true;
-                UInfo.webtoken.to_json(ReturnObj);
-                return ReturnObject(ReturnObj);
-            } else {
-                Poco::JSON::Object ReturnObj;
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                UInfo.webtoken.userMustChangePassword = true;
-                UInfo.webtoken.to_json(ReturnObj);
-                return ReturnObject(ReturnObj);
-            }
-        }
+				Poco::JSON::Object ReturnObj;
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				UInfo.webtoken.userMustChangePassword = true;
+				UInfo.webtoken.to_json(ReturnObj);
+				return ReturnObject(ReturnObj);
+			} else {
+				Poco::JSON::Object ReturnObj;
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				UInfo.webtoken.userMustChangePassword = true;
+				UInfo.webtoken.to_json(ReturnObj);
+				return ReturnObject(ReturnObj);
+			}
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::RESENDMFACODE)) {
-            Logger_.information(fmt::format("RESEND-MFA-CODE({}): Request for {}", Request->clientAddress().toString(), userId));
-            if(Obj->has("uuid")) {
-                auto uuid = Obj->get("uuid").toString();
-                if(MFAServer()->ResendCode(uuid))
-                    return OK();
-            }
-            return UnAuthorized(RESTAPI::Errors::BAD_MFA_TRANSACTION);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::RESENDMFACODE)) {
+			Logger_.information(fmt::format("RESEND-MFA-CODE({}): Request for {}",
+											Request->clientAddress().toString(), userId));
+			if (Obj->has("uuid")) {
+				auto uuid = Obj->get("uuid").toString();
+				if (MFAServer()->ResendCode(uuid))
+					return OK();
+			}
+			return UnAuthorized(RESTAPI::Errors::BAD_MFA_TRANSACTION);
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::COMPLETEMFACHALLENGE,false)) {
-            Logger_.information(fmt::format("COMPLETE-MFA-CHALLENGE({}): Request for {}", Request->clientAddress().toString(), userId));
-            if(Obj->has("uuid")) {
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                if(MFAServer()->CompleteMFAChallenge(Obj,UInfo)) {
-                    Poco::JSON::Object ReturnObj;
-                    UInfo.webtoken.to_json(ReturnObj);
-                    return ReturnObject(ReturnObj);
-                }
-            }
-            return UnAuthorized(RESTAPI::Errors::MFA_FAILURE);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::COMPLETEMFACHALLENGE, false)) {
+			Logger_.information(fmt::format("COMPLETE-MFA-CHALLENGE({}): Request for {}",
+											Request->clientAddress().toString(), userId));
+			if (Obj->has("uuid")) {
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				if (MFAServer()->CompleteMFAChallenge(Obj, UInfo)) {
+					Poco::JSON::Object ReturnObj;
+					UInfo.webtoken.to_json(ReturnObj);
+					return ReturnObject(ReturnObj);
+				}
+			}
+			return UnAuthorized(RESTAPI::Errors::MFA_FAILURE);
+		}
 
-        SecurityObjects::UserInfoAndPolicy UInfo;
-        bool Expired=false;
-        auto Code=AuthService()->Authorize(userId, password, newPassword, UInfo, Expired);
-        switch(Code) {
-            case SUCCESS:
-                {
-                    Poco::JSON::Object ReturnObj;
-                    if(AuthService()->RequiresMFA(UInfo)) {
-                        if(MFAServer()->StartMFAChallenge(UInfo, ReturnObj)) {
-                            return ReturnObject(ReturnObj);
-                        }
-                        Logger_.warning("MFA Seems to be broken. Please fix. Disabling MFA checking for now.");
-                    }
-                    UInfo.webtoken.to_json(ReturnObj);
-                    return ReturnObject(ReturnObj);
-                }
-            case INVALID_CREDENTIALS:
-                return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
-            case PASSWORD_INVALID:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_INVALID);
-            case PASSWORD_ALREADY_USED:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_ALREADY_USED);
-            case USERNAME_PENDING_VERIFICATION:
-                return UnAuthorized(RESTAPI::Errors::USERNAME_PENDING_VERIFICATION);
-            case PASSWORD_CHANGE_REQUIRED:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_CHANGE_REQUIRED);
-            case ACCOUNT_SUSPENDED:
-                return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
-            default:
-                return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
-        }
+		SecurityObjects::UserInfoAndPolicy UInfo;
+		bool Expired = false;
+		auto Code = AuthService()->Authorize(userId, password, newPassword, UInfo, Expired);
+		switch (Code) {
+		case SUCCESS: {
+			Poco::JSON::Object ReturnObj;
+			if (AuthService()->RequiresMFA(UInfo)) {
+				if (MFAServer()->StartMFAChallenge(UInfo, ReturnObj)) {
+					return ReturnObject(ReturnObj);
+				}
+				Logger_.warning(
+					"MFA Seems to be broken. Please fix. Disabling MFA checking for now.");
+			}
+			UInfo.webtoken.to_json(ReturnObj);
+			return ReturnObject(ReturnObj);
+		}
+		case INVALID_CREDENTIALS:
+			return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
+		case PASSWORD_INVALID:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_INVALID);
+		case PASSWORD_ALREADY_USED:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_ALREADY_USED);
+		case USERNAME_PENDING_VERIFICATION:
+			return UnAuthorized(RESTAPI::Errors::USERNAME_PENDING_VERIFICATION);
+		case PASSWORD_CHANGE_REQUIRED:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_CHANGE_REQUIRED);
+		case ACCOUNT_SUSPENDED:
+			return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
+		default:
+			return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
+		}
 	}
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_oauth2_handler.h

@@ -12,21 +12,22 @@
 namespace OpenWifi {
 	class RESTAPI_oauth2_handler : public RESTAPIHandler {
 	  public:
-	    RESTAPI_oauth2_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_oauth2_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
 													  Poco::Net::HTTPRequest::HTTP_DELETE,
-                                                      Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-													  Server,
-                                                      TransactionId,
-													  Internal, false, true , RateLimit{.Interval=1000,.MaxCalls=10}) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/oauth2/{token}","/api/v1/oauth2"}; };
+							 Server, TransactionId, Internal, false, true,
+							 RateLimit{.Interval = 1000, .MaxCalls = 10}) {}
+		static auto PathName() {
+			return std::list<std::string>{"/api/v1/oauth2/{token}", "/api/v1/oauth2"};
+		};
 		void DoGet() final;
 		void DoPost() final;
 		void DoDelete() final;
-		void DoPut() final {};
+		void DoPut() final{};
 	};
-}
-
-
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_preferences.cpp

@@ -7,30 +7,30 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_preferences::DoGet() {
-        SecurityObjects::Preferences    P;
-        Poco::JSON::Object  Answer;
-        StorageService()->PreferencesDB().GetPreferences(UserInfo_.userinfo.id, P);
-        P.to_json(Answer);
-        ReturnObject(Answer);
-    }
+	void RESTAPI_preferences::DoGet() {
+		SecurityObjects::Preferences P;
+		Poco::JSON::Object Answer;
+		StorageService()->PreferencesDB().GetPreferences(UserInfo_.userinfo.id, P);
+		P.to_json(Answer);
+		ReturnObject(Answer);
+	}
 
-    void RESTAPI_preferences::DoPut() {
+	void RESTAPI_preferences::DoPut() {
 
-        SecurityObjects::Preferences    P;
+		SecurityObjects::Preferences P;
 
-        const auto & RawObject = ParsedBody_;
-        if(!P.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		const auto &RawObject = ParsedBody_;
+		if (!P.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        P.id = UserInfo_.userinfo.id;
-        P.modified = OpenWifi::Now();
-        StorageService()->PreferencesDB().SetPreferences(P);
+		P.id = UserInfo_.userinfo.id;
+		P.modified = OpenWifi::Now();
+		StorageService()->PreferencesDB().SetPreferences(P);
 
-        Poco::JSON::Object  Answer;
-        P.to_json(Answer);
-        ReturnObject(Answer);
-    }
+		Poco::JSON::Object Answer;
+		P.to_json(Answer);
+		ReturnObject(Answer);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_preferences.h

@@ -7,21 +7,20 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_preferences : public RESTAPIHandler {
-    public:
-        RESTAPI_preferences(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{
-            Poco::Net::HTTPRequest::HTTP_GET,
-            Poco::Net::HTTPRequest::HTTP_PUT,
-            Poco::Net::HTTPRequest::HTTP_OPTIONS},
-            Server,
-            TransactionId,
-            Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/preferences"}; };
-        void DoGet() final;
-        void DoPut() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-    };
-}
+	class RESTAPI_preferences : public RESTAPIHandler {
+	  public:
+		RESTAPI_preferences(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/preferences"}; };
+		void DoGet() final;
+		void DoPut() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_routers.cpp

@@ -2,97 +2,65 @@
 // Created by stephane bourque on 2021-10-23.
 //
 
-#include "RESTAPI/RESTAPI_oauth2_handler.h"
-#include "RESTAPI/RESTAPI_user_handler.h"
-#include "RESTAPI/RESTAPI_users_handler.h"
 #include "RESTAPI/RESTAPI_action_links.h"
-#include "RESTAPI/RESTAPI_system_endpoints_handler.h"
+#include "RESTAPI/RESTAPI_apiKey_handler.h"
 #include "RESTAPI/RESTAPI_asset_server.h"
 #include "RESTAPI/RESTAPI_avatar_handler.h"
-#include "RESTAPI/RESTAPI_subavatar_handler.h"
 #include "RESTAPI/RESTAPI_email_handler.h"
-#include "RESTAPI/RESTAPI_sms_handler.h"
-#include "RESTAPI/RESTAPI_validate_token_handler.h"
+#include "RESTAPI/RESTAPI_oauth2_handler.h"
 #include "RESTAPI/RESTAPI_preferences.h"
-#include "RESTAPI/RESTAPI_subpreferences.h"
+#include "RESTAPI/RESTAPI_signup_handler.h"
+#include "RESTAPI/RESTAPI_sms_handler.h"
+#include "RESTAPI/RESTAPI_subavatar_handler.h"
+#include "RESTAPI/RESTAPI_submfa_handler.h"
 #include "RESTAPI/RESTAPI_suboauth2_handler.h"
+#include "RESTAPI/RESTAPI_subpreferences.h"
+#include "RESTAPI/RESTAPI_subtotp_handler.h"
 #include "RESTAPI/RESTAPI_subuser_handler.h"
 #include "RESTAPI/RESTAPI_subusers_handler.h"
-#include "RESTAPI/RESTAPI_validate_sub_token_handler.h"
-#include "RESTAPI/RESTAPI_submfa_handler.h"
+#include "RESTAPI/RESTAPI_system_endpoints_handler.h"
 #include "RESTAPI/RESTAPI_totp_handler.h"
-#include "RESTAPI/RESTAPI_subtotp_handler.h"
-#include "RESTAPI/RESTAPI_signup_handler.h"
-#include "RESTAPI/RESTAPI_apiKey_handler.h"
+#include "RESTAPI/RESTAPI_user_handler.h"
+#include "RESTAPI/RESTAPI_users_handler.h"
 #include "RESTAPI/RESTAPI_validate_apikey.h"
+#include "RESTAPI/RESTAPI_validate_sub_token_handler.h"
+#include "RESTAPI/RESTAPI_validate_token_handler.h"
 
+#include "RESTAPI_systemSecret_handler.h"
 #include "framework/RESTAPI_SystemCommand.h"
 #include "framework/RESTAPI_WebSocketServer.h"
-#include "RESTAPI_systemSecret_handler.h"
 
 namespace OpenWifi {
 
-    Poco::Net::HTTPRequestHandler * RESTAPI_ExtRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
-                                                            Poco::Logger & L, RESTAPI_GenericServerAccounting & S,
-                                                            uint64_t TransactionId) {
-        return RESTAPI_Router<
-            RESTAPI_oauth2_handler,
-            RESTAPI_user_handler,
-            RESTAPI_users_handler,
-            RESTAPI_system_command,
-            RESTAPI_asset_server,
-            RESTAPI_system_endpoints_handler,
-            RESTAPI_action_links,
-            RESTAPI_avatar_handler,
-            RESTAPI_subavatar_handler,
-            RESTAPI_email_handler,
-            RESTAPI_sms_handler,
-            RESTAPI_preferences,
-            RESTAPI_subpreferences,
-            RESTAPI_suboauth2_handler,
-            RESTAPI_subuser_handler,
-            RESTAPI_subusers_handler,
-            RESTAPI_submfa_handler,
-            RESTAPI_totp_handler,
-            RESTAPI_subtotp_handler,
-            RESTAPI_signup_handler,
-            RESTAPI_validate_sub_token_handler,
-            RESTAPI_validate_token_handler,
-            RESTAPI_validate_apikey,
-            RESTAPI_webSocketServer,
-            RESTAPI_apiKey_handler,
-            RESTAPI_systemSecret_handler
-        >(Path, Bindings, L, S,TransactionId);
-    }
+	Poco::Net::HTTPRequestHandler *
+	RESTAPI_ExtRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
+					  Poco::Logger &L, RESTAPI_GenericServerAccounting &S, uint64_t TransactionId) {
+		return RESTAPI_Router<
+			RESTAPI_oauth2_handler, RESTAPI_user_handler, RESTAPI_users_handler,
+			RESTAPI_system_command, RESTAPI_asset_server, RESTAPI_system_endpoints_handler,
+			RESTAPI_action_links, RESTAPI_avatar_handler, RESTAPI_subavatar_handler,
+			RESTAPI_email_handler, RESTAPI_sms_handler, RESTAPI_preferences, RESTAPI_subpreferences,
+			RESTAPI_suboauth2_handler, RESTAPI_subuser_handler, RESTAPI_subusers_handler,
+			RESTAPI_submfa_handler, RESTAPI_totp_handler, RESTAPI_subtotp_handler,
+			RESTAPI_signup_handler, RESTAPI_validate_sub_token_handler,
+			RESTAPI_validate_token_handler, RESTAPI_validate_apikey, RESTAPI_webSocketServer,
+			RESTAPI_apiKey_handler, RESTAPI_systemSecret_handler>(Path, Bindings, L, S,
+																  TransactionId);
+	}
 
-    Poco::Net::HTTPRequestHandler * RESTAPI_IntRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
-                                                            Poco::Logger & L, RESTAPI_GenericServerAccounting & S, uint64_t TransactionId) {
+	Poco::Net::HTTPRequestHandler *
+	RESTAPI_IntRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
+					  Poco::Logger &L, RESTAPI_GenericServerAccounting &S, uint64_t TransactionId) {
 
-        return RESTAPI_Router_I<
-            RESTAPI_oauth2_handler,
-            RESTAPI_user_handler,
-            RESTAPI_users_handler,
-            RESTAPI_system_command,
-            RESTAPI_asset_server,
-            RESTAPI_system_endpoints_handler,
-            RESTAPI_action_links,
-            RESTAPI_avatar_handler,
-            RESTAPI_subavatar_handler,
-            RESTAPI_email_handler,
-            RESTAPI_sms_handler,
-            RESTAPI_preferences,
-            RESTAPI_subpreferences,
-            RESTAPI_suboauth2_handler,
-            RESTAPI_subuser_handler,
-            RESTAPI_subusers_handler,
-            RESTAPI_submfa_handler,
-            RESTAPI_totp_handler,
-            RESTAPI_subtotp_handler,
-            RESTAPI_validate_sub_token_handler,
-            RESTAPI_validate_token_handler,
-            RESTAPI_validate_apikey,
-            RESTAPI_signup_handler,
-            RESTAPI_systemSecret_handler
-        >(Path, Bindings, L, S, TransactionId);
-    }
-}
+		return RESTAPI_Router_I<
+			RESTAPI_oauth2_handler, RESTAPI_user_handler, RESTAPI_users_handler,
+			RESTAPI_system_command, RESTAPI_asset_server, RESTAPI_system_endpoints_handler,
+			RESTAPI_action_links, RESTAPI_avatar_handler, RESTAPI_subavatar_handler,
+			RESTAPI_email_handler, RESTAPI_sms_handler, RESTAPI_preferences, RESTAPI_subpreferences,
+			RESTAPI_suboauth2_handler, RESTAPI_subuser_handler, RESTAPI_subusers_handler,
+			RESTAPI_submfa_handler, RESTAPI_totp_handler, RESTAPI_subtotp_handler,
+			RESTAPI_validate_sub_token_handler, RESTAPI_validate_token_handler,
+			RESTAPI_validate_apikey, RESTAPI_signup_handler, RESTAPI_systemSecret_handler>(
+			Path, Bindings, L, S, TransactionId);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_signup_handler.cpp

@@ -3,73 +3,74 @@
 //
 
 #include "RESTAPI_signup_handler.h"
-#include "StorageService.h"
 #include "RESTObjects/RESTAPI_SecurityObjects.h"
+#include "StorageService.h"
 #include "framework/MicroServiceFuncs.h"
 
 #define __DBG__ std::cout << __LINE__ << std::endl;
 namespace OpenWifi {
 
-    void RESTAPI_signup_handler::DoPost() {
-        auto UserName = GetParameter("email");
-        auto signupUUID = GetParameter("signupUUID");
-        auto owner = GetParameter("owner");
-        auto operatorName = GetParameter("operatorName");
-        if(UserName.empty() || signupUUID.empty() || owner.empty() || operatorName.empty()) {
-            Logger().error("Signup requires: email, signupUUID, operatorName, and owner.");
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+	void RESTAPI_signup_handler::DoPost() {
+		auto UserName = GetParameter("email");
+		auto signupUUID = GetParameter("signupUUID");
+		auto owner = GetParameter("owner");
+		auto operatorName = GetParameter("operatorName");
+		if (UserName.empty() || signupUUID.empty() || owner.empty() || operatorName.empty()) {
+			Logger().error("Signup requires: email, signupUUID, operatorName, and owner.");
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        if(!Utils::ValidEMailAddress(UserName)) {
-            return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
-        }
+		if (!Utils::ValidEMailAddress(UserName)) {
+			return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
+		}
 
-        // Do we already exist? Can only signup once...
-        SecurityObjects::UserInfo   Existing;
-        if(StorageService()->SubDB().GetUserByEmail(UserName,Existing)) {
-            if(Existing.signingUp.empty()) {
-                return BadRequest(RESTAPI::Errors::SignupAlreadySigned);
-            }
+		// Do we already exist? Can only signup once...
+		SecurityObjects::UserInfo Existing;
+		if (StorageService()->SubDB().GetUserByEmail(UserName, Existing)) {
+			if (Existing.signingUp.empty()) {
+				return BadRequest(RESTAPI::Errors::SignupAlreadySigned);
+			}
 
-            if(Existing.waitingForEmailCheck) {
-                return BadRequest(RESTAPI::Errors::SignupEmailCheck);
-            }
+			if (Existing.waitingForEmailCheck) {
+				return BadRequest(RESTAPI::Errors::SignupEmailCheck);
+			}
 
-            return BadRequest(RESTAPI::Errors::SignupWaitingForDevice);
-        }
+			return BadRequest(RESTAPI::Errors::SignupWaitingForDevice);
+		}
 
-        SecurityObjects::UserInfo   NewSub;
-        NewSub.signingUp = operatorName + ":" + signupUUID;
-        NewSub.waitingForEmailCheck = true;
-        NewSub.name = UserName;
-        NewSub.modified = OpenWifi::Now();
-        NewSub.creationDate = OpenWifi::Now();
-        NewSub.id = MicroServiceCreateUUID();
-        NewSub.email = UserName;
-        NewSub.userRole = SecurityObjects::SUBSCRIBER;
-        NewSub.changePassword = true;
-        NewSub.owner = owner;
+		SecurityObjects::UserInfo NewSub;
+		NewSub.signingUp = operatorName + ":" + signupUUID;
+		NewSub.waitingForEmailCheck = true;
+		NewSub.name = UserName;
+		NewSub.modified = OpenWifi::Now();
+		NewSub.creationDate = OpenWifi::Now();
+		NewSub.id = MicroServiceCreateUUID();
+		NewSub.email = UserName;
+		NewSub.userRole = SecurityObjects::SUBSCRIBER;
+		NewSub.changePassword = true;
+		NewSub.owner = owner;
 
-        StorageService()->SubDB().CreateRecord(NewSub);
+		StorageService()->SubDB().CreateRecord(NewSub);
 
-        Logger_.information(fmt::format("SIGNUP-PASSWORD({}): Request for {}", Request->clientAddress().toString(), UserName));
-        SecurityObjects::ActionLink NewLink;
+		Logger_.information(fmt::format("SIGNUP-PASSWORD({}): Request for {}",
+										Request->clientAddress().toString(), UserName));
+		SecurityObjects::ActionLink NewLink;
 
-        NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_SIGNUP;
-        NewLink.id = MicroServiceCreateUUID();
-        NewLink.userId = NewSub.id;
-        NewLink.created = OpenWifi::Now();
-        NewLink.expires = NewLink.created + (1*60*60);  // 1 hour
-        NewLink.userAction = false;
-        StorageService()->ActionLinksDB().CreateAction(NewLink);
+		NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_SIGNUP;
+		NewLink.id = MicroServiceCreateUUID();
+		NewLink.userId = NewSub.id;
+		NewLink.created = OpenWifi::Now();
+		NewLink.expires = NewLink.created + (1 * 60 * 60); // 1 hour
+		NewLink.userAction = false;
+		StorageService()->ActionLinksDB().CreateAction(NewLink);
 
-        Poco::JSON::Object  Answer;
-        NewSub.to_json(Answer);
-        return ReturnObject(Answer);
-    }
+		Poco::JSON::Object Answer;
+		NewSub.to_json(Answer);
+		return ReturnObject(Answer);
+	}
 
-    void RESTAPI_signup_handler::DoPut() {
-        // TODO
-    }
+	void RESTAPI_signup_handler::DoPut() {
+		// TODO
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_signup_handler.h

@@ -7,33 +7,32 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_signup_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_signup_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>{
-                                         Poco::Net::HTTPRequest::HTTP_POST,
-                                         Poco::Net::HTTPRequest::HTTP_OPTIONS,
-                                         Poco::Net::HTTPRequest::HTTP_PUT},
-                                 Server,
-                                 TransactionId,
-                                 Internal, false, true ){}
+	class RESTAPI_signup_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_signup_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS,
+													  Poco::Net::HTTPRequest::HTTP_PUT},
+							 Server, TransactionId, Internal, false, true) {}
 
-        static auto PathName() { return std::list<std::string>{"/api/v1/signup"}; };
+		static auto PathName() { return std::list<std::string>{"/api/v1/signup"}; };
 
-/*        inline bool RoleIsAuthorized(std::string & Reason) {
-            if(UserInfo_.userinfo.userRole != SecurityObjects::USER_ROLE::SUBSCRIBER) {
-                Reason = "User must be a subscriber";
-                return false;
-            }
-            return true;
-        }
-*/
-        void DoGet() final {};
-        void DoPost() final;
-        void DoPut() final ;
-        void DoDelete() final {};
-    private:
+		/*        inline bool RoleIsAuthorized(std::string & Reason) {
+					if(UserInfo_.userinfo.userRole != SecurityObjects::USER_ROLE::SUBSCRIBER) {
+						Reason = "User must be a subscriber";
+						return false;
+					}
+					return true;
+				}
+		*/
+		void DoGet() final{};
+		void DoPost() final;
+		void DoPut() final;
+		void DoDelete() final{};
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_sms_handler.cpp

@@ -8,51 +8,48 @@
 
 namespace OpenWifi {
 
-    void OpenWifi::RESTAPI_sms_handler::DoPost() {
-        const auto &Obj = ParsedBody_;
+	void OpenWifi::RESTAPI_sms_handler::DoPost() {
+		const auto &Obj = ParsedBody_;
 
-        if(!SMSSender()->Enabled()) {
-            return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
-        }
+		if (!SMSSender()->Enabled()) {
+			return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
+		}
 
-        std::string Arg;
-        if(HasParameter("validateNumber",Arg) && Arg=="true" && Obj->has("to")) {
-            auto Number = Obj->get("to").toString();
-            if(SMSSender()->StartValidation(Number, UserInfo_.userinfo.email)) {
-                return OK();
-            }
-            return BadRequest(RESTAPI::Errors::SMSCouldNotBeSentRetry);
-        }
+		std::string Arg;
+		if (HasParameter("validateNumber", Arg) && Arg == "true" && Obj->has("to")) {
+			auto Number = Obj->get("to").toString();
+			if (SMSSender()->StartValidation(Number, UserInfo_.userinfo.email)) {
+				return OK();
+			}
+			return BadRequest(RESTAPI::Errors::SMSCouldNotBeSentRetry);
+		}
 
-        std::string Code;
-        if( HasParameter("completeValidation",Arg) &&
-            Arg=="true" &&
-            HasParameter("validationCode", Code) &&
-            Obj->has("to")) {
-            auto Number = Obj->get("to").toString();
-            if(SMSSender()->CompleteValidation(Number, Code, UserInfo_.userinfo.email)) {
-                return OK();
-            }
-            return BadRequest(RESTAPI::Errors::SMSCouldNotValidate);
-        }
+		std::string Code;
+		if (HasParameter("completeValidation", Arg) && Arg == "true" &&
+			HasParameter("validationCode", Code) && Obj->has("to")) {
+			auto Number = Obj->get("to").toString();
+			if (SMSSender()->CompleteValidation(Number, Code, UserInfo_.userinfo.email)) {
+				return OK();
+			}
+			return BadRequest(RESTAPI::Errors::SMSCouldNotValidate);
+		}
 
-        if( UserInfo_.userinfo.userRole!=SecurityObjects::ROOT &&
-            UserInfo_.userinfo.userRole!=SecurityObjects::PARTNER &&
-            UserInfo_.userinfo.userRole!=SecurityObjects::ADMIN) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT &&
+			UserInfo_.userinfo.userRole != SecurityObjects::PARTNER &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ADMIN) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if (Obj->has("to") &&
-            Obj->has("text")) {
+		if (Obj->has("to") && Obj->has("text")) {
 
-            std::string PhoneNumber = Obj->get("to").toString();
-            std::string Text = Obj->get("text").toString();
-            if(SMSSender()->Send(PhoneNumber, Text))
-                return OK();
+			std::string PhoneNumber = Obj->get("to").toString();
+			std::string Text = Obj->get("text").toString();
+			if (SMSSender()->Send(PhoneNumber, Text))
+				return OK();
 
-            return InternalError(RESTAPI::Errors::SMSCouldNotBeSentRetry);
-        }
-        BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-    }
+			return InternalError(RESTAPI::Errors::SMSCouldNotBeSentRetry);
+		}
+		BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_sms_handler.h

@@ -7,19 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_sms_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_sms_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
-                                                  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                                  Server,
-                                                  TransactionId,
-                                                  Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/sms"};}
-        void DoGet() final {};
-        void DoPost() final;
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
+	class RESTAPI_sms_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_sms_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/sms"}; }
+		void DoGet() final{};
+		void DoPost() final;
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subavatar_handler.cpp

@@ -5,78 +5,84 @@
 #include <fstream>
 #include <iostream>
 
+#include "Poco/CountingStream.h"
+#include "Poco/Net/HTMLForm.h"
 #include "RESTAPI_subavatar_handler.h"
 #include "StorageService.h"
-#include "Poco/Net/HTMLForm.h"
-#include "Poco/CountingStream.h"
 #include "framework/MicroServiceFuncs.h"
 
 namespace OpenWifi {
 
-    void SubAvatarPartHandler::handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream) {
-        FileType_ = Header.get(RESTAPI::Protocol::CONTENTTYPE, RESTAPI::Protocol::UNSPECIFIED);
-        if (Header.has(RESTAPI::Protocol::CONTENTDISPOSITION)) {
-            std::string Disposition;
-            Poco::Net::NameValueCollection Parameters;
-            Poco::Net::MessageHeader::splitParameters(Header[RESTAPI::Protocol::CONTENTDISPOSITION], Disposition, Parameters);
-            Name_ = Parameters.get(RESTAPI::Protocol::NAME, RESTAPI::Protocol::UNNAMED);
-        }
-        Poco::CountingInputStream InputStream(Stream);
-        Poco::StreamCopier::copyStream(InputStream, OutputStream_);
-        Length_ = OutputStream_.str().size();
-    };
+	void SubAvatarPartHandler::handlePart(const Poco::Net::MessageHeader &Header,
+										  std::istream &Stream) {
+		FileType_ = Header.get(RESTAPI::Protocol::CONTENTTYPE, RESTAPI::Protocol::UNSPECIFIED);
+		if (Header.has(RESTAPI::Protocol::CONTENTDISPOSITION)) {
+			std::string Disposition;
+			Poco::Net::NameValueCollection Parameters;
+			Poco::Net::MessageHeader::splitParameters(Header[RESTAPI::Protocol::CONTENTDISPOSITION],
+													  Disposition, Parameters);
+			Name_ = Parameters.get(RESTAPI::Protocol::NAME, RESTAPI::Protocol::UNNAMED);
+		}
+		Poco::CountingInputStream InputStream(Stream);
+		Poco::StreamCopier::copyStream(InputStream, OutputStream_);
+		Length_ = OutputStream_.str().size();
+	};
 
-    void RESTAPI_subavatar_handler::DoPost() {
-        std::string Id = UserInfo_.userinfo.id;
-        SecurityObjects::UserInfo UInfo;
+	void RESTAPI_subavatar_handler::DoPost() {
+		std::string Id = UserInfo_.userinfo.id;
+		SecurityObjects::UserInfo UInfo;
 
-        std::stringstream SS;
-        SubAvatarPartHandler partHandler(Id, Logger_, SS);
-        Poco::Net::HTMLForm form(*Request, Request->stream(), partHandler);
-        Poco::JSON::Object Answer;
+		std::stringstream SS;
+		SubAvatarPartHandler partHandler(Id, Logger_, SS);
+		Poco::Net::HTMLForm form(*Request, Request->stream(), partHandler);
+		Poco::JSON::Object Answer;
 
-        if (!partHandler.Name().empty() && partHandler.Length()< MicroServiceConfigGetInt("openwifi.avatar.maxsize",2000000)) {
-            Answer.set(RESTAPI::Protocol::AVATARID, Id);
-            Answer.set(RESTAPI::Protocol::ERRORCODE, 0);
-            Logger_.information(fmt::format("Uploaded avatar: {} Type: {}", partHandler.Name(), partHandler.ContentType()));
-            StorageService()->SubAvatarDB().SetAvatar(UserInfo_.userinfo.email,
-                                 Id, SS.str(), partHandler.ContentType(), partHandler.Name());
-            StorageService()->SubDB().SetAvatar(Id,"1");
-            Logger().information(fmt::format("Adding avatar for {}",UserInfo_.userinfo.email));
-        } else {
-            Answer.set(RESTAPI::Protocol::AVATARID, Id);
-            Answer.set(RESTAPI::Protocol::ERRORCODE, 13);
-            Answer.set(RESTAPI::Protocol::ERRORTEXT, "Avatar upload could not complete.");
-        }
-        ReturnObject(Answer);
-    }
+		if (!partHandler.Name().empty() &&
+			partHandler.Length() < MicroServiceConfigGetInt("openwifi.avatar.maxsize", 2000000)) {
+			Answer.set(RESTAPI::Protocol::AVATARID, Id);
+			Answer.set(RESTAPI::Protocol::ERRORCODE, 0);
+			Logger_.information(fmt::format("Uploaded avatar: {} Type: {}", partHandler.Name(),
+											partHandler.ContentType()));
+			StorageService()->SubAvatarDB().SetAvatar(UserInfo_.userinfo.email, Id, SS.str(),
+													  partHandler.ContentType(),
+													  partHandler.Name());
+			StorageService()->SubDB().SetAvatar(Id, "1");
+			Logger().information(fmt::format("Adding avatar for {}", UserInfo_.userinfo.email));
+		} else {
+			Answer.set(RESTAPI::Protocol::AVATARID, Id);
+			Answer.set(RESTAPI::Protocol::ERRORCODE, 13);
+			Answer.set(RESTAPI::Protocol::ERRORTEXT, "Avatar upload could not complete.");
+		}
+		ReturnObject(Answer);
+	}
 
-    void RESTAPI_subavatar_handler::DoGet() {
-        std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
-        if (Id.empty()) {
-            return NotFound();
-        }
+	void RESTAPI_subavatar_handler::DoGet() {
+		std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
+		if (Id.empty()) {
+			return NotFound();
+		}
 
-        std::string Type, Name, AvatarContent;
-        if (!StorageService()->SubAvatarDB().GetAvatar(UserInfo_.userinfo.email, Id, AvatarContent, Type, Name)) {
-            return NotFound();
-        }
-        Logger().information(fmt::format("Retrieving avatar for {}",UserInfo_.userinfo.email));
-        return SendFileContent(AvatarContent, Type, Name);
-    }
+		std::string Type, Name, AvatarContent;
+		if (!StorageService()->SubAvatarDB().GetAvatar(UserInfo_.userinfo.email, Id, AvatarContent,
+													   Type, Name)) {
+			return NotFound();
+		}
+		Logger().information(fmt::format("Retrieving avatar for {}", UserInfo_.userinfo.email));
+		return SendFileContent(AvatarContent, Type, Name);
+	}
 
-    void RESTAPI_subavatar_handler::DoDelete() {
-        std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
+	void RESTAPI_subavatar_handler::DoDelete() {
+		std::string Id = GetBinding(RESTAPI::Protocol::ID, "");
 
-        if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && Id!=UserInfo_.userinfo.id) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT && Id != UserInfo_.userinfo.id) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if (!StorageService()->SubAvatarDB().DeleteAvatar(UserInfo_.userinfo.email, Id)) {
-            return NotFound();
-        }
-        Logger().information(fmt::format("Deleted avatar for {}",UserInfo_.userinfo.email));
-        StorageService()->SubDB().SetAvatar(Id,"");
-        OK();
-    }
-}
+		if (!StorageService()->SubAvatarDB().DeleteAvatar(UserInfo_.userinfo.email, Id)) {
+			return NotFound();
+		}
+		Logger().information(fmt::format("Deleted avatar for {}", UserInfo_.userinfo.email));
+		StorageService()->SubDB().SetAvatar(Id, "");
+		OK();
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subavatar_handler.h

@@ -3,52 +3,47 @@
 //
 #pragma once
 
-#include "framework/RESTAPI_Handler.h"
 #include "Poco/Net/PartHandler.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 
-    class SubAvatarPartHandler : public Poco::Net::PartHandler {
-    public:
-        SubAvatarPartHandler(std::string Id, Poco::Logger &Logger, std::stringstream & ofs) :
-                Id_(std::move(Id)),
-                Logger_(Logger),
-                OutputStream_(ofs){
-        }
-        void handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream);
-        [[nodiscard]] uint64_t Length() const { return Length_; }
-        [[nodiscard]] std::string &Name() { return Name_; }
-        [[nodiscard]] std::string &ContentType() { return FileType_; }
+	class SubAvatarPartHandler : public Poco::Net::PartHandler {
+	  public:
+		SubAvatarPartHandler(std::string Id, Poco::Logger &Logger, std::stringstream &ofs)
+			: Id_(std::move(Id)), Logger_(Logger), OutputStream_(ofs) {}
+		void handlePart(const Poco::Net::MessageHeader &Header, std::istream &Stream);
+		[[nodiscard]] uint64_t Length() const { return Length_; }
+		[[nodiscard]] std::string &Name() { return Name_; }
+		[[nodiscard]] std::string &ContentType() { return FileType_; }
 
-    private:
-        uint64_t        Length_ = 0;
-        std::string     FileType_;
-        std::string     Name_;
-        std::string     Id_;
-        Poco::Logger    &Logger_;
-        std::stringstream &OutputStream_;
+	  private:
+		uint64_t Length_ = 0;
+		std::string FileType_;
+		std::string Name_;
+		std::string Id_;
+		Poco::Logger &Logger_;
+		std::stringstream &OutputStream_;
 
-        inline Poco::Logger & Logger() { return Logger_; }
-    };
+		inline Poco::Logger &Logger() { return Logger_; }
+	};
 
-    class RESTAPI_subavatar_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_subavatar_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>{
-                                         Poco::Net::HTTPRequest::HTTP_GET,
-                                         Poco::Net::HTTPRequest::HTTP_POST,
-                                         Poco::Net::HTTPRequest::HTTP_DELETE,
-                                         Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                         Server,
-                                         TransactionId,
-                                         Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/subavatar/{id}"}; };
+	class RESTAPI_subavatar_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_subavatar_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								  RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								  bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/subavatar/{id}"}; };
 
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final;
-        void DoPut() final {};
-
-    };
-}
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final;
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_submfa_handler.cpp

@@ -3,136 +3,140 @@
 //
 
 #include "RESTAPI_submfa_handler.h"
-#include "StorageService.h"
 #include "SMSSender.h"
+#include "StorageService.h"
 #include "framework/MicroServiceFuncs.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_submfa_handler::DoGet() {
-        SecurityObjects::UserInfo   User;
+	void RESTAPI_submfa_handler::DoGet() {
+		SecurityObjects::UserInfo User;
 
-        if (StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id,User)) {
-            Poco::JSON::Object              Answer;
-            SecurityObjects::SubMfaConfig   MFC;
+		if (StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User)) {
+			Poco::JSON::Object Answer;
+			SecurityObjects::SubMfaConfig MFC;
 
-            MFC.id = User.id;
-            if(User.userTypeProprietaryInfo.mfa.enabled) {
-                if(User.userTypeProprietaryInfo.mfa.method == "sms") {
-                    MFC.sms = User.userTypeProprietaryInfo.mobiles[0].number;
-                    MFC.type = "sms";
-                } else if(User.userTypeProprietaryInfo.mfa.method == "email") {
-                    MFC.email = User.email;
-                    MFC.type = "email";
-                }
-            } else {
-                MFC.type = "disabled";
-            }
-            MFC.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-        NotFound();
-    }
+			MFC.id = User.id;
+			if (User.userTypeProprietaryInfo.mfa.enabled) {
+				if (User.userTypeProprietaryInfo.mfa.method == "sms") {
+					MFC.sms = User.userTypeProprietaryInfo.mobiles[0].number;
+					MFC.type = "sms";
+				} else if (User.userTypeProprietaryInfo.mfa.method == "email") {
+					MFC.email = User.email;
+					MFC.type = "email";
+				}
+			} else {
+				MFC.type = "disabled";
+			}
+			MFC.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+		NotFound();
+	}
 
-    void RESTAPI_submfa_handler::DoPut() {
+	void RESTAPI_submfa_handler::DoPut() {
 
-        try {
-            const auto & Body = ParsedBody_;
+		try {
+			const auto &Body = ParsedBody_;
 
-            SecurityObjects::SubMfaConfig MFC;
+			SecurityObjects::SubMfaConfig MFC;
 
-            if (!MFC.from_json(Body)) {
-                return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-            }
+			if (!MFC.from_json(Body)) {
+				return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+			}
 
-            if (MFC.type == "disabled") {
-                SecurityObjects::UserInfo User;
-                StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
-                User.userTypeProprietaryInfo.mfa.enabled = false;
-                StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, UserInfo_.userinfo.id, User);
+			if (MFC.type == "disabled") {
+				SecurityObjects::UserInfo User;
+				StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
+				User.userTypeProprietaryInfo.mfa.enabled = false;
+				StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,
+														 UserInfo_.userinfo.id, User);
 
-                Poco::JSON::Object Answer;
-                MFC.to_json(Answer);
-                return ReturnObject(Answer);
-            } else if (MFC.type == "email") {
-                SecurityObjects::UserInfo User;
+				Poco::JSON::Object Answer;
+				MFC.to_json(Answer);
+				return ReturnObject(Answer);
+			} else if (MFC.type == "email") {
+				SecurityObjects::UserInfo User;
 
-                StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
-                User.userTypeProprietaryInfo.mfa.enabled = true;
-                User.userTypeProprietaryInfo.mfa.method = "email";
-                StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, UserInfo_.userinfo.id, User);
+				StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
+				User.userTypeProprietaryInfo.mfa.enabled = true;
+				User.userTypeProprietaryInfo.mfa.method = "email";
+				StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,
+														 UserInfo_.userinfo.id, User);
 
-                MFC.sms = MFC.sms;
-                MFC.type = "email";
-                MFC.email = UserInfo_.userinfo.email;
-                MFC.id = MicroServiceCreateUUID();
+				MFC.sms = MFC.sms;
+				MFC.type = "email";
+				MFC.email = UserInfo_.userinfo.email;
+				MFC.id = MicroServiceCreateUUID();
 
-                Poco::JSON::Object Answer;
-                MFC.to_json(Answer);
-                return ReturnObject(Answer);
+				Poco::JSON::Object Answer;
+				MFC.to_json(Answer);
+				return ReturnObject(Answer);
 
-            } else if (MFC.type == "sms") {
-                if (GetBoolParameter("startValidation", false)) {
-                    if (MFC.sms.empty()) {
-                        return BadRequest(RESTAPI::Errors::SMSMissingPhoneNumber);
-                    }
+			} else if (MFC.type == "sms") {
+				if (GetBoolParameter("startValidation", false)) {
+					if (MFC.sms.empty()) {
+						return BadRequest(RESTAPI::Errors::SMSMissingPhoneNumber);
+					}
 
-                    if(!SMSSender()->Enabled()) {
-                        return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
-                    }
+					if (!SMSSender()->Enabled()) {
+						return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
+					}
 
-                    if (SMSSender()->StartValidation(MFC.sms, UserInfo_.userinfo.email)) {
-                        return OK();
-                    } else {
-                        return InternalError(RESTAPI::Errors::SMSTryLater);
-                    }
-                } else if (GetBoolParameter("completeValidation", false)) {
+					if (SMSSender()->StartValidation(MFC.sms, UserInfo_.userinfo.email)) {
+						return OK();
+					} else {
+						return InternalError(RESTAPI::Errors::SMSTryLater);
+					}
+				} else if (GetBoolParameter("completeValidation", false)) {
 
-                    if(!SMSSender()->Enabled()) {
-                        return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
-                    }
+					if (!SMSSender()->Enabled()) {
+						return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
+					}
 
-                    auto ChallengeCode = GetParameter("challengeCode", "");
-                    if (ChallengeCode.empty()) {
-                        return BadRequest(RESTAPI::Errors::SMSMissingChallenge);
-                    }
-                    if (MFC.sms.empty()) {
-                        return BadRequest(RESTAPI::Errors::SMSMissingPhoneNumber);
-                    }
-                    if (SMSSender()->CompleteValidation(MFC.sms, ChallengeCode, UserInfo_.userinfo.email)) {
-                        SecurityObjects::UserInfo User;
+					auto ChallengeCode = GetParameter("challengeCode", "");
+					if (ChallengeCode.empty()) {
+						return BadRequest(RESTAPI::Errors::SMSMissingChallenge);
+					}
+					if (MFC.sms.empty()) {
+						return BadRequest(RESTAPI::Errors::SMSMissingPhoneNumber);
+					}
+					if (SMSSender()->CompleteValidation(MFC.sms, ChallengeCode,
+														UserInfo_.userinfo.email)) {
+						SecurityObjects::UserInfo User;
 
-                        StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
-                        User.userTypeProprietaryInfo.mfa.enabled = true;
-                        User.userTypeProprietaryInfo.mfa.method = "sms";
-                        SecurityObjects::MobilePhoneNumber PhoneNumber;
-                        PhoneNumber.number = MFC.sms;
-                        PhoneNumber.primary = true;
-                        PhoneNumber.verified = true;
-                        User.userTypeProprietaryInfo.mobiles.clear();
-                        User.userTypeProprietaryInfo.mobiles.push_back(PhoneNumber);
+						StorageService()->SubDB().GetUserById(UserInfo_.userinfo.id, User);
+						User.userTypeProprietaryInfo.mfa.enabled = true;
+						User.userTypeProprietaryInfo.mfa.method = "sms";
+						SecurityObjects::MobilePhoneNumber PhoneNumber;
+						PhoneNumber.number = MFC.sms;
+						PhoneNumber.primary = true;
+						PhoneNumber.verified = true;
+						User.userTypeProprietaryInfo.mobiles.clear();
+						User.userTypeProprietaryInfo.mobiles.push_back(PhoneNumber);
 
-                        StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, UserInfo_.userinfo.id, User);
+						StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,
+																 UserInfo_.userinfo.id, User);
 
-                        MFC.sms = MFC.sms;
-                        MFC.type = "sms";
-                        MFC.email = UserInfo_.userinfo.email;
-                        MFC.id = MicroServiceCreateUUID();
+						MFC.sms = MFC.sms;
+						MFC.type = "sms";
+						MFC.email = UserInfo_.userinfo.email;
+						MFC.id = MicroServiceCreateUUID();
 
-                        Poco::JSON::Object Answer;
-                        MFC.to_json(Answer);
+						Poco::JSON::Object Answer;
+						MFC.to_json(Answer);
 
-                        return ReturnObject(Answer);
+						return ReturnObject(Answer);
 
-                    } else {
-                        return InternalError(RESTAPI::Errors::SMSTryLater);
-                    }
-                }
-            }
-        } catch (const Poco::Exception &E) {
-            Logger_.log(E);
-        }
-        return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-    }
+					} else {
+						return InternalError(RESTAPI::Errors::SMSTryLater);
+					}
+				}
+			}
+		} catch (const Poco::Exception &E) {
+			Logger_.log(E);
+		}
+		return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_submfa_handler.h

@@ -7,21 +7,21 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_submfa_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_submfa_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_PUT,
-                                                  Poco::Net::HTTPRequest::HTTP_GET,
-                                                  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                                  Server,
-                                                  TransactionId,
-                                                  Internal, true, false , RateLimit{.Interval=1000,.MaxCalls=10},
-                                                  true) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/submfa"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final ;
-    };
-}
+	class RESTAPI_submfa_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_submfa_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal, true, false,
+							 RateLimit{.Interval = 1000, .MaxCalls = 10}, true) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/submfa"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final;
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_suboauth2_handler.cpp

@@ -5,161 +5,167 @@
 #include "RESTAPI_suboauth2_handler.h"
 #include "AuthService.h"
 #include "MFAServer.h"
-#include "StorageService.h"
 #include "RESTAPI/RESTAPI_db_helpers.h"
+#include "StorageService.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_suboauth2_handler::DoGet() {
-        bool Expired = false, Contacted = false;
-        if (!IsAuthorized(Expired, Contacted, true)) {
-            if(Expired)
-                return UnAuthorized(RESTAPI::Errors::EXPIRED_TOKEN);
-            return UnAuthorized(RESTAPI::Errors::INVALID_TOKEN);
-        }
-        bool GetMe = GetBoolParameter(RESTAPI::Protocol::ME, false);
-        if(GetMe) {
-            Logger_.information(fmt::format("REQUEST-ME({}): Request for {}", Request->clientAddress().toString(),
-                                             UserInfo_.userinfo.email));
-            Poco::JSON::Object Me;
-            SecurityObjects::UserInfo   ReturnedUser = UserInfo_.userinfo;
-            Sanitize(UserInfo_, ReturnedUser);
-            ReturnedUser.to_json(Me);
-            return ReturnObject(Me);
-        }
-        BadRequest(RESTAPI::Errors::UnrecognizedRequest);
-    }
+	void RESTAPI_suboauth2_handler::DoGet() {
+		bool Expired = false, Contacted = false;
+		if (!IsAuthorized(Expired, Contacted, true)) {
+			if (Expired)
+				return UnAuthorized(RESTAPI::Errors::EXPIRED_TOKEN);
+			return UnAuthorized(RESTAPI::Errors::INVALID_TOKEN);
+		}
+		bool GetMe = GetBoolParameter(RESTAPI::Protocol::ME, false);
+		if (GetMe) {
+			Logger_.information(fmt::format("REQUEST-ME({}): Request for {}",
+											Request->clientAddress().toString(),
+											UserInfo_.userinfo.email));
+			Poco::JSON::Object Me;
+			SecurityObjects::UserInfo ReturnedUser = UserInfo_.userinfo;
+			Sanitize(UserInfo_, ReturnedUser);
+			ReturnedUser.to_json(Me);
+			return ReturnObject(Me);
+		}
+		BadRequest(RESTAPI::Errors::UnrecognizedRequest);
+	}
 
-    void RESTAPI_suboauth2_handler::DoDelete() {
-        auto Token = GetBinding(RESTAPI::Protocol::TOKEN, "");
-        std::string SessionToken;
-        try {
-            Poco::Net::OAuth20Credentials Auth(*Request);
-            if (Auth.getScheme() == "Bearer") {
-                SessionToken = Auth.getBearerToken();
-            }
-        } catch (const Poco::Exception &E) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        if (Token.empty() || (Token != SessionToken)) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
-        AuthService()->SubLogout(Token);
-        return ReturnStatus(Poco::Net::HTTPResponse::HTTP_NO_CONTENT, true);
-    }
+	void RESTAPI_suboauth2_handler::DoDelete() {
+		auto Token = GetBinding(RESTAPI::Protocol::TOKEN, "");
+		std::string SessionToken;
+		try {
+			Poco::Net::OAuth20Credentials Auth(*Request);
+			if (Auth.getScheme() == "Bearer") {
+				SessionToken = Auth.getBearerToken();
+			}
+		} catch (const Poco::Exception &E) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		if (Token.empty() || (Token != SessionToken)) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+		AuthService()->SubLogout(Token);
+		return ReturnStatus(Poco::Net::HTTPResponse::HTTP_NO_CONTENT, true);
+	}
 
-    void RESTAPI_suboauth2_handler::DoPost() {
-        const auto & Obj = ParsedBody_;
-        auto userId = GetS(RESTAPI::Protocol::USERID, Obj);
-        auto password = GetS(RESTAPI::Protocol::PASSWORD, Obj);
-        auto newPassword = GetS(RESTAPI::Protocol::NEWPASSWORD, Obj);
-        auto refreshToken = GetS("refreshToken", Obj);
-        auto grant_type = GetParameter("grant_type");
+	void RESTAPI_suboauth2_handler::DoPost() {
+		const auto &Obj = ParsedBody_;
+		auto userId = GetS(RESTAPI::Protocol::USERID, Obj);
+		auto password = GetS(RESTAPI::Protocol::PASSWORD, Obj);
+		auto newPassword = GetS(RESTAPI::Protocol::NEWPASSWORD, Obj);
+		auto refreshToken = GetS("refreshToken", Obj);
+		auto grant_type = GetParameter("grant_type");
 
-        Poco::toLowerInPlace(userId);
+		Poco::toLowerInPlace(userId);
 
-        if(!refreshToken.empty() && grant_type == "refresh_token") {
-            SecurityObjects::UserInfoAndPolicy UInfo;
-            if(AuthService()->RefreshSubToken(*Request, refreshToken, UInfo)) {
-                Poco::JSON::Object  Answer;
-                UInfo.webtoken.to_json(Answer);
-                return ReturnObject(Answer);
-            } else {
-                return UnAuthorized(RESTAPI::Errors::CANNOT_REFRESH_TOKEN);
-            }
-        }
+		if (!refreshToken.empty() && grant_type == "refresh_token") {
+			SecurityObjects::UserInfoAndPolicy UInfo;
+			if (AuthService()->RefreshSubToken(*Request, refreshToken, UInfo)) {
+				Poco::JSON::Object Answer;
+				UInfo.webtoken.to_json(Answer);
+				return ReturnObject(Answer);
+			} else {
+				return UnAuthorized(RESTAPI::Errors::CANNOT_REFRESH_TOKEN);
+			}
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::REQUIREMENTS)) {
-            Logger_.information(fmt::format("POLICY-REQUEST({}): Request.", Request->clientAddress().toString()));
-            Poco::JSON::Object  Answer;
-            Answer.set(RESTAPI::Protocol::PASSWORDPATTERN, AuthService()->SubPasswordValidationExpression());
-            Answer.set(RESTAPI::Protocol::ACCESSPOLICY, AuthService()->GetSubAccessPolicy());
-            Answer.set(RESTAPI::Protocol::PASSWORDPOLICY, AuthService()->GetSubPasswordPolicy());
-            return ReturnObject(Answer);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::REQUIREMENTS)) {
+			Logger_.information(
+				fmt::format("POLICY-REQUEST({}): Request.", Request->clientAddress().toString()));
+			Poco::JSON::Object Answer;
+			Answer.set(RESTAPI::Protocol::PASSWORDPATTERN,
+					   AuthService()->SubPasswordValidationExpression());
+			Answer.set(RESTAPI::Protocol::ACCESSPOLICY, AuthService()->GetSubAccessPolicy());
+			Answer.set(RESTAPI::Protocol::PASSWORDPOLICY, AuthService()->GetSubPasswordPolicy());
+			return ReturnObject(Answer);
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::FORGOTPASSWORD)) {
-            SecurityObjects::UserInfo UInfo1;
-            auto UserExists = StorageService()->SubDB().GetUserByEmail(userId,UInfo1);
-            if(UserExists) {
-                Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}", Request->clientAddress().toString(), userId));
-                SecurityObjects::ActionLink NewLink;
+		if (GetBoolParameter(RESTAPI::Protocol::FORGOTPASSWORD)) {
+			SecurityObjects::UserInfo UInfo1;
+			auto UserExists = StorageService()->SubDB().GetUserByEmail(userId, UInfo1);
+			if (UserExists) {
+				Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}",
+												Request->clientAddress().toString(), userId));
+				SecurityObjects::ActionLink NewLink;
 
-                NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_FORGOT_PASSWORD;
-                NewLink.id = MicroServiceCreateUUID();
-                NewLink.userId = UInfo1.id;
-                NewLink.created = OpenWifi::Now();
-                NewLink.expires = NewLink.created + (24*60*60);
-                NewLink.userAction = false;
-                StorageService()->ActionLinksDB().CreateAction(NewLink);
+				NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_FORGOT_PASSWORD;
+				NewLink.id = MicroServiceCreateUUID();
+				NewLink.userId = UInfo1.id;
+				NewLink.created = OpenWifi::Now();
+				NewLink.expires = NewLink.created + (24 * 60 * 60);
+				NewLink.userAction = false;
+				StorageService()->ActionLinksDB().CreateAction(NewLink);
 
-                Poco::JSON::Object ReturnObj;
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                UInfo.webtoken.userMustChangePassword = true;
-                UInfo.webtoken.to_json(ReturnObj);
-                return ReturnObject(ReturnObj);
-            } else {
-                Poco::JSON::Object ReturnObj;
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                UInfo.webtoken.userMustChangePassword = true;
-                UInfo.webtoken.to_json(ReturnObj);
-                return ReturnObject(ReturnObj);
-            }
-        }
+				Poco::JSON::Object ReturnObj;
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				UInfo.webtoken.userMustChangePassword = true;
+				UInfo.webtoken.to_json(ReturnObj);
+				return ReturnObject(ReturnObj);
+			} else {
+				Poco::JSON::Object ReturnObj;
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				UInfo.webtoken.userMustChangePassword = true;
+				UInfo.webtoken.to_json(ReturnObj);
+				return ReturnObject(ReturnObj);
+			}
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::RESENDMFACODE)) {
-            Logger_.information(fmt::format("RESEND-MFA-CODE({}): Request for {}", Request->clientAddress().toString(), userId));
-            if(Obj->has("uuid")) {
-                auto uuid = Obj->get("uuid").toString();
-                if(MFAServer()->ResendCode(uuid))
-                    return OK();
-            }
-            return UnAuthorized(RESTAPI::Errors::BAD_MFA_TRANSACTION);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::RESENDMFACODE)) {
+			Logger_.information(fmt::format("RESEND-MFA-CODE({}): Request for {}",
+											Request->clientAddress().toString(), userId));
+			if (Obj->has("uuid")) {
+				auto uuid = Obj->get("uuid").toString();
+				if (MFAServer()->ResendCode(uuid))
+					return OK();
+			}
+			return UnAuthorized(RESTAPI::Errors::BAD_MFA_TRANSACTION);
+		}
 
-        if(GetBoolParameter(RESTAPI::Protocol::COMPLETEMFACHALLENGE)) {
-            Logger_.information(fmt::format("COMPLETE-MFA-CHALLENGE({}): Request for {}", Request->clientAddress().toString(), userId));
-            if(Obj->has("uuid") && Obj->has("answer")) {
-                SecurityObjects::UserInfoAndPolicy UInfo;
-                if(MFAServer()->CompleteMFAChallenge(Obj,UInfo)) {
-                    Poco::JSON::Object ReturnObj;
-                    UInfo.webtoken.to_json(ReturnObj);
-                    return ReturnObject(ReturnObj);
-                }
-            }
-            return UnAuthorized(RESTAPI::Errors::MFA_FAILURE);
-        }
+		if (GetBoolParameter(RESTAPI::Protocol::COMPLETEMFACHALLENGE)) {
+			Logger_.information(fmt::format("COMPLETE-MFA-CHALLENGE({}): Request for {}",
+											Request->clientAddress().toString(), userId));
+			if (Obj->has("uuid") && Obj->has("answer")) {
+				SecurityObjects::UserInfoAndPolicy UInfo;
+				if (MFAServer()->CompleteMFAChallenge(Obj, UInfo)) {
+					Poco::JSON::Object ReturnObj;
+					UInfo.webtoken.to_json(ReturnObj);
+					return ReturnObject(ReturnObj);
+				}
+			}
+			return UnAuthorized(RESTAPI::Errors::MFA_FAILURE);
+		}
 
-        SecurityObjects::UserInfoAndPolicy UInfo;
-        bool Expired=false;
-        auto Code=AuthService()->AuthorizeSub(userId, password, newPassword, UInfo, Expired);
-        switch(Code) {
-            case SUCCESS:
-            {
-                Poco::JSON::Object ReturnObj;
-                if(AuthService()->RequiresMFA(UInfo)) {
-                    if(MFAServer()->StartMFAChallenge(UInfo, ReturnObj)) {
-                        return ReturnObject(ReturnObj);
-                    }
-                    Logger_.warning("MFA Seems to be broken. Please fix. Disabling MFA checking for now.");
-                }
-                UInfo.webtoken.to_json(ReturnObj);
-                return ReturnObject(ReturnObj);
-            }
-            case INVALID_CREDENTIALS:
-                return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
-            case PASSWORD_INVALID:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_INVALID);
-            case PASSWORD_ALREADY_USED:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_ALREADY_USED);
-            case USERNAME_PENDING_VERIFICATION:
-                return UnAuthorized(RESTAPI::Errors::USERNAME_PENDING_VERIFICATION);
-            case PASSWORD_CHANGE_REQUIRED:
-                return UnAuthorized(RESTAPI::Errors::PASSWORD_CHANGE_REQUIRED);
-            case ACCOUNT_SUSPENDED:
-                return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
-            default:
-                return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
-        }
-    }
-}
+		SecurityObjects::UserInfoAndPolicy UInfo;
+		bool Expired = false;
+		auto Code = AuthService()->AuthorizeSub(userId, password, newPassword, UInfo, Expired);
+		switch (Code) {
+		case SUCCESS: {
+			Poco::JSON::Object ReturnObj;
+			if (AuthService()->RequiresMFA(UInfo)) {
+				if (MFAServer()->StartMFAChallenge(UInfo, ReturnObj)) {
+					return ReturnObject(ReturnObj);
+				}
+				Logger_.warning(
+					"MFA Seems to be broken. Please fix. Disabling MFA checking for now.");
+			}
+			UInfo.webtoken.to_json(ReturnObj);
+			return ReturnObject(ReturnObj);
+		}
+		case INVALID_CREDENTIALS:
+			return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
+		case PASSWORD_INVALID:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_INVALID);
+		case PASSWORD_ALREADY_USED:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_ALREADY_USED);
+		case USERNAME_PENDING_VERIFICATION:
+			return UnAuthorized(RESTAPI::Errors::USERNAME_PENDING_VERIFICATION);
+		case PASSWORD_CHANGE_REQUIRED:
+			return UnAuthorized(RESTAPI::Errors::PASSWORD_CHANGE_REQUIRED);
+		case ACCOUNT_SUSPENDED:
+			return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
+		default:
+			return UnAuthorized(RESTAPI::Errors::INVALID_CREDENTIALS);
+		}
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_suboauth2_handler.h

@@ -6,22 +6,24 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_suboauth2_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_suboauth2_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
-                                                  Poco::Net::HTTPRequest::HTTP_DELETE,
-                                                  Poco::Net::HTTPRequest::HTTP_GET,
-                                                  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                                  Server,
-                                                  TransactionId,
-                                                  Internal, false, false , RateLimit{.Interval=1000,.MaxCalls=10},
-                                                  false) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/suboauth2/{token}","/api/v1/suboauth2"}; };
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final;
-        void DoPut() final {};
-    };
-}
+	class RESTAPI_suboauth2_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_suboauth2_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								  RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								  bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal, false, false,
+							 RateLimit{.Interval = 1000, .MaxCalls = 10}, false) {}
+		static auto PathName() {
+			return std::list<std::string>{"/api/v1/suboauth2/{token}", "/api/v1/suboauth2"};
+		};
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final;
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subpreferences.cpp

@@ -7,30 +7,30 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_subpreferences::DoGet() {
-        SecurityObjects::Preferences    P;
-        Poco::JSON::Object  Answer;
-        StorageService()->SubPreferencesDB().GetPreferences(UserInfo_.userinfo.id, P);
-        P.to_json(Answer);
-        ReturnObject(Answer);
-    }
+	void RESTAPI_subpreferences::DoGet() {
+		SecurityObjects::Preferences P;
+		Poco::JSON::Object Answer;
+		StorageService()->SubPreferencesDB().GetPreferences(UserInfo_.userinfo.id, P);
+		P.to_json(Answer);
+		ReturnObject(Answer);
+	}
 
-    void RESTAPI_subpreferences::DoPut() {
+	void RESTAPI_subpreferences::DoPut() {
 
-        SecurityObjects::Preferences    P;
+		SecurityObjects::Preferences P;
 
-        const auto & RawObject = ParsedBody_;
-        if(!P.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		const auto &RawObject = ParsedBody_;
+		if (!P.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        P.id = UserInfo_.userinfo.id;
-        P.modified = OpenWifi::Now();
-        StorageService()->SubPreferencesDB().SetPreferences(P);
+		P.id = UserInfo_.userinfo.id;
+		P.modified = OpenWifi::Now();
+		StorageService()->SubPreferencesDB().SetPreferences(P);
 
-        Poco::JSON::Object  Answer;
-        P.to_json(Answer);
-        ReturnObject(Answer);
-    }
+		Poco::JSON::Object Answer;
+		P.to_json(Answer);
+		ReturnObject(Answer);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subpreferences.h

@@ -7,21 +7,20 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_subpreferences : public RESTAPIHandler {
-    public:
-        RESTAPI_subpreferences(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>{
-            Poco::Net::HTTPRequest::HTTP_GET,
-            Poco::Net::HTTPRequest::HTTP_PUT,
-            Poco::Net::HTTPRequest::HTTP_OPTIONS},
-            Server,
-            TransactionId,
-            Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/subpreferences"}; };
-        void DoGet() final;
-        void DoPut() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-    };
-}
+	class RESTAPI_subpreferences : public RESTAPIHandler {
+	  public:
+		RESTAPI_subpreferences(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							   RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							   bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/subpreferences"}; };
+		void DoGet() final;
+		void DoPut() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subtotp_handler.cpp

@@ -9,30 +9,31 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_subtotp_handler::DoGet() {
+	void RESTAPI_subtotp_handler::DoGet() {
 
-        auto Reset = GetBoolParameter("reset",false);
-        std::string QRCode;
+		auto Reset = GetBoolParameter("reset", false);
+		std::string QRCode;
 
-        if(TotpCache()->StartValidation(UserInfo_.userinfo,true,QRCode,Reset)) {
-            return SendFileContent(QRCode, "image/svg+xml","qrcode.svg");
-        }
-        return BadRequest(RESTAPI::Errors::InvalidCommand);
-    }
+		if (TotpCache()->StartValidation(UserInfo_.userinfo, true, QRCode, Reset)) {
+			return SendFileContent(QRCode, "image/svg+xml", "qrcode.svg");
+		}
+		return BadRequest(RESTAPI::Errors::InvalidCommand);
+	}
 
-    void RESTAPI_subtotp_handler::DoPut() {
-        auto Value = GetParameter("value","");
-        auto nextIndex = GetParameter("index",0);
-        bool moreCodes=false;
+	void RESTAPI_subtotp_handler::DoPut() {
+		auto Value = GetParameter("value", "");
+		auto nextIndex = GetParameter("index", 0);
+		bool moreCodes = false;
 
-        RESTAPI::Errors::msg    Error;
-        if(TotpCache()->ContinueValidation(UserInfo_.userinfo,true,Value,nextIndex,moreCodes, Error )) {
-            Poco::JSON::Object Answer;
-            Answer.set("nextIndex", nextIndex);
-            Answer.set("moreCodes", moreCodes);
-            return ReturnObject(Answer);
-        }
-        return BadRequest(Error);
-    }
+		RESTAPI::Errors::msg Error;
+		if (TotpCache()->ContinueValidation(UserInfo_.userinfo, true, Value, nextIndex, moreCodes,
+											Error)) {
+			Poco::JSON::Object Answer;
+			Answer.set("nextIndex", nextIndex);
+			Answer.set("moreCodes", moreCodes);
+			return ReturnObject(Answer);
+		}
+		return BadRequest(Error);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subtotp_handler.h

@@ -5,25 +5,22 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_subtotp_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_subtotp_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {
-                                                 Poco::Net::HTTPRequest::HTTP_GET,
-                                                 Poco::Net::HTTPRequest::HTTP_PUT,
-                                                 Poco::Net::HTTPRequest::HTTP_OPTIONS
-                                         },
-                                 Server,
-                                 TransactionId,
-                                 Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/subtotp"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final;
-    private:
+	class RESTAPI_subtotp_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_subtotp_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/subtotp"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final;
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subuser_handler.cpp

@@ -3,316 +3,338 @@
 //
 
 #include "RESTAPI_subuser_handler.h"
-#include "StorageService.h"
-#include "framework/ow_constants.h"
-#include "SMSSender.h"
-#include "SMTPMailerService.h"
 #include "ACLProcessor.h"
 #include "AuthService.h"
-#include "RESTAPI/RESTAPI_db_helpers.h"
 #include "MFAServer.h"
+#include "RESTAPI/RESTAPI_db_helpers.h"
+#include "SMSSender.h"
+#include "SMTPMailerService.h"
+#include "StorageService.h"
 #include "TotpCache.h"
+#include "framework/ow_constants.h"
 
 #include "framework/MicroServiceFuncs.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_subuser_handler::DoGet() {
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+	void RESTAPI_subuser_handler::DoGet() {
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        Poco::toLowerInPlace(Id);
-        std::string Arg;
-        SecurityObjects::UserInfo   UInfo;
-        if(HasParameter("byEmail",Arg) && Arg=="true") {
-            if(!StorageService()->SubDB().GetUserByEmail(Id,UInfo)) {
-                return NotFound();
-            }
-        } else if(!StorageService()->SubDB().GetUserById(Id,UInfo)) {
-            return NotFound();
-        }
+		Poco::toLowerInPlace(Id);
+		std::string Arg;
+		SecurityObjects::UserInfo UInfo;
+		if (HasParameter("byEmail", Arg) && Arg == "true") {
+			if (!StorageService()->SubDB().GetUserByEmail(Id, UInfo)) {
+				return NotFound();
+			}
+		} else if (!StorageService()->SubDB().GetUserById(Id, UInfo)) {
+			return NotFound();
+		}
 
-        Poco::JSON::Object  UserInfoObject;
-        Sanitize(UserInfo_, UInfo);
-        UInfo.to_json(UserInfoObject);
-        ReturnObject(UserInfoObject);
-    }
+		Poco::JSON::Object UserInfoObject;
+		Sanitize(UserInfo_, UInfo);
+		UInfo.to_json(UserInfoObject);
+		ReturnObject(UserInfoObject);
+	}
 
-    void RESTAPI_subuser_handler::DoDelete() {
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+	void RESTAPI_subuser_handler::DoDelete() {
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        SecurityObjects::UserInfo TargetUser;
-        if(!StorageService()->SubDB().GetUserById(Id,TargetUser)) {
-            return NotFound();
-        }
+		SecurityObjects::UserInfo TargetUser;
+		if (!StorageService()->SubDB().GetUserById(Id, TargetUser)) {
+			return NotFound();
+		}
 
-        if(TargetUser.userRole != SecurityObjects::SUBSCRIBER) {
-            return BadRequest(RESTAPI::Errors::InvalidUserRole);
-        }
+		if (TargetUser.userRole != SecurityObjects::SUBSCRIBER) {
+			return BadRequest(RESTAPI::Errors::InvalidUserRole);
+		}
 
-        if(!Internal_ && !ACLProcessor::Can(UserInfo_.userinfo, TargetUser,ACLProcessor::DELETE)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!Internal_ &&
+			!ACLProcessor::Can(UserInfo_.userinfo, TargetUser, ACLProcessor::DELETE)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(!StorageService()->SubDB().DeleteUser(UserInfo_.userinfo.email,Id)) {
-            return NotFound();
-        }
+		if (!StorageService()->SubDB().DeleteUser(UserInfo_.userinfo.email, Id)) {
+			return NotFound();
+		}
 
-        AuthService()->DeleteSubUserFromCache(Id);
-        StorageService()->SubTokenDB().RevokeAllTokens(TargetUser.email);
-        StorageService()->SubPreferencesDB().DeleteRecord("id", Id);
-        StorageService()->SubAvatarDB().DeleteRecord("id", Id);
-        Logger_.information(fmt::format("User '{}' deleted by '{}'.",Id,UserInfo_.userinfo.email));
-        OK();
-    }
+		AuthService()->DeleteSubUserFromCache(Id);
+		StorageService()->SubTokenDB().RevokeAllTokens(TargetUser.email);
+		StorageService()->SubPreferencesDB().DeleteRecord("id", Id);
+		StorageService()->SubAvatarDB().DeleteRecord("id", Id);
+		Logger_.information(
+			fmt::format("User '{}' deleted by '{}'.", Id, UserInfo_.userinfo.email));
+		OK();
+	}
 
-    void RESTAPI_subuser_handler::DoPost() {
-        std::string Id = GetBinding("id", "");
-        if(Id!="0") {
-            return BadRequest(RESTAPI::Errors::IdMustBe0);
-        }
+	void RESTAPI_subuser_handler::DoPost() {
+		std::string Id = GetBinding("id", "");
+		if (Id != "0") {
+			return BadRequest(RESTAPI::Errors::IdMustBe0);
+		}
 
-        SecurityObjects::UserInfo   NewUser;
-        const auto & RawObject = ParsedBody_;
-        if(!NewUser.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		SecurityObjects::UserInfo NewUser;
+		const auto &RawObject = ParsedBody_;
+		if (!NewUser.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        if(NewUser.userRole == SecurityObjects::UNKNOWN || NewUser.userRole != SecurityObjects::SUBSCRIBER) {
-            return BadRequest(RESTAPI::Errors::InvalidUserRole);
-        }
+		if (NewUser.userRole == SecurityObjects::UNKNOWN ||
+			NewUser.userRole != SecurityObjects::SUBSCRIBER) {
+			return BadRequest(RESTAPI::Errors::InvalidUserRole);
+		}
 
-        Poco::toLowerInPlace(NewUser.email);
-        SecurityObjects::UserInfo   Existing;
-        if(StorageService()->SubDB().GetUserByEmail(NewUser.email,Existing)) {
-            return BadRequest(RESTAPI::Errors::UserAlreadyExists);
-        }
+		Poco::toLowerInPlace(NewUser.email);
+		SecurityObjects::UserInfo Existing;
+		if (StorageService()->SubDB().GetUserByEmail(NewUser.email, Existing)) {
+			return BadRequest(RESTAPI::Errors::UserAlreadyExists);
+		}
 
-        if(!Internal_ && !ACLProcessor::Can(UserInfo_.userinfo,NewUser,ACLProcessor::CREATE)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!Internal_ && !ACLProcessor::Can(UserInfo_.userinfo, NewUser, ACLProcessor::CREATE)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        Poco::toLowerInPlace(NewUser.email);
-        if(!Utils::ValidEMailAddress(NewUser.email)) {
-            return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
-        }
+		Poco::toLowerInPlace(NewUser.email);
+		if (!Utils::ValidEMailAddress(NewUser.email)) {
+			return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
+		}
 
-        if(!NewUser.currentPassword.empty()) {
-            if(!AuthService()->ValidateSubPassword(NewUser.currentPassword)) {
-                return BadRequest(RESTAPI::Errors::InvalidPassword);
-            }
-        }
+		if (!NewUser.currentPassword.empty()) {
+			if (!AuthService()->ValidateSubPassword(NewUser.currentPassword)) {
+				return BadRequest(RESTAPI::Errors::InvalidPassword);
+			}
+		}
 
-        if(NewUser.name.empty())
-            NewUser.name = NewUser.email;
+		if (NewUser.name.empty())
+			NewUser.name = NewUser.email;
 
-        //  You cannot enable MFA during user creation
-        NewUser.userTypeProprietaryInfo.mfa.enabled = false;
-        NewUser.userTypeProprietaryInfo.mfa.method = "";
-        NewUser.userTypeProprietaryInfo.mobiles.clear();
-        NewUser.userTypeProprietaryInfo.authenticatorSecret.clear();
+		//  You cannot enable MFA during user creation
+		NewUser.userTypeProprietaryInfo.mfa.enabled = false;
+		NewUser.userTypeProprietaryInfo.mfa.method = "";
+		NewUser.userTypeProprietaryInfo.mobiles.clear();
+		NewUser.userTypeProprietaryInfo.authenticatorSecret.clear();
 
-        if(!StorageService()->SubDB().CreateUser(UserInfo_.userinfo.email, NewUser)) {
-            Logger_.information(fmt::format("Could not add user '{}'.",NewUser.email));
-            return BadRequest(RESTAPI::Errors::RecordNotCreated);
-        }
+		if (!StorageService()->SubDB().CreateUser(UserInfo_.userinfo.email, NewUser)) {
+			Logger_.information(fmt::format("Could not add user '{}'.", NewUser.email));
+			return BadRequest(RESTAPI::Errors::RecordNotCreated);
+		}
 
-        if(GetParameter("email_verification","false")=="true") {
-            if(AuthService::VerifySubEmail(NewUser))
-                Logger_.information(fmt::format("Verification e-mail requested for {}",NewUser.email));
-            StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,NewUser.id,NewUser);
-        }
+		if (GetParameter("email_verification", "false") == "true") {
+			if (AuthService::VerifySubEmail(NewUser))
+				Logger_.information(
+					fmt::format("Verification e-mail requested for {}", NewUser.email));
+			StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, NewUser.id, NewUser);
+		}
 
-        if(!StorageService()->SubDB().GetUserByEmail(NewUser.email, NewUser)) {
-            Logger_.information(fmt::format("User '{}' but not retrieved.",NewUser.email));
-            return NotFound();
-        }
+		if (!StorageService()->SubDB().GetUserByEmail(NewUser.email, NewUser)) {
+			Logger_.information(fmt::format("User '{}' but not retrieved.", NewUser.email));
+			return NotFound();
+		}
 
-        Poco::JSON::Object  UserInfoObject;
-        Sanitize(UserInfo_, NewUser);
-        NewUser.to_json(UserInfoObject);
-        ReturnObject(UserInfoObject);
-        Logger_.information(fmt::format("User '{}' has been added by '{}')",NewUser.email, UserInfo_.userinfo.email));
-    }
+		Poco::JSON::Object UserInfoObject;
+		Sanitize(UserInfo_, NewUser);
+		NewUser.to_json(UserInfoObject);
+		ReturnObject(UserInfoObject);
+		Logger_.information(fmt::format("User '{}' has been added by '{}')", NewUser.email,
+										UserInfo_.userinfo.email));
+	}
 
-    void RESTAPI_subuser_handler::DoPut() {
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+	void RESTAPI_subuser_handler::DoPut() {
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        SecurityObjects::UserInfo   Existing;
-        if(!StorageService()->SubDB().GetUserById(Id,Existing)) {
-            return NotFound();
-        }
+		SecurityObjects::UserInfo Existing;
+		if (!StorageService()->SubDB().GetUserById(Id, Existing)) {
+			return NotFound();
+		}
 
-        if(!Internal_ && !ACLProcessor::Can(UserInfo_.userinfo,Existing,ACLProcessor::MODIFY)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!Internal_ && !ACLProcessor::Can(UserInfo_.userinfo, Existing, ACLProcessor::MODIFY)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(GetBoolParameter("resetMFA")) {
-            if( (UserInfo_.userinfo.userRole == SecurityObjects::ROOT) ||
-                (UserInfo_.userinfo.userRole == SecurityObjects::ADMIN && Existing.userRole!=SecurityObjects::ROOT) ||
-                (UserInfo_.userinfo.id == Id)) {
-                Existing.userTypeProprietaryInfo.mfa.enabled = false;
-                Existing.userTypeProprietaryInfo.mfa.method.clear();
-                Existing.userTypeProprietaryInfo.mobiles.clear();
-                Existing.modified = OpenWifi::Now();
-                Existing.notes.push_back( SecurityObjects::NoteInfo{
-                        .created=OpenWifi::Now(),
-                        .createdBy=UserInfo_.userinfo.email,
-                        .note="MFA Reset by " + UserInfo_.userinfo.email});
-                StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,Id,Existing);
-                SecurityObjects::UserInfo   NewUserInfo;
-                StorageService()->SubDB().GetUserByEmail(UserInfo_.userinfo.email,NewUserInfo);
-                Poco::JSON::Object  ModifiedObject;
-                Sanitize(UserInfo_, NewUserInfo);
-                NewUserInfo.to_json(ModifiedObject);
-                return ReturnObject(ModifiedObject);
-            } else {
-                return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-            }
-        }
+		if (GetBoolParameter("resetMFA")) {
+			if ((UserInfo_.userinfo.userRole == SecurityObjects::ROOT) ||
+				(UserInfo_.userinfo.userRole == SecurityObjects::ADMIN &&
+				 Existing.userRole != SecurityObjects::ROOT) ||
+				(UserInfo_.userinfo.id == Id)) {
+				Existing.userTypeProprietaryInfo.mfa.enabled = false;
+				Existing.userTypeProprietaryInfo.mfa.method.clear();
+				Existing.userTypeProprietaryInfo.mobiles.clear();
+				Existing.modified = OpenWifi::Now();
+				Existing.notes.push_back(
+					SecurityObjects::NoteInfo{.created = OpenWifi::Now(),
+											  .createdBy = UserInfo_.userinfo.email,
+											  .note = "MFA Reset by " + UserInfo_.userinfo.email});
+				StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, Id, Existing);
+				SecurityObjects::UserInfo NewUserInfo;
+				StorageService()->SubDB().GetUserByEmail(UserInfo_.userinfo.email, NewUserInfo);
+				Poco::JSON::Object ModifiedObject;
+				Sanitize(UserInfo_, NewUserInfo);
+				NewUserInfo.to_json(ModifiedObject);
+				return ReturnObject(ModifiedObject);
+			} else {
+				return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+			}
+		}
 
-        if(GetBoolParameter("forgotPassword")) {
-            Existing.changePassword = true;
-            Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}", Request->clientAddress().toString(), Existing.email));
+		if (GetBoolParameter("forgotPassword")) {
+			Existing.changePassword = true;
+			Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}",
+											Request->clientAddress().toString(), Existing.email));
 
-            SecurityObjects::ActionLink NewLink;
-            NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_FORGOT_PASSWORD;
-            NewLink.id = MicroServiceCreateUUID();
-            NewLink.userId = Existing.id;
-            NewLink.created = OpenWifi::Now();
-            NewLink.expires = NewLink.created + (24*60*60);
-            NewLink.userAction = false;
-            StorageService()->ActionLinksDB().CreateAction(NewLink);
+			SecurityObjects::ActionLink NewLink;
+			NewLink.action = OpenWifi::SecurityObjects::LinkActions::SUB_FORGOT_PASSWORD;
+			NewLink.id = MicroServiceCreateUUID();
+			NewLink.userId = Existing.id;
+			NewLink.created = OpenWifi::Now();
+			NewLink.expires = NewLink.created + (24 * 60 * 60);
+			NewLink.userAction = false;
+			StorageService()->ActionLinksDB().CreateAction(NewLink);
 
-            return OK();
-        }
+			return OK();
+		}
 
-        SecurityObjects::UserInfo   NewUser;
-        const auto & RawObject = ParsedBody_;
-        if(!NewUser.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		SecurityObjects::UserInfo NewUser;
+		const auto &RawObject = ParsedBody_;
+		if (!NewUser.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        // some basic validations
-        if(RawObject->has("userRole") &&
-            (SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString())==SecurityObjects::UNKNOWN ||
-            SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString())==SecurityObjects::SUBSCRIBER)) {
-            return BadRequest(RESTAPI::Errors::InvalidUserRole);
-        }
+		// some basic validations
+		if (RawObject->has("userRole") &&
+			(SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString()) ==
+				 SecurityObjects::UNKNOWN ||
+			 SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString()) ==
+				 SecurityObjects::SUBSCRIBER)) {
+			return BadRequest(RESTAPI::Errors::InvalidUserRole);
+		}
 
-        // The only valid things to change are: changePassword, name,
-        AssignIfPresent(RawObject,"name", Existing.name);
-        AssignIfPresent(RawObject,"description", Existing.description);
-        AssignIfPresent(RawObject,"owner", Existing.owner);
-        AssignIfPresent(RawObject,"location", Existing.location);
-        AssignIfPresent(RawObject,"locale", Existing.locale);
-        AssignIfPresent(RawObject,"changePassword", Existing.changePassword);
-        AssignIfPresent(RawObject,"suspended", Existing.suspended);
-        AssignIfPresent(RawObject,"blackListed", Existing.blackListed);
+		// The only valid things to change are: changePassword, name,
+		AssignIfPresent(RawObject, "name", Existing.name);
+		AssignIfPresent(RawObject, "description", Existing.description);
+		AssignIfPresent(RawObject, "owner", Existing.owner);
+		AssignIfPresent(RawObject, "location", Existing.location);
+		AssignIfPresent(RawObject, "locale", Existing.locale);
+		AssignIfPresent(RawObject, "changePassword", Existing.changePassword);
+		AssignIfPresent(RawObject, "suspended", Existing.suspended);
+		AssignIfPresent(RawObject, "blackListed", Existing.blackListed);
 
-        if(RawObject->has("userRole")) {
-            auto NewRole = SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString());
-            if(NewRole!=Existing.userRole) {
-                if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && NewRole==SecurityObjects::ROOT) {
-                    return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-                }
-                if(Id==UserInfo_.userinfo.id) {
-                    return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-                }
-                Existing.userRole = NewRole;
-            }
-        }
+		if (RawObject->has("userRole")) {
+			auto NewRole =
+				SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString());
+			if (NewRole != Existing.userRole) {
+				if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT &&
+					NewRole == SecurityObjects::ROOT) {
+					return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+				}
+				if (Id == UserInfo_.userinfo.id) {
+					return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+				}
+				Existing.userRole = NewRole;
+			}
+		}
 
-        if(RawObject->has("notes")) {
-            SecurityObjects::NoteInfoVec NIV;
-            NIV = RESTAPI_utils::to_object_array<SecurityObjects::NoteInfo>(RawObject->get("notes").toString());
-            for(auto const &i:NIV) {
-                SecurityObjects::NoteInfo   ii{.created=(uint64_t)OpenWifi::Now(), .createdBy=UserInfo_.userinfo.email, .note=i.note};
-                Existing.notes.push_back(ii);
-            }
-        }
-        if(RawObject->has("currentPassword")) {
-            if(!AuthService()->ValidateSubPassword(RawObject->get("currentPassword").toString())) {
-                return BadRequest(RESTAPI::Errors::InvalidPassword);
-            }
-            if(!AuthService()->SetPassword(RawObject->get("currentPassword").toString(),Existing)) {
-                return BadRequest(RESTAPI::Errors::PasswordRejected);
-            }
-        }
+		if (RawObject->has("notes")) {
+			SecurityObjects::NoteInfoVec NIV;
+			NIV = RESTAPI_utils::to_object_array<SecurityObjects::NoteInfo>(
+				RawObject->get("notes").toString());
+			for (auto const &i : NIV) {
+				SecurityObjects::NoteInfo ii{.created = (uint64_t)OpenWifi::Now(),
+											 .createdBy = UserInfo_.userinfo.email,
+											 .note = i.note};
+				Existing.notes.push_back(ii);
+			}
+		}
+		if (RawObject->has("currentPassword")) {
+			if (!AuthService()->ValidateSubPassword(RawObject->get("currentPassword").toString())) {
+				return BadRequest(RESTAPI::Errors::InvalidPassword);
+			}
+			if (!AuthService()->SetPassword(RawObject->get("currentPassword").toString(),
+											Existing)) {
+				return BadRequest(RESTAPI::Errors::PasswordRejected);
+			}
+		}
 
-        if(GetParameter("email_verification","false")=="true") {
-            if(AuthService::VerifySubEmail(Existing))
-                Logger_.information(fmt::format("Verification e-mail requested for {}",Existing.email));
-        }
+		if (GetParameter("email_verification", "false") == "true") {
+			if (AuthService::VerifySubEmail(Existing))
+				Logger_.information(
+					fmt::format("Verification e-mail requested for {}", Existing.email));
+		}
 
-        if(RawObject->has("userTypeProprietaryInfo")) {
-            if(NewUser.userTypeProprietaryInfo.mfa.enabled) {
-                if (!MFAMETHODS::Validate(NewUser.userTypeProprietaryInfo.mfa.method)) {
-                    return BadRequest(RESTAPI::Errors::BadMFAMethod);
-                }
+		if (RawObject->has("userTypeProprietaryInfo")) {
+			if (NewUser.userTypeProprietaryInfo.mfa.enabled) {
+				if (!MFAMETHODS::Validate(NewUser.userTypeProprietaryInfo.mfa.method)) {
+					return BadRequest(RESTAPI::Errors::BadMFAMethod);
+				}
 
-                if( NewUser.userTypeProprietaryInfo.mfa.enabled &&
-                    NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS &&
-                    !SMSSender()->Enabled()) {
-                    return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
-                }
+				if (NewUser.userTypeProprietaryInfo.mfa.enabled &&
+					NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS &&
+					!SMSSender()->Enabled()) {
+					return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
+				}
 
-                if( NewUser.userTypeProprietaryInfo.mfa.enabled &&
-                    NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL &&
-                    !SMTPMailerService()->Enabled()) {
-                    return BadRequest(RESTAPI::Errors::EMailMFANotEnabled);
-                }
+				if (NewUser.userTypeProprietaryInfo.mfa.enabled &&
+					NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL &&
+					!SMTPMailerService()->Enabled()) {
+					return BadRequest(RESTAPI::Errors::EMailMFANotEnabled);
+				}
 
-                Existing.userTypeProprietaryInfo.mfa.method = NewUser.userTypeProprietaryInfo.mfa.method;
-                Existing.userTypeProprietaryInfo.mfa.enabled = true;
+				Existing.userTypeProprietaryInfo.mfa.method =
+					NewUser.userTypeProprietaryInfo.mfa.method;
+				Existing.userTypeProprietaryInfo.mfa.enabled = true;
 
-                if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS) {
-                    if(NewUser.userTypeProprietaryInfo.mobiles.empty()) {
-                        return BadRequest(RESTAPI::Errors::NeedMobileNumber);
-                    }
-                    if (!SMSSender()->IsNumberValid(NewUser.userTypeProprietaryInfo.mobiles[0].number,UserInfo_.userinfo.email)) {
-                        return BadRequest(RESTAPI::Errors::NeedMobileNumber);
-                    }
-                    Existing.userTypeProprietaryInfo.mobiles = NewUser.userTypeProprietaryInfo.mobiles;
-                    Existing.userTypeProprietaryInfo.mobiles[0].verified = true;
-                    Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                } else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::AUTHENTICATOR) {
-                    std::string Secret;
-                    Existing.userTypeProprietaryInfo.mobiles.clear();
-                    if(Existing.userTypeProprietaryInfo.authenticatorSecret.empty() && TotpCache()->CompleteValidation(UserInfo_.userinfo,false,Secret)) {
-                        Existing.userTypeProprietaryInfo.authenticatorSecret = Secret;
-                    } else if (!Existing.userTypeProprietaryInfo.authenticatorSecret.empty()) {
-                        // we allow someone to use their old secret
-                    } else {
-                        return BadRequest(RESTAPI::Errors::AuthenticatorVerificationIncomplete);
-                    }
-                } else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL) {
-                    Existing.userTypeProprietaryInfo.mobiles.clear();
-                    Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                }
-            } else {
-                Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                Existing.userTypeProprietaryInfo.mobiles.clear();
-                Existing.userTypeProprietaryInfo.mfa.enabled = false;
-            }
-        }
+				if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS) {
+					if (NewUser.userTypeProprietaryInfo.mobiles.empty()) {
+						return BadRequest(RESTAPI::Errors::NeedMobileNumber);
+					}
+					if (!SMSSender()->IsNumberValid(
+							NewUser.userTypeProprietaryInfo.mobiles[0].number,
+							UserInfo_.userinfo.email)) {
+						return BadRequest(RESTAPI::Errors::NeedMobileNumber);
+					}
+					Existing.userTypeProprietaryInfo.mobiles =
+						NewUser.userTypeProprietaryInfo.mobiles;
+					Existing.userTypeProprietaryInfo.mobiles[0].verified = true;
+					Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				} else if (NewUser.userTypeProprietaryInfo.mfa.method ==
+						   MFAMETHODS::AUTHENTICATOR) {
+					std::string Secret;
+					Existing.userTypeProprietaryInfo.mobiles.clear();
+					if (Existing.userTypeProprietaryInfo.authenticatorSecret.empty() &&
+						TotpCache()->CompleteValidation(UserInfo_.userinfo, false, Secret)) {
+						Existing.userTypeProprietaryInfo.authenticatorSecret = Secret;
+					} else if (!Existing.userTypeProprietaryInfo.authenticatorSecret.empty()) {
+						// we allow someone to use their old secret
+					} else {
+						return BadRequest(RESTAPI::Errors::AuthenticatorVerificationIncomplete);
+					}
+				} else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL) {
+					Existing.userTypeProprietaryInfo.mobiles.clear();
+					Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				}
+			} else {
+				Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				Existing.userTypeProprietaryInfo.mobiles.clear();
+				Existing.userTypeProprietaryInfo.mfa.enabled = false;
+			}
+		}
 
-        if(StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email,Id,Existing)) {
-            SecurityObjects::UserInfo   NewUserInfo;
-            StorageService()->SubDB().GetUserById(Id,NewUserInfo);
-            Poco::JSON::Object  ModifiedObject;
-            Sanitize(UserInfo_, NewUserInfo);
-            NewUserInfo.to_json(ModifiedObject);
-            return ReturnObject(ModifiedObject);
-        }
-        BadRequest(RESTAPI::Errors::RecordNotUpdated);
-    }
-}
+		if (StorageService()->SubDB().UpdateUserInfo(UserInfo_.userinfo.email, Id, Existing)) {
+			SecurityObjects::UserInfo NewUserInfo;
+			StorageService()->SubDB().GetUserById(Id, NewUserInfo);
+			Poco::JSON::Object ModifiedObject;
+			Sanitize(UserInfo_, NewUserInfo);
+			NewUserInfo.to_json(ModifiedObject);
+			return ReturnObject(ModifiedObject);
+		}
+		BadRequest(RESTAPI::Errors::RecordNotUpdated);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subuser_handler.h

@@ -7,25 +7,24 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_subuser_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_subuser_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>
-                         {Poco::Net::HTTPRequest::HTTP_POST,
-                          Poco::Net::HTTPRequest::HTTP_GET,
-                          Poco::Net::HTTPRequest::HTTP_PUT,
-                          Poco::Net::HTTPRequest::HTTP_DELETE,
-                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                          Server,
-                          TransactionId,
-                          Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/subuser/{id}"}; };
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final;
-        void DoPut() final;
-    private:
+	class RESTAPI_subuser_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_subuser_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/subuser/{id}"}; };
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final;
+		void DoPut() final;
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subusers_handler.cpp

@@ -3,77 +3,84 @@
 //
 
 #include "RESTAPI_subusers_handler.h"
-#include "StorageService.h"
 #include "RESTAPI/RESTAPI_db_helpers.h"
+#include "StorageService.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_subusers_handler::DoGet() {
-        bool IdOnly = GetBoolParameter("idOnly");
-        auto operatorId = GetParameter("operatorId");
-        auto nameSearch = GetParameter("nameSearch");
-        auto emailSearch = GetParameter("emailSearch");
+	void RESTAPI_subusers_handler::DoGet() {
+		bool IdOnly = GetBoolParameter("idOnly");
+		auto operatorId = GetParameter("operatorId");
+		auto nameSearch = GetParameter("nameSearch");
+		auto emailSearch = GetParameter("emailSearch");
 
-        std::string baseQuery;
-        if(!nameSearch.empty() || !emailSearch.empty()) {
-            if(!nameSearch.empty())
-                baseQuery = fmt::format(" Lower(name) like('%{}%') ", ORM::Escape(Poco::toLower(nameSearch)) );
-            if(!emailSearch.empty())
-                baseQuery += baseQuery.empty() ? fmt::format(" Lower(email) like('%{}%') ", ORM::Escape(Poco::toLower(emailSearch)))
-                : fmt::format(" and Lower(email) like('%{}%') ", ORM::Escape(Poco::toLower(emailSearch)));
-        }
+		std::string baseQuery;
+		if (!nameSearch.empty() || !emailSearch.empty()) {
+			if (!nameSearch.empty())
+				baseQuery = fmt::format(" Lower(name) like('%{}%') ",
+										ORM::Escape(Poco::toLower(nameSearch)));
+			if (!emailSearch.empty())
+				baseQuery += baseQuery.empty()
+								 ? fmt::format(" Lower(email) like('%{}%') ",
+											   ORM::Escape(Poco::toLower(emailSearch)))
+								 : fmt::format(" and Lower(email) like('%{}%') ",
+											   ORM::Escape(Poco::toLower(emailSearch)));
+		}
 
-        if(QB_.CountOnly) {
-            std::string whereClause;
-            if(!operatorId.empty() && Utils::ValidUUID(operatorId)) {
-                whereClause = baseQuery.empty() ? fmt::format(" owner='{}' ", operatorId) :
-                              fmt::format(" owner='{}' and {} ", operatorId, baseQuery);
-                auto count = StorageService()->SubDB().Count(whereClause);
-                return ReturnCountOnly(count);
-            }
-            auto count = StorageService()->UserDB().Count();
-            return ReturnCountOnly(count);
-        } else if(QB_.Select.empty()) {
-            std::string whereClause;
-            if(!operatorId.empty() && Utils::ValidUUID(operatorId)) {
-                whereClause = baseQuery.empty() ? fmt::format(" owner='{}' ", operatorId) :
-                              fmt::format(" owner='{}' and {} ", operatorId, baseQuery);
-            }
+		if (QB_.CountOnly) {
+			std::string whereClause;
+			if (!operatorId.empty() && Utils::ValidUUID(operatorId)) {
+				whereClause = baseQuery.empty()
+								  ? fmt::format(" owner='{}' ", operatorId)
+								  : fmt::format(" owner='{}' and {} ", operatorId, baseQuery);
+				auto count = StorageService()->SubDB().Count(whereClause);
+				return ReturnCountOnly(count);
+			}
+			auto count = StorageService()->UserDB().Count();
+			return ReturnCountOnly(count);
+		} else if (QB_.Select.empty()) {
+			std::string whereClause;
+			if (!operatorId.empty() && Utils::ValidUUID(operatorId)) {
+				whereClause = baseQuery.empty()
+								  ? fmt::format(" owner='{}' ", operatorId)
+								  : fmt::format(" owner='{}' and {} ", operatorId, baseQuery);
+			}
 
-            SecurityObjects::UserInfoList   Users;
-            if (StorageService()->SubDB().GetUsers(QB_.Offset, QB_.Limit, Users.users, whereClause)) {
-                for (auto &i : Users.users) {
-                    Sanitize(UserInfo_, i);
-                }
-            }
+			SecurityObjects::UserInfoList Users;
+			if (StorageService()->SubDB().GetUsers(QB_.Offset, QB_.Limit, Users.users,
+												   whereClause)) {
+				for (auto &i : Users.users) {
+					Sanitize(UserInfo_, i);
+				}
+			}
 
-            if(IdOnly) {
-                Poco::JSON::Array   Arr;
-                Poco::JSON::Object  Answer;
+			if (IdOnly) {
+				Poco::JSON::Array Arr;
+				Poco::JSON::Object Answer;
 
-                for(const auto &i:Users.users) {
-                    Arr.add(i.id);
-                }
-                Answer.set("users",Arr);
-                return ReturnObject(Answer);
-            }
+				for (const auto &i : Users.users) {
+					Arr.add(i.id);
+				}
+				Answer.set("users", Arr);
+				return ReturnObject(Answer);
+			}
 
-            Poco::JSON::Object  Answer;
-            Users.to_json(Answer);
-            return ReturnObject(Answer);
-        } else {
-            SecurityObjects::UserInfoList   Users;
-            for(auto &i:SelectedRecords()) {
-                SecurityObjects::UserInfo   UInfo;
-                if(StorageService()->SubDB().GetUserById(i,UInfo)) {
-                    Poco::JSON::Object Obj;
-                    Sanitize(UserInfo_, UInfo);
-                    Users.users.emplace_back(UInfo);
-                }
-            }
-            Poco::JSON::Object Answer;
-            Users.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-    }
-}
+			Poco::JSON::Object Answer;
+			Users.to_json(Answer);
+			return ReturnObject(Answer);
+		} else {
+			SecurityObjects::UserInfoList Users;
+			for (auto &i : SelectedRecords()) {
+				SecurityObjects::UserInfo UInfo;
+				if (StorageService()->SubDB().GetUserById(i, UInfo)) {
+					Poco::JSON::Object Obj;
+					Sanitize(UserInfo_, UInfo);
+					Users.users.emplace_back(UInfo);
+				}
+			}
+			Poco::JSON::Object Answer;
+			Users.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_subusers_handler.h

@@ -7,20 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_subusers_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_subusers_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>
-                         {Poco::Net::HTTPRequest::HTTP_GET,
-                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                          Server,
-                          TransactionId,
-                          Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/subusers"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-};
+	class RESTAPI_subusers_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_subusers_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								 RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								 bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/subusers"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+}; // namespace OpenWifi

src/RESTAPI/RESTAPI_systemSecret_handler.cpp

@@ -7,92 +7,90 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_systemSecret_handler::DoGet() {
-        if(!Internal_ && UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+	void RESTAPI_systemSecret_handler::DoGet() {
+		if (!Internal_ && UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(GetBoolParameter("all")) {
-            auto Store = SecretStore()->Store();
-            Poco::JSON::Array   Entries;
-            Poco::JSON::Object  List;
+		if (GetBoolParameter("all")) {
+			auto Store = SecretStore()->Store();
+			Poco::JSON::Array Entries;
+			Poco::JSON::Object List;
 
-            for(const auto &[Key,Value]:Store) {
-                Poco::JSON::Object  E;
-                E.set("key",Key);
-                E.set("value",Value);
-                Entries.add(E);
-            }
-            List.set("secrets",Entries);
-            return ReturnObject(List);
-        }
+			for (const auto &[Key, Value] : Store) {
+				Poco::JSON::Object E;
+				E.set("key", Key);
+				E.set("value", Value);
+				Entries.add(E);
+			}
+			List.set("secrets", Entries);
+			return ReturnObject(List);
+		}
 
-        if(GetBoolParameter("dictionary")) {
-            static std::vector<std::pair<std::string,std::string>> KnownKeys =
-                    {
-                            { "google.maps.apikey" , "A Google Key specific for the Google MAPS API."},
-                            { "iptocountry.ipinfo.token", "IPInfo.io service token."},
-                            { "iptocountry.ipdata.apikey", "IPData.co API Key."},
-                            { "iptocountry.ip2location.apikey", "IP2Location.com API Key"}
-                    };
+		if (GetBoolParameter("dictionary")) {
+			static std::vector<std::pair<std::string, std::string>> KnownKeys = {
+				{"google.maps.apikey", "A Google Key specific for the Google MAPS API."},
+				{"iptocountry.ipinfo.token", "IPInfo.io service token."},
+				{"iptocountry.ipdata.apikey", "IPData.co API Key."},
+				{"iptocountry.ip2location.apikey", "IP2Location.com API Key"}};
 
-            Poco::JSON::Object  Answer;
-            Poco::JSON::Array   Entries;
-            for(const auto &[key,description]:KnownKeys) {
-                Poco::JSON::Object  E;
-                E.set("key",key);
-                E.set("description",description);
-                Entries.add(E);
-            }
-            Answer.set("knownKeys", Entries);
-            return ReturnObject(Answer);
-        }
+			Poco::JSON::Object Answer;
+			Poco::JSON::Array Entries;
+			for (const auto &[key, description] : KnownKeys) {
+				Poco::JSON::Object E;
+				E.set("key", key);
+				E.set("description", description);
+				Entries.add(E);
+			}
+			Answer.set("knownKeys", Entries);
+			return ReturnObject(Answer);
+		}
 
-        auto Key = GetBinding("secret");
-        if(Key.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		auto Key = GetBinding("secret");
+		if (Key.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        std::string Value;
-        if(SecretStore()->Get(Key,Value,"")) {
-            Poco::JSON::Object  Answer;
-            Answer.set("key", Key);
-            Answer.set("value", Value);
-            return ReturnObject(Answer);
-        }
-        return NotFound();
-    }
+		std::string Value;
+		if (SecretStore()->Get(Key, Value, "")) {
+			Poco::JSON::Object Answer;
+			Answer.set("key", Key);
+			Answer.set("value", Value);
+			return ReturnObject(Answer);
+		}
+		return NotFound();
+	}
 
-    void RESTAPI_systemSecret_handler::DoDelete() {
-        if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+	void RESTAPI_systemSecret_handler::DoDelete() {
+		if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        auto Key = GetBinding("secret");
-        if(Key.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		auto Key = GetBinding("secret");
+		if (Key.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        SecretStore()->Remove(Key);
-        return OK();
-    }
+		SecretStore()->Remove(Key);
+		return OK();
+	}
 
-    void RESTAPI_systemSecret_handler::DoPut() {
-        if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+	void RESTAPI_systemSecret_handler::DoPut() {
+		if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        auto Key = GetBinding("secret");
-        auto Value = GetParameter("value","_______no_value_____");
-        if(Key.empty() || Value == "_______no_value_____") {
-            return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-        }
+		auto Key = GetBinding("secret");
+		auto Value = GetParameter("value", "_______no_value_____");
+		if (Key.empty() || Value == "_______no_value_____") {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
 
-        SecretStore()->Set(Key,Value);
-        Poco::JSON::Object  Answer;
-        Answer.set("key", Key);
-        Answer.set("value", Value);
-        return ReturnObject(Answer);
-    }
+		SecretStore()->Set(Key, Value);
+		Poco::JSON::Object Answer;
+		Answer.set("key", Key);
+		Answer.set("value", Value);
+		return ReturnObject(Answer);
+	}
 
-} // OpenWifi
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_systemSecret_handler.h

@@ -7,26 +7,23 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_systemSecret_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_systemSecret_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {
-                                                 Poco::Net::HTTPRequest::HTTP_GET,
-                                                 Poco::Net::HTTPRequest::HTTP_PUT,
-                                                 Poco::Net::HTTPRequest::HTTP_DELETE,
-                                                 Poco::Net::HTTPRequest::HTTP_OPTIONS
-                                         },
-                                 Server,
-                                 TransactionId,
-                                 Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/systemSecret/{secret}"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final;
-        void DoPut() final;
-    private:
+	class RESTAPI_systemSecret_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_systemSecret_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+									 RESTAPI_GenericServerAccounting &Server,
+									 uint64_t TransactionId, bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/systemSecret/{secret}"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final;
+		void DoPut() final;
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_system_endpoints_handler.cpp

@@ -8,18 +8,15 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_system_endpoints_handler::DoGet() {
-        auto Services = MicroServiceGetServices();
-        SecurityObjects::SystemEndpointList L;
-        for(const auto &i:Services) {
-            SecurityObjects::SystemEndpoint S{
-                .type = i.Type,
-                .id = i.Id,
-                .uri = i.PublicEndPoint};
-            L.endpoints.push_back(S);
-        }
-        Poco::JSON::Object  Obj;
-        L.to_json(Obj);
-        ReturnObject(Obj);
-    }
-}
+	void RESTAPI_system_endpoints_handler::DoGet() {
+		auto Services = MicroServiceGetServices();
+		SecurityObjects::SystemEndpointList L;
+		for (const auto &i : Services) {
+			SecurityObjects::SystemEndpoint S{.type = i.Type, .id = i.Id, .uri = i.PublicEndPoint};
+			L.endpoints.push_back(S);
+		}
+		Poco::JSON::Object Obj;
+		L.to_json(Obj);
+		ReturnObject(Obj);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_system_endpoints_handler.h

@@ -7,19 +7,19 @@
 #include "../framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_system_endpoints_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_system_endpoints_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
-                                                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                                          Server,
-                                                          TransactionId,
-                                                          Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/systemEndpoints"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
+	class RESTAPI_system_endpoints_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_system_endpoints_handler(const RESTAPIHandler::BindingMap &bindings,
+										 Poco::Logger &L, RESTAPI_GenericServerAccounting &Server,
+										 uint64_t TransactionId, bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/systemEndpoints"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_totp_handler.cpp

@@ -7,29 +7,30 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_totp_handler::DoGet() {
+	void RESTAPI_totp_handler::DoGet() {
 
-        auto Reset = GetBoolParameter("reset",false);
-        std::string QRCode;
-        if(TotpCache()->StartValidation(UserInfo_.userinfo,false,QRCode,Reset)) {
-            return SendFileContent(QRCode, "image/svg+xml","qrcode.svg");
-        }
-        return BadRequest(RESTAPI::Errors::InvalidCommand);
-    }
+		auto Reset = GetBoolParameter("reset", false);
+		std::string QRCode;
+		if (TotpCache()->StartValidation(UserInfo_.userinfo, false, QRCode, Reset)) {
+			return SendFileContent(QRCode, "image/svg+xml", "qrcode.svg");
+		}
+		return BadRequest(RESTAPI::Errors::InvalidCommand);
+	}
 
-    void RESTAPI_totp_handler::DoPut() {
-        auto Value = GetParameter("value","");
-        auto nextIndex = GetParameter("index",0);
-        bool moreCodes=false;
+	void RESTAPI_totp_handler::DoPut() {
+		auto Value = GetParameter("value", "");
+		auto nextIndex = GetParameter("index", 0);
+		bool moreCodes = false;
 
-        RESTAPI::Errors::msg Err;
-        if(TotpCache()->ContinueValidation(UserInfo_.userinfo,false,Value,nextIndex,moreCodes, Err)) {
-            Poco::JSON::Object Answer;
-            Answer.set("nextIndex", nextIndex);
-            Answer.set("moreCodes", moreCodes);
-            return ReturnObject(Answer);
-        }
-        return BadRequest(Err);
-    }
+		RESTAPI::Errors::msg Err;
+		if (TotpCache()->ContinueValidation(UserInfo_.userinfo, false, Value, nextIndex, moreCodes,
+											Err)) {
+			Poco::JSON::Object Answer;
+			Answer.set("nextIndex", nextIndex);
+			Answer.set("moreCodes", moreCodes);
+			return ReturnObject(Answer);
+		}
+		return BadRequest(Err);
+	}
 
-}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_totp_handler.h

@@ -7,25 +7,22 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_totp_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_totp_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {
-                                              Poco::Net::HTTPRequest::HTTP_GET,
-                                              Poco::Net::HTTPRequest::HTTP_PUT,
-                                              Poco::Net::HTTPRequest::HTTP_OPTIONS
-                                          },
-                                 Server,
-                                 TransactionId,
-                                 Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/totp"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final;
-    private:
+	class RESTAPI_totp_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_totp_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							 RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							 bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/totp"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final;
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_user_handler.cpp

@@ -3,327 +3,348 @@
 //
 
 #include "RESTAPI_user_handler.h"
-#include "StorageService.h"
-#include "framework/ow_constants.h"
-#include "SMSSender.h"
-#include "SMTPMailerService.h"
 #include "ACLProcessor.h"
 #include "AuthService.h"
-#include "RESTAPI/RESTAPI_db_helpers.h"
 #include "MFAServer.h"
+#include "RESTAPI/RESTAPI_db_helpers.h"
+#include "SMSSender.h"
+#include "SMTPMailerService.h"
+#include "StorageService.h"
 #include "TotpCache.h"
 #include "framework/MicroServiceFuncs.h"
+#include "framework/ow_constants.h"
 
 namespace OpenWifi {
 
-    void RESTAPI_user_handler::DoGet() {
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+	void RESTAPI_user_handler::DoGet() {
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        Poco::toLowerInPlace(Id);
-        std::string Arg;
-        SecurityObjects::UserInfo   UInfo;
-        if(HasParameter("byEmail",Arg) && Arg=="true") {
-            if(!StorageService()->UserDB().GetUserByEmail(Id,UInfo)) {
-                return NotFound();
-            }
-        } else if(!StorageService()->UserDB().GetUserById(Id,UInfo)) {
-            return NotFound();
-        }
+		Poco::toLowerInPlace(Id);
+		std::string Arg;
+		SecurityObjects::UserInfo UInfo;
+		if (HasParameter("byEmail", Arg) && Arg == "true") {
+			if (!StorageService()->UserDB().GetUserByEmail(Id, UInfo)) {
+				return NotFound();
+			}
+		} else if (!StorageService()->UserDB().GetUserById(Id, UInfo)) {
+			return NotFound();
+		}
 
-        if(!ACLProcessor::Can(UserInfo_.userinfo, UInfo,ACLProcessor::READ)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!ACLProcessor::Can(UserInfo_.userinfo, UInfo, ACLProcessor::READ)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        Poco::JSON::Object  UserInfoObject;
-        Sanitize(UserInfo_, UInfo);
-        UInfo.to_json(UserInfoObject);
-        ReturnObject(UserInfoObject);
-    }
+		Poco::JSON::Object UserInfoObject;
+		Sanitize(UserInfo_, UInfo);
+		UInfo.to_json(UserInfoObject);
+		ReturnObject(UserInfoObject);
+	}
 
-    void RESTAPI_user_handler::DoDelete() {
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+	void RESTAPI_user_handler::DoDelete() {
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        SecurityObjects::UserInfo UInfo;
-        if(!StorageService()->UserDB().GetUserById(Id,UInfo)) {
-            return NotFound();
-        }
+		SecurityObjects::UserInfo UInfo;
+		if (!StorageService()->UserDB().GetUserById(Id, UInfo)) {
+			return NotFound();
+		}
 
-        if(!ACLProcessor::Can(UserInfo_.userinfo, UInfo,ACLProcessor::DELETE)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!ACLProcessor::Can(UserInfo_.userinfo, UInfo, ACLProcessor::DELETE)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(!StorageService()->UserDB().DeleteUser(UserInfo_.userinfo.email,Id)) {
-            return NotFound();
-        }
+		if (!StorageService()->UserDB().DeleteUser(UserInfo_.userinfo.email, Id)) {
+			return NotFound();
+		}
 
-        AuthService()->DeleteUserFromCache(Id);
-        StorageService()->AvatarDB().DeleteAvatar(UserInfo_.userinfo.email,Id);
-        StorageService()->PreferencesDB().DeletePreferences(UserInfo_.userinfo.email,Id);
-        StorageService()->UserTokenDB().RevokeAllTokens(Id);
-        StorageService()->ApiKeyDB().RemoveAllApiKeys(Id);
-        Logger_.information(fmt::format("User '{}' deleted by '{}'.",Id,UserInfo_.userinfo.email));
-        OK();
-    }
+		AuthService()->DeleteUserFromCache(Id);
+		StorageService()->AvatarDB().DeleteAvatar(UserInfo_.userinfo.email, Id);
+		StorageService()->PreferencesDB().DeletePreferences(UserInfo_.userinfo.email, Id);
+		StorageService()->UserTokenDB().RevokeAllTokens(Id);
+		StorageService()->ApiKeyDB().RemoveAllApiKeys(Id);
+		Logger_.information(
+			fmt::format("User '{}' deleted by '{}'.", Id, UserInfo_.userinfo.email));
+		OK();
+	}
 
-    void RESTAPI_user_handler::DoPost() {
+	void RESTAPI_user_handler::DoPost() {
 
-        std::string Id = GetBinding("id", "");
-        if(Id!="0") {
-            return BadRequest(RESTAPI::Errors::IdMustBe0);
-        }
+		std::string Id = GetBinding("id", "");
+		if (Id != "0") {
+			return BadRequest(RESTAPI::Errors::IdMustBe0);
+		}
 
-        SecurityObjects::UserInfo   NewUser;
-        const auto & RawObject = ParsedBody_;
-        if(!NewUser.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		SecurityObjects::UserInfo NewUser;
+		const auto &RawObject = ParsedBody_;
+		if (!NewUser.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        if(NewUser.userRole == SecurityObjects::UNKNOWN) {
-            return BadRequest(RESTAPI::Errors::InvalidUserRole);
-        }
+		if (NewUser.userRole == SecurityObjects::UNKNOWN) {
+			return BadRequest(RESTAPI::Errors::InvalidUserRole);
+		}
 
-        if(UserInfo_.userinfo.userRole==SecurityObjects::ROOT) {
-            NewUser.owner = GetParameter("entity","");
-        } else {
-            NewUser.owner = UserInfo_.userinfo.owner;
-        }
+		if (UserInfo_.userinfo.userRole == SecurityObjects::ROOT) {
+			NewUser.owner = GetParameter("entity", "");
+		} else {
+			NewUser.owner = UserInfo_.userinfo.owner;
+		}
 
-        if(!ACLProcessor::Can(UserInfo_.userinfo,NewUser,ACLProcessor::CREATE)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!ACLProcessor::Can(UserInfo_.userinfo, NewUser, ACLProcessor::CREATE)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        Poco::toLowerInPlace(NewUser.email);
-        if(!Utils::ValidEMailAddress(NewUser.email)) {
-            return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
-        }
+		Poco::toLowerInPlace(NewUser.email);
+		if (!Utils::ValidEMailAddress(NewUser.email)) {
+			return BadRequest(RESTAPI::Errors::InvalidEmailAddress);
+		}
 
-        SecurityObjects::UserInfo   Existing;
-        if(StorageService()->SubDB().GetUserByEmail(NewUser.email,Existing)) {
-            return BadRequest(RESTAPI::Errors::UserAlreadyExists);
-        }
+		SecurityObjects::UserInfo Existing;
+		if (StorageService()->SubDB().GetUserByEmail(NewUser.email, Existing)) {
+			return BadRequest(RESTAPI::Errors::UserAlreadyExists);
+		}
 
-        if(!NewUser.currentPassword.empty()) {
-            if(!AuthService()->ValidatePassword(NewUser.currentPassword)) {
-                return BadRequest(RESTAPI::Errors::InvalidPassword);
-            }
-        }
+		if (!NewUser.currentPassword.empty()) {
+			if (!AuthService()->ValidatePassword(NewUser.currentPassword)) {
+				return BadRequest(RESTAPI::Errors::InvalidPassword);
+			}
+		}
 
-        if(NewUser.name.empty())
-            NewUser.name = NewUser.email;
+		if (NewUser.name.empty())
+			NewUser.name = NewUser.email;
 
-        //  You cannot enable MFA during user creation
-        NewUser.userTypeProprietaryInfo.mfa.enabled = false;
-        NewUser.userTypeProprietaryInfo.mfa.method = "";
-        NewUser.userTypeProprietaryInfo.mobiles.clear();
-        NewUser.userTypeProprietaryInfo.authenticatorSecret.clear();
-        NewUser.validated = true;
+		//  You cannot enable MFA during user creation
+		NewUser.userTypeProprietaryInfo.mfa.enabled = false;
+		NewUser.userTypeProprietaryInfo.mfa.method = "";
+		NewUser.userTypeProprietaryInfo.mobiles.clear();
+		NewUser.userTypeProprietaryInfo.authenticatorSecret.clear();
+		NewUser.validated = true;
 
-        if(!StorageService()->UserDB().CreateUser(NewUser.email,NewUser)) {
-            Logger_.information(fmt::format("Could not add user '{}'.",NewUser.email));
-            return BadRequest(RESTAPI::Errors::RecordNotCreated);
-        }
+		if (!StorageService()->UserDB().CreateUser(NewUser.email, NewUser)) {
+			Logger_.information(fmt::format("Could not add user '{}'.", NewUser.email));
+			return BadRequest(RESTAPI::Errors::RecordNotCreated);
+		}
 
-        if(GetBoolParameter("email_verification")) {
-            if(AuthService::VerifyEmail(NewUser))
-                Logger_.information(fmt::format("Verification e-mail requested for {}",NewUser.email));
-            StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email,NewUser.id,NewUser);
-        }
+		if (GetBoolParameter("email_verification")) {
+			if (AuthService::VerifyEmail(NewUser))
+				Logger_.information(
+					fmt::format("Verification e-mail requested for {}", NewUser.email));
+			StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email, NewUser.id,
+													  NewUser);
+		}
 
-        if(!StorageService()->UserDB().GetUserByEmail(NewUser.email, NewUser)) {
-            Logger_.information(fmt::format("User '{}' but not retrieved.",NewUser.email));
-            return NotFound();
-        }
+		if (!StorageService()->UserDB().GetUserByEmail(NewUser.email, NewUser)) {
+			Logger_.information(fmt::format("User '{}' but not retrieved.", NewUser.email));
+			return NotFound();
+		}
 
-        Poco::JSON::Object  UserInfoObject;
-        Sanitize(UserInfo_, NewUser);
-        NewUser.to_json(UserInfoObject);
-        ReturnObject(UserInfoObject);
-        Logger_.information(fmt::format("User '{}' has been added by '{}')",NewUser.email, UserInfo_.userinfo.email));
-    }
+		Poco::JSON::Object UserInfoObject;
+		Sanitize(UserInfo_, NewUser);
+		NewUser.to_json(UserInfoObject);
+		ReturnObject(UserInfoObject);
+		Logger_.information(fmt::format("User '{}' has been added by '{}')", NewUser.email,
+										UserInfo_.userinfo.email));
+	}
 
-    void RESTAPI_user_handler::DoPut() {
+	void RESTAPI_user_handler::DoPut() {
 
-        std::string Id = GetBinding("id", "");
-        if(Id.empty()) {
-            return BadRequest(RESTAPI::Errors::MissingUserID);
-        }
+		std::string Id = GetBinding("id", "");
+		if (Id.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingUserID);
+		}
 
-        SecurityObjects::UserInfo   Existing;
-        if(!StorageService()->UserDB().GetUserById(Id,Existing)) {
-            return NotFound();
-        }
+		SecurityObjects::UserInfo Existing;
+		if (!StorageService()->UserDB().GetUserById(Id, Existing)) {
+			return NotFound();
+		}
 
-        if(!ACLProcessor::Can(UserInfo_.userinfo,Existing,ACLProcessor::MODIFY)) {
-            return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-        }
+		if (!ACLProcessor::Can(UserInfo_.userinfo, Existing, ACLProcessor::MODIFY)) {
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
 
-        if(GetBoolParameter("resetMFA")) {
-            if( (UserInfo_.userinfo.userRole == SecurityObjects::ROOT) ||
-                (UserInfo_.userinfo.userRole == SecurityObjects::ADMIN && Existing.userRole!=SecurityObjects::ROOT) ||
-                (UserInfo_.userinfo.id == Id)) {
-                Existing.userTypeProprietaryInfo.mfa.enabled = false;
-                Existing.userTypeProprietaryInfo.mfa.method.clear();
-                Existing.userTypeProprietaryInfo.mobiles.clear();
-                Existing.modified = OpenWifi::Now();
-                Existing.notes.push_back( SecurityObjects::NoteInfo{
-                            .created=OpenWifi::Now(),
-                            .createdBy=UserInfo_.userinfo.email,
-                            .note="MFA Reset by " + UserInfo_.userinfo.email});
-                StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email,Id,Existing);
-                SecurityObjects::UserInfo   NewUserInfo;
-                StorageService()->UserDB().GetUserByEmail(UserInfo_.userinfo.email,NewUserInfo);
-                Poco::JSON::Object  ModifiedObject;
-                Sanitize(UserInfo_, NewUserInfo);
-                NewUserInfo.to_json(ModifiedObject);
-                return ReturnObject(ModifiedObject);
-            } else {
-                return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-            }
-        }
+		if (GetBoolParameter("resetMFA")) {
+			if ((UserInfo_.userinfo.userRole == SecurityObjects::ROOT) ||
+				(UserInfo_.userinfo.userRole == SecurityObjects::ADMIN &&
+				 Existing.userRole != SecurityObjects::ROOT) ||
+				(UserInfo_.userinfo.id == Id)) {
+				Existing.userTypeProprietaryInfo.mfa.enabled = false;
+				Existing.userTypeProprietaryInfo.mfa.method.clear();
+				Existing.userTypeProprietaryInfo.mobiles.clear();
+				Existing.modified = OpenWifi::Now();
+				Existing.notes.push_back(
+					SecurityObjects::NoteInfo{.created = OpenWifi::Now(),
+											  .createdBy = UserInfo_.userinfo.email,
+											  .note = "MFA Reset by " + UserInfo_.userinfo.email});
+				StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email, Id, Existing);
+				SecurityObjects::UserInfo NewUserInfo;
+				StorageService()->UserDB().GetUserByEmail(UserInfo_.userinfo.email, NewUserInfo);
+				Poco::JSON::Object ModifiedObject;
+				Sanitize(UserInfo_, NewUserInfo);
+				NewUserInfo.to_json(ModifiedObject);
+				return ReturnObject(ModifiedObject);
+			} else {
+				return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+			}
+		}
 
-        if(GetBoolParameter("forgotPassword")) {
-            Existing.changePassword = true;
-            Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}", Request->clientAddress().toString(), Existing.email));
-            SecurityObjects::ActionLink NewLink;
+		if (GetBoolParameter("forgotPassword")) {
+			Existing.changePassword = true;
+			Logger_.information(fmt::format("FORGOTTEN-PASSWORD({}): Request for {}",
+											Request->clientAddress().toString(), Existing.email));
+			SecurityObjects::ActionLink NewLink;
 
-            NewLink.action = OpenWifi::SecurityObjects::LinkActions::FORGOT_PASSWORD;
-            NewLink.id = MicroServiceCreateUUID();
-            NewLink.userId = Existing.id;
-            NewLink.created = OpenWifi::Now();
-            NewLink.expires = NewLink.created + (24*60*60);
-            NewLink.userAction = true;
-            StorageService()->ActionLinksDB().CreateAction(NewLink);
-            return OK();
-        }
+			NewLink.action = OpenWifi::SecurityObjects::LinkActions::FORGOT_PASSWORD;
+			NewLink.id = MicroServiceCreateUUID();
+			NewLink.userId = Existing.id;
+			NewLink.created = OpenWifi::Now();
+			NewLink.expires = NewLink.created + (24 * 60 * 60);
+			NewLink.userAction = true;
+			StorageService()->ActionLinksDB().CreateAction(NewLink);
+			return OK();
+		}
 
-        SecurityObjects::UserInfo   NewUser;
-        const auto & RawObject = ParsedBody_;
-        if(!NewUser.from_json(RawObject)) {
-            return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
-        }
+		SecurityObjects::UserInfo NewUser;
+		const auto &RawObject = ParsedBody_;
+		if (!NewUser.from_json(RawObject)) {
+			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
+		}
 
-        // some basic validations
-        if(RawObject->has("userRole") && SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString())==SecurityObjects::UNKNOWN) {
-            return BadRequest(RESTAPI::Errors::InvalidUserRole);
-        }
+		// some basic validations
+		if (RawObject->has("userRole") &&
+			SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString()) ==
+				SecurityObjects::UNKNOWN) {
+			return BadRequest(RESTAPI::Errors::InvalidUserRole);
+		}
 
-        if(RawObject->has("owner")) {
-            if (UserInfo_.userinfo.userRole == SecurityObjects::ROOT && Existing.owner.empty()) {
-                AssignIfPresent(RawObject, "owner", Existing.owner);
-            }
-        }
+		if (RawObject->has("owner")) {
+			if (UserInfo_.userinfo.userRole == SecurityObjects::ROOT && Existing.owner.empty()) {
+				AssignIfPresent(RawObject, "owner", Existing.owner);
+			}
+		}
 
-        // The only valid things to change are: changePassword, name,
-        AssignIfPresent(RawObject,"name", Existing.name);
-        AssignIfPresent(RawObject,"description", Existing.description);
-        AssignIfPresent(RawObject,"location", Existing.location);
-        AssignIfPresent(RawObject,"locale", Existing.locale);
-        AssignIfPresent(RawObject,"changePassword", Existing.changePassword);
-        AssignIfPresent(RawObject,"suspended", Existing.suspended);
-        AssignIfPresent(RawObject,"blackListed", Existing.blackListed);
+		// The only valid things to change are: changePassword, name,
+		AssignIfPresent(RawObject, "name", Existing.name);
+		AssignIfPresent(RawObject, "description", Existing.description);
+		AssignIfPresent(RawObject, "location", Existing.location);
+		AssignIfPresent(RawObject, "locale", Existing.locale);
+		AssignIfPresent(RawObject, "changePassword", Existing.changePassword);
+		AssignIfPresent(RawObject, "suspended", Existing.suspended);
+		AssignIfPresent(RawObject, "blackListed", Existing.blackListed);
 
-        if(RawObject->has("userRole")) {
-            auto NewRole = SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString());
-            if(NewRole!=Existing.userRole) {
-                if(UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && NewRole==SecurityObjects::ROOT) {
-                    return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-                }
-                if(Id==UserInfo_.userinfo.id) {
-                    return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-                }
-                Existing.userRole = NewRole;
-            }
-        }
+		if (RawObject->has("userRole")) {
+			auto NewRole =
+				SecurityObjects::UserTypeFromString(RawObject->get("userRole").toString());
+			if (NewRole != Existing.userRole) {
+				if (UserInfo_.userinfo.userRole != SecurityObjects::ROOT &&
+					NewRole == SecurityObjects::ROOT) {
+					return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+				}
+				if (Id == UserInfo_.userinfo.id) {
+					return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+				}
+				Existing.userRole = NewRole;
+			}
+		}
 
-        if(RawObject->has("notes")) {
-            SecurityObjects::NoteInfoVec NIV;
-            NIV = RESTAPI_utils::to_object_array<SecurityObjects::NoteInfo>(RawObject->get("notes").toString());
-            for(auto const &i:NIV) {
-                SecurityObjects::NoteInfo   ii{.created=(uint64_t)OpenWifi::Now(), .createdBy=UserInfo_.userinfo.email, .note=i.note};
-                Existing.notes.push_back(ii);
-            }
-        }
-        if(RawObject->has("currentPassword")) {
-            if(!AuthService()->ValidatePassword(RawObject->get("currentPassword").toString())) {
-                return BadRequest(RESTAPI::Errors::InvalidPassword);
-            }
-            if(!AuthService()->SetPassword(RawObject->get("currentPassword").toString(),Existing)) {
-                return BadRequest(RESTAPI::Errors::PasswordRejected);
-            }
-        }
+		if (RawObject->has("notes")) {
+			SecurityObjects::NoteInfoVec NIV;
+			NIV = RESTAPI_utils::to_object_array<SecurityObjects::NoteInfo>(
+				RawObject->get("notes").toString());
+			for (auto const &i : NIV) {
+				SecurityObjects::NoteInfo ii{.created = (uint64_t)OpenWifi::Now(),
+											 .createdBy = UserInfo_.userinfo.email,
+											 .note = i.note};
+				Existing.notes.push_back(ii);
+			}
+		}
+		if (RawObject->has("currentPassword")) {
+			if (!AuthService()->ValidatePassword(RawObject->get("currentPassword").toString())) {
+				return BadRequest(RESTAPI::Errors::InvalidPassword);
+			}
+			if (!AuthService()->SetPassword(RawObject->get("currentPassword").toString(),
+											Existing)) {
+				return BadRequest(RESTAPI::Errors::PasswordRejected);
+			}
+		}
 
-        if(GetBoolParameter("email_verification")) {
-            if(AuthService::VerifyEmail(Existing))
-                Logger_.information(fmt::format("Verification e-mail requested for {}",Existing.email));
-        }
+		if (GetBoolParameter("email_verification")) {
+			if (AuthService::VerifyEmail(Existing))
+				Logger_.information(
+					fmt::format("Verification e-mail requested for {}", Existing.email));
+		}
 
-        if(RawObject->has("userTypeProprietaryInfo")) {
-            if(NewUser.userTypeProprietaryInfo.mfa.enabled) {
-                if (!MFAMETHODS::Validate(NewUser.userTypeProprietaryInfo.mfa.method)) {
-                    return BadRequest(RESTAPI::Errors::BadMFAMethod);
-                }
+		if (RawObject->has("userTypeProprietaryInfo")) {
+			if (NewUser.userTypeProprietaryInfo.mfa.enabled) {
+				if (!MFAMETHODS::Validate(NewUser.userTypeProprietaryInfo.mfa.method)) {
+					return BadRequest(RESTAPI::Errors::BadMFAMethod);
+				}
 
-                if( NewUser.userTypeProprietaryInfo.mfa.enabled &&
-                    NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS &&
-                    !SMSSender()->Enabled()) {
-                    return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
-                }
+				if (NewUser.userTypeProprietaryInfo.mfa.enabled &&
+					NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS &&
+					!SMSSender()->Enabled()) {
+					return BadRequest(RESTAPI::Errors::SMSMFANotEnabled);
+				}
 
-                if( NewUser.userTypeProprietaryInfo.mfa.enabled &&
-                    NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL &&
-                    !SMTPMailerService()->Enabled()) {
-                    return BadRequest(RESTAPI::Errors::EMailMFANotEnabled);
-                }
+				if (NewUser.userTypeProprietaryInfo.mfa.enabled &&
+					NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL &&
+					!SMTPMailerService()->Enabled()) {
+					return BadRequest(RESTAPI::Errors::EMailMFANotEnabled);
+				}
 
-                Existing.userTypeProprietaryInfo.mfa.method = NewUser.userTypeProprietaryInfo.mfa.method;
-                Existing.userTypeProprietaryInfo.mfa.enabled = true;
+				Existing.userTypeProprietaryInfo.mfa.method =
+					NewUser.userTypeProprietaryInfo.mfa.method;
+				Existing.userTypeProprietaryInfo.mfa.enabled = true;
 
-                if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS) {
-                    if(NewUser.userTypeProprietaryInfo.mobiles.empty()) {
-                        return BadRequest(RESTAPI::Errors::NeedMobileNumber);
-                    }
-                    if (!SMSSender()->IsNumberValid(NewUser.userTypeProprietaryInfo.mobiles[0].number,UserInfo_.userinfo.email)) {
-                        return BadRequest(RESTAPI::Errors::NeedMobileNumber);
-                    }
-                    Existing.userTypeProprietaryInfo.mobiles = NewUser.userTypeProprietaryInfo.mobiles;
-                    Existing.userTypeProprietaryInfo.mobiles[0].verified = true;
-                    Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                } else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::AUTHENTICATOR) {
-                    std::string Secret;
-                    Existing.userTypeProprietaryInfo.mobiles.clear();
-                    if(Existing.userTypeProprietaryInfo.authenticatorSecret.empty() && TotpCache()->CompleteValidation(UserInfo_.userinfo,false,Secret)) {
-                        Existing.userTypeProprietaryInfo.authenticatorSecret = Secret;
-                    } else if (!Existing.userTypeProprietaryInfo.authenticatorSecret.empty()) {
-                        // we allow someone to use their old secret
-                    } else {
-                        return BadRequest(RESTAPI::Errors::AuthenticatorVerificationIncomplete);
-                    }
-                } else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL) {
-                    Existing.userTypeProprietaryInfo.mobiles.clear();
-                    Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                }
-            } else {
-                Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
-                Existing.userTypeProprietaryInfo.mobiles.clear();
-                Existing.userTypeProprietaryInfo.mfa.enabled = false;
-            }
-        }
+				if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::SMS) {
+					if (NewUser.userTypeProprietaryInfo.mobiles.empty()) {
+						return BadRequest(RESTAPI::Errors::NeedMobileNumber);
+					}
+					if (!SMSSender()->IsNumberValid(
+							NewUser.userTypeProprietaryInfo.mobiles[0].number,
+							UserInfo_.userinfo.email)) {
+						return BadRequest(RESTAPI::Errors::NeedMobileNumber);
+					}
+					Existing.userTypeProprietaryInfo.mobiles =
+						NewUser.userTypeProprietaryInfo.mobiles;
+					Existing.userTypeProprietaryInfo.mobiles[0].verified = true;
+					Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				} else if (NewUser.userTypeProprietaryInfo.mfa.method ==
+						   MFAMETHODS::AUTHENTICATOR) {
+					std::string Secret;
+					Existing.userTypeProprietaryInfo.mobiles.clear();
+					if (Existing.userTypeProprietaryInfo.authenticatorSecret.empty() &&
+						TotpCache()->CompleteValidation(UserInfo_.userinfo, false, Secret)) {
+						Existing.userTypeProprietaryInfo.authenticatorSecret = Secret;
+					} else if (!Existing.userTypeProprietaryInfo.authenticatorSecret.empty()) {
+						// we allow someone to use their old secret
+					} else {
+						return BadRequest(RESTAPI::Errors::AuthenticatorVerificationIncomplete);
+					}
+				} else if (NewUser.userTypeProprietaryInfo.mfa.method == MFAMETHODS::EMAIL) {
+					Existing.userTypeProprietaryInfo.mobiles.clear();
+					Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				}
+			} else {
+				Existing.userTypeProprietaryInfo.authenticatorSecret.clear();
+				Existing.userTypeProprietaryInfo.mobiles.clear();
+				Existing.userTypeProprietaryInfo.mfa.enabled = false;
+			}
+		}
 
-        Existing.modified = OpenWifi::Now();
-        if(StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email,Id,Existing)) {
-            SecurityObjects::UserInfo   NewUserInfo;
-            StorageService()->UserDB().GetUserByEmail(UserInfo_.userinfo.email,NewUserInfo);
-            Poco::JSON::Object  ModifiedObject;
-            Sanitize(UserInfo_, NewUserInfo);
-            NewUserInfo.to_json(ModifiedObject);
-            return ReturnObject(ModifiedObject);
-        }
-        BadRequest(RESTAPI::Errors::RecordNotUpdated);
-    }
-}
+		Existing.modified = OpenWifi::Now();
+		if (StorageService()->UserDB().UpdateUserInfo(UserInfo_.userinfo.email, Id, Existing)) {
+			SecurityObjects::UserInfo NewUserInfo;
+			StorageService()->UserDB().GetUserByEmail(UserInfo_.userinfo.email, NewUserInfo);
+			Poco::JSON::Object ModifiedObject;
+			Sanitize(UserInfo_, NewUserInfo);
+			NewUserInfo.to_json(ModifiedObject);
+			return ReturnObject(ModifiedObject);
+		}
+		BadRequest(RESTAPI::Errors::RecordNotUpdated);
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_user_handler.h

@@ -7,25 +7,24 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_user_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_user_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {Poco::Net::HTTPRequest::HTTP_POST,
-                                          Poco::Net::HTTPRequest::HTTP_GET,
-                                          Poco::Net::HTTPRequest::HTTP_PUT,
-                                          Poco::Net::HTTPRequest::HTTP_DELETE,
-                                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                          Server,
-                                          TransactionId,
-                                          Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/user/{id}"}; };
-        void DoGet() final;
-        void DoPost() final;
-        void DoDelete() final;
-        void DoPut() final;
-    private:
+	class RESTAPI_user_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_user_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							 RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							 bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_POST,
+													  Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_PUT,
+													  Poco::Net::HTTPRequest::HTTP_DELETE,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/user/{id}"}; };
+		void DoGet() final;
+		void DoPost() final;
+		void DoDelete() final;
+		void DoPut() final;
 
-    };
-}
+	  private:
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_users_handler.cpp

@@ -3,55 +3,60 @@
 //
 
 #include "RESTAPI_users_handler.h"
-#include "StorageService.h"
 #include "RESTAPI/RESTAPI_db_helpers.h"
+#include "StorageService.h"
 
 namespace OpenWifi {
-    void RESTAPI_users_handler::DoGet() {
-        bool IdOnly = (GetParameter("idOnly","false")=="true");
-        auto nameSearch = GetParameter("nameSearch");
-        auto emailSearch = GetParameter("emailSearch");
+	void RESTAPI_users_handler::DoGet() {
+		bool IdOnly = (GetParameter("idOnly", "false") == "true");
+		auto nameSearch = GetParameter("nameSearch");
+		auto emailSearch = GetParameter("emailSearch");
 
-        std::string baseQuery;
-        if(!nameSearch.empty() || !emailSearch.empty()) {
-            if(!nameSearch.empty())
-                baseQuery = fmt::format(" Lower(name) like('%{}%') ", ORM::Escape(Poco::toLower(nameSearch)) );
-            if(!emailSearch.empty())
-                baseQuery += baseQuery.empty() ? fmt::format(" Lower(email) like('%{}%') ", ORM::Escape(Poco::toLower(emailSearch)))
-                                               : fmt::format(" and Lower(email) like('%{}%') ", ORM::Escape(Poco::toLower(emailSearch)));
-        }
+		std::string baseQuery;
+		if (!nameSearch.empty() || !emailSearch.empty()) {
+			if (!nameSearch.empty())
+				baseQuery = fmt::format(" Lower(name) like('%{}%') ",
+										ORM::Escape(Poco::toLower(nameSearch)));
+			if (!emailSearch.empty())
+				baseQuery += baseQuery.empty()
+								 ? fmt::format(" Lower(email) like('%{}%') ",
+											   ORM::Escape(Poco::toLower(emailSearch)))
+								 : fmt::format(" and Lower(email) like('%{}%') ",
+											   ORM::Escape(Poco::toLower(emailSearch)));
+		}
 
-        if(QB_.Select.empty()) {
-            SecurityObjects::UserInfoList   Users;
-            if(StorageService()->UserDB().GetUsers(QB_.Offset, QB_.Limit, Users.users, baseQuery)) {
-                for (auto &i : Users.users) {
-                    Sanitize(UserInfo_, i);
-                }
-                if(IdOnly) {
-                    Poco::JSON::Array   Arr;
-                    for(const auto &i:Users.users)
-                        Arr.add(i.id);
-                    Poco::JSON::Object  Answer;
-                    Answer.set("users", Arr);
-                    return ReturnObject(Answer);
-                }
-            }
-            Poco::JSON::Object  Answer;
-            Users.to_json(Answer);
-            return ReturnObject(Answer);
-        } else {
-            SecurityObjects::UserInfoList   Users;
-            for(auto &i:SelectedRecords()) {
-                SecurityObjects::UserInfo   UInfo;
-                if(StorageService()->UserDB().GetUserById(i,UInfo)) {
-                    Poco::JSON::Object Obj;
-                    Sanitize(UserInfo_, UInfo);
-                    Users.users.emplace_back(UInfo);
-                }
-            }
-            Poco::JSON::Object Answer;
-            Users.to_json(Answer);
-            return ReturnObject(Answer);
-        }
-    }
-}
+		if (QB_.Select.empty()) {
+			SecurityObjects::UserInfoList Users;
+			if (StorageService()->UserDB().GetUsers(QB_.Offset, QB_.Limit, Users.users,
+													baseQuery)) {
+				for (auto &i : Users.users) {
+					Sanitize(UserInfo_, i);
+				}
+				if (IdOnly) {
+					Poco::JSON::Array Arr;
+					for (const auto &i : Users.users)
+						Arr.add(i.id);
+					Poco::JSON::Object Answer;
+					Answer.set("users", Arr);
+					return ReturnObject(Answer);
+				}
+			}
+			Poco::JSON::Object Answer;
+			Users.to_json(Answer);
+			return ReturnObject(Answer);
+		} else {
+			SecurityObjects::UserInfoList Users;
+			for (auto &i : SelectedRecords()) {
+				SecurityObjects::UserInfo UInfo;
+				if (StorageService()->UserDB().GetUserById(i, UInfo)) {
+					Poco::JSON::Object Obj;
+					Sanitize(UserInfo_, UInfo);
+					Users.users.emplace_back(UInfo);
+				}
+			}
+			Poco::JSON::Object Answer;
+			Users.to_json(Answer);
+			return ReturnObject(Answer);
+		}
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_users_handler.h

@@ -7,21 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_users_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_users_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                 {Poco::Net::HTTPRequest::HTTP_GET,
-                                  Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                  Server,
-                                  TransactionId,
-                                  Internal) {}
-        static auto PathName() { return std::list<std::string>{"/api/v1/users"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-};
-
+	class RESTAPI_users_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_users_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+							  RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+							  bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal) {}
+		static auto PathName() { return std::list<std::string>{"/api/v1/users"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+}; // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_apikey.cpp

@@ -7,28 +7,29 @@
 
 namespace OpenWifi {
 
-    void RESTAPI_validate_apikey::DoGet() {
-        Poco::URI URI(Request->getURI());
-        auto Parameters = URI.getQueryParameters();
-        for(auto const &i:Parameters) {
-            if (i.first == "apikey") {
-                //  can we find this token?
-                SecurityObjects::UserInfoAndPolicy SecObj;
-                bool Expired = false;
-                bool Suspended = false;
-                std::uint64_t expiresOn=0;
-                if (AuthService()->IsValidApiKey(i.second, SecObj.webtoken, SecObj.userinfo, Expired, expiresOn, Suspended)) {
-                    Poco::JSON::Object Answer;
-                    SecObj.to_json(Answer);
-                    Answer.set("expiresOn", expiresOn);
-                    return ReturnObject(Answer);
-                }
-                if(Suspended)
-                    return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
-                return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-            }
-        }
-        return NotFound();
-    }
+	void RESTAPI_validate_apikey::DoGet() {
+		Poco::URI URI(Request->getURI());
+		auto Parameters = URI.getQueryParameters();
+		for (auto const &i : Parameters) {
+			if (i.first == "apikey") {
+				//  can we find this token?
+				SecurityObjects::UserInfoAndPolicy SecObj;
+				bool Expired = false;
+				bool Suspended = false;
+				std::uint64_t expiresOn = 0;
+				if (AuthService()->IsValidApiKey(i.second, SecObj.webtoken, SecObj.userinfo,
+												 Expired, expiresOn, Suspended)) {
+					Poco::JSON::Object Answer;
+					SecObj.to_json(Answer);
+					Answer.set("expiresOn", expiresOn);
+					return ReturnObject(Answer);
+				}
+				if (Suspended)
+					return UnAuthorized(RESTAPI::Errors::ACCOUNT_SUSPENDED);
+				return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+			}
+		}
+		return NotFound();
+	}
 
-} // OpenWifi
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_apikey.h

@@ -7,21 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_validate_apikey : public RESTAPIHandler {
-    public:
-        RESTAPI_validate_apikey(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {Poco::Net::HTTPRequest::HTTP_GET,
-                                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                 Server,
-                                 TransactionId,
-                                 Internal) {};
-        static auto PathName() { return std::list<std::string>{"/api/v1/validateApiKey"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
-
+	class RESTAPI_validate_apikey : public RESTAPIHandler {
+	  public:
+		RESTAPI_validate_apikey(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+								RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
+								bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal){};
+		static auto PathName() { return std::list<std::string>{"/api/v1/validateApiKey"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_sub_token_handler.cpp

@@ -6,21 +6,22 @@
 #include "AuthService.h"
 
 namespace OpenWifi {
-    void RESTAPI_validate_sub_token_handler::DoGet() {
-        Poco::URI URI(Request->getURI());
-        auto Parameters = URI.getQueryParameters();
-        for(auto const &i:Parameters) {
-            if (i.first == "token") {
-                //  can we find this token?
-                SecurityObjects::UserInfoAndPolicy SecObj;
-                bool Expired = false;
-                if (AuthService()->IsValidSubToken(i.second, SecObj.webtoken, SecObj.userinfo, Expired)) {
-                    Poco::JSON::Object Obj;
-                    SecObj.to_json(Obj);
-                    return ReturnObject(Obj);
-                }
-            }
-        }
-        return NotFound();
-    }
-}
+	void RESTAPI_validate_sub_token_handler::DoGet() {
+		Poco::URI URI(Request->getURI());
+		auto Parameters = URI.getQueryParameters();
+		for (auto const &i : Parameters) {
+			if (i.first == "token") {
+				//  can we find this token?
+				SecurityObjects::UserInfoAndPolicy SecObj;
+				bool Expired = false;
+				if (AuthService()->IsValidSubToken(i.second, SecObj.webtoken, SecObj.userinfo,
+												   Expired)) {
+					Poco::JSON::Object Obj;
+					SecObj.to_json(Obj);
+					return ReturnObject(Obj);
+				}
+			}
+		}
+		return NotFound();
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_sub_token_handler.h

@@ -7,20 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_validate_sub_token_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_validate_sub_token_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-        : RESTAPIHandler(bindings, L,
-                         std::vector<std::string>
-                         {Poco::Net::HTTPRequest::HTTP_GET,
-                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                          Server,
-                          TransactionId,
-                          Internal) {};
-        static auto PathName() { return std::list<std::string>{"/api/v1/validateSubToken"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
+	class RESTAPI_validate_sub_token_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_validate_sub_token_handler(const RESTAPIHandler::BindingMap &bindings,
+										   Poco::Logger &L, RESTAPI_GenericServerAccounting &Server,
+										   uint64_t TransactionId, bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal){};
+		static auto PathName() { return std::list<std::string>{"/api/v1/validateSubToken"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_token_handler.cpp

@@ -6,21 +6,22 @@
 #include "AuthService.h"
 
 namespace OpenWifi {
-    void RESTAPI_validate_token_handler::DoGet() {
-        Poco::URI URI(Request->getURI());
-        auto Parameters = URI.getQueryParameters();
-        for(auto const &i:Parameters) {
-            if (i.first == "token") {
-                //  can we find this token?
-                SecurityObjects::UserInfoAndPolicy SecObj;
-                bool Expired = false;
-                if (AuthService()->IsValidToken(i.second, SecObj.webtoken, SecObj.userinfo, Expired)) {
-                    Poco::JSON::Object Obj;
-                    SecObj.to_json(Obj);
-                    return ReturnObject(Obj);
-                }
-            }
-        }
-        return NotFound();
-    }
-}
+	void RESTAPI_validate_token_handler::DoGet() {
+		Poco::URI URI(Request->getURI());
+		auto Parameters = URI.getQueryParameters();
+		for (auto const &i : Parameters) {
+			if (i.first == "token") {
+				//  can we find this token?
+				SecurityObjects::UserInfoAndPolicy SecObj;
+				bool Expired = false;
+				if (AuthService()->IsValidToken(i.second, SecObj.webtoken, SecObj.userinfo,
+												Expired)) {
+					Poco::JSON::Object Obj;
+					SecObj.to_json(Obj);
+					return ReturnObject(Obj);
+				}
+			}
+		}
+		return NotFound();
+	}
+} // namespace OpenWifi

src/RESTAPI/RESTAPI_validate_token_handler.h

@@ -7,21 +7,19 @@
 #include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
-    class RESTAPI_validate_token_handler : public RESTAPIHandler {
-    public:
-        RESTAPI_validate_token_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
-                : RESTAPIHandler(bindings, L,
-                                 std::vector<std::string>
-                                         {Poco::Net::HTTPRequest::HTTP_GET,
-                                          Poco::Net::HTTPRequest::HTTP_OPTIONS},
-                                          Server,
-                                          TransactionId,
-                                          Internal) {};
-        static auto PathName() { return std::list<std::string>{"/api/v1/validateToken"}; };
-        void DoGet() final;
-        void DoPost() final {};
-        void DoDelete() final {};
-        void DoPut() final {};
-    };
-}
-
+	class RESTAPI_validate_token_handler : public RESTAPIHandler {
+	  public:
+		RESTAPI_validate_token_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
+									   RESTAPI_GenericServerAccounting &Server,
+									   uint64_t TransactionId, bool Internal)
+			: RESTAPIHandler(bindings, L,
+							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
+													  Poco::Net::HTTPRequest::HTTP_OPTIONS},
+							 Server, TransactionId, Internal){};
+		static auto PathName() { return std::list<std::string>{"/api/v1/validateToken"}; };
+		void DoGet() final;
+		void DoPost() final{};
+		void DoDelete() final{};
+		void DoPut() final{};
+	};
+} // namespace OpenWifi