diff --git a/build b/build
index 978b4e8..a5c750f 100644
--- a/build
+++ b/build
@@ -1 +1 @@
-26
\ No newline at end of file
+27
\ No newline at end of file
diff --git a/src/framework/MicroService.cpp b/src/framework/MicroService.cpp
index da3c146..a8f0c43 100644
--- a/src/framework/MicroService.cpp
+++ b/src/framework/MicroService.cpp
@@ -181,8 +181,6 @@ namespace OpenWifi {
 		MyHash_ = Utils::ComputeHash(MyPublicEndPoint_);
 	}
 
-	void MicroServicePostInitialization();
-
 	void MicroService::InitializeLoggingSystem() {
 		static auto initialized = false;
 
@@ -200,95 +198,136 @@ namespace OpenWifi {
 				Poco::AutoPtr<Poco::NullChannel> DevNull(new Poco::NullChannel);
 				Poco::Logger::root().setChannel(DevNull);
 			} else if (LoggingDestination == "console") {
-				Poco::AutoPtr<Poco::ConsoleChannel> Console(new Poco::ConsoleChannel);
-				if(UseAsyncLogs_) {
-					Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Console));
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, Async));
-					Poco::Logger::root().setChannel(FormattingChannel);
-				} else {
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, Console));
-					Poco::Logger::root().setChannel(FormattingChannel);
-				}
+                SetConsoleLogs(UseAsyncLogs_, DisableWebSocketLogging, LoggingFormat);
 			} else if (LoggingDestination == "colorconsole") {
-				Poco::AutoPtr<Poco::ColorConsoleChannel> ColorConsole(new Poco::ColorConsoleChannel);
-				if(UseAsyncLogs_) {
-					Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(ColorConsole));
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, Async));
-					Poco::Logger::root().setChannel(FormattingChannel);
-				} else {
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, ColorConsole));
-					Poco::Logger::root().setChannel(FormattingChannel);
-				}
+                SetColorConsoleLogs(UseAsyncLogs_, DisableWebSocketLogging, LoggingFormat);
 			} else if (LoggingDestination == "sql") {
-				//"CREATE TABLE T_POCO_LOG (Source VARCHAR, Name VARCHAR, ProcessId INTEGER, Thread VARCHAR, ThreadId INTEGER, Priority INTEGER, Text VARCHAR, DateTime DATE)"
-
+                SetSQLLogs(UseAsyncLogs_, DisableWebSocketLogging, LoggingFormat);
 			} else if (LoggingDestination == "syslog") {
-
+                SetSyslogLogs(UseAsyncLogs_, DisableWebSocketLogging, LoggingFormat);
 			} else {
-				auto LoggingLocation =
-					MicroService::instance().ConfigPath("logging.path", "$OWCERT_ROOT/logs") + "/log";
+                SetFileLogs(UseAsyncLogs_, DisableWebSocketLogging, LoggingFormat, DAEMON_ROOT_ENV_VAR);
+            }
 
-				Poco::AutoPtr<Poco::FileChannel> FileChannel(new Poco::FileChannel);
-				FileChannel->setProperty("rotation", "10 M");
-				FileChannel->setProperty("archive", "timestamp");
-				FileChannel->setProperty("purgeCount", "10");
-				FileChannel->setProperty("path", LoggingLocation);
-				if(UseAsyncLogs_) {
-					Poco::AutoPtr<Poco::AsyncChannel> Async_File(
-						new Poco::AsyncChannel(FileChannel));
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, Async_File));
-					if(DisableWebSocketLogging) {
-						Poco::Logger::root().setChannel(FormattingChannel);
-					} else {
-						Poco::AutoPtr<WebSocketLogger>			WSLogger(new WebSocketLogger);
-						Poco::AutoPtr<Poco::SplitterChannel>	Splitter(new Poco::SplitterChannel);
-						Splitter->addChannel(WSLogger);
-						Splitter->addChannel(FormattingChannel);
-						Poco::Logger::root().setChannel(Splitter);
-					}
-
-				} else {
-					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-					Formatter->setProperty("pattern", LoggingFormat);
-					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-						new Poco::FormattingChannel(Formatter, FileChannel));
-					if(DisableWebSocketLogging) {
-						Poco::Logger::root().setChannel(FormattingChannel);
-					} else {
-						Poco::AutoPtr<Poco::SplitterChannel>	Splitter(new Poco::SplitterChannel);
-						Poco::AutoPtr<WebSocketLogger>			WSLogger(new WebSocketLogger);
-						Splitter->addChannel(WSLogger);
-						Splitter->addChannel(FormattingChannel);
-						Poco::Logger::root().setChannel(Splitter);
-					}
-				}
-			}
 			auto Level = Poco::Logger::parseLevel(MicroService::instance().ConfigGetString("logging.level", "debug"));
 			Poco::Logger::root().setLevel(Level);
-
 			if(!DisableWebSocketLogging) {
 				static const UI_WebSocketClientServer::NotificationTypeIdVec Notifications = {
 					{1, "log"}};
-
 				UI_WebSocketClientServer()->RegisterNotifications(Notifications);
 			}
 		}
-	}
+    }
+
+    void MicroService::SetConsoleLogs(bool UseAsync, bool DisableWebSocketLogging, const std::string & FormatterPattern) {
+
+        Poco::AutoPtr<Poco::ConsoleChannel> Console(new Poco::ConsoleChannel);
+        Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+        Formatter->setProperty("pattern", FormatterPattern);
+        Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(new Poco::FormattingChannel(Formatter, Console));
+
+        if(DisableWebSocketLogging) {
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(FormattingChannel));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(FormattingChannel);
+            }
+        } else {
+            Poco::AutoPtr<WebSocketLogger>			WSLogger(new WebSocketLogger);
+            Poco::AutoPtr<Poco::SplitterChannel>	Splitter(new Poco::SplitterChannel);
+            Splitter->addChannel(WSLogger);
+            Splitter->addChannel(FormattingChannel);
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Splitter));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(Splitter);
+            }
+        }
+
+    }
+
+    void MicroService::SetColorConsoleLogs(bool UseAsync, bool DisableWebSocketLogging, const std::string & FormatterPattern) {
+
+        Poco::AutoPtr<Poco::ColorConsoleChannel> Console(new Poco::ColorConsoleChannel);
+        Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+        Formatter->setProperty("pattern", FormatterPattern);
+        Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(new Poco::FormattingChannel(Formatter, Console));
+
+        if(DisableWebSocketLogging) {
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(FormattingChannel));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(FormattingChannel);
+            }
+        } else {
+            Poco::AutoPtr<WebSocketLogger>			WSLogger(new WebSocketLogger);
+            Poco::AutoPtr<Poco::SplitterChannel>	Splitter(new Poco::SplitterChannel);
+            Splitter->addChannel(WSLogger);
+            Splitter->addChannel(FormattingChannel);
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Splitter));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(Splitter);
+            }
+        }
+
+    }
+
+    void MicroService::SetSQLLogs([[maybe_unused]] bool UseAsync,[[maybe_unused]]  bool DisableWebSocketLogging,[[maybe_unused]]  const std::string & FormatterPattern) {
+        //"CREATE TABLE T_POCO_LOG (Source VARCHAR, Name VARCHAR, ProcessId INTEGER, Thread VARCHAR, ThreadId INTEGER, Priority INTEGER, Text VARCHAR, DateTime DATE)"
+    }
+
+    void MicroService::SetSyslogLogs([[maybe_unused]] bool UseAsync,[[maybe_unused]]  bool DisableWebSocketLogging,[[maybe_unused]]  const std::string & FormatterPattern) {
+
+    }
+
+    void MicroService::SetFileLogs(bool UseAsync, bool DisableWebSocketLogging, const std::string & FormatterPattern, const std::string & root_env_var) {
+        std::string DefaultLogPath = fmt::format("${}/logs",root_env_var);
+        auto LoggingLocationDir = MicroService::instance().ConfigPath("logging.path", DefaultLogPath);
+        Poco::File      LD(LoggingLocationDir);
+        try {
+            if(!LD.exists()) {
+                LD.createDirectory();
+            }
+        } catch(const Poco::Exception &E) {
+            std::cout << "Cannot create " << LD.path() << "  Error: " << E.message() << std::endl;
+        }
+        auto LoggingLocationDirFilePattern = LoggingLocationDir + "/log";
+
+        Poco::AutoPtr<Poco::FileChannel> FileChannel(new Poco::FileChannel);
+        FileChannel->setProperty("rotation", "10 M");
+        FileChannel->setProperty("archive", "timestamp");
+        FileChannel->setProperty("purgeCount", "10");
+        FileChannel->setProperty("path", LoggingLocationDirFilePattern);
+
+        Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+        Formatter->setProperty("pattern", FormatterPattern);
+        Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(new Poco::FormattingChannel(Formatter, FileChannel));
+
+        if(DisableWebSocketLogging) {
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(FormattingChannel));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(FormattingChannel);
+            }
+        } else {
+            Poco::AutoPtr<WebSocketLogger>			WSLogger(new WebSocketLogger);
+            Poco::AutoPtr<Poco::SplitterChannel>	Splitter(new Poco::SplitterChannel);
+            Splitter->addChannel(WSLogger);
+            Splitter->addChannel(FormattingChannel);
+            if(UseAsync) {
+                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Splitter));
+                Poco::Logger::root().setChannel(Async);
+            } else {
+                Poco::Logger::root().setChannel(Splitter);
+            }
+        }
+    }
 
 	void DaemonPostInitialization(Poco::Util::Application &self);
 
diff --git a/src/framework/MicroService.h b/src/framework/MicroService.h
index 45b17bf..03f1d76 100644
--- a/src/framework/MicroService.h
+++ b/src/framework/MicroService.h
@@ -158,6 +158,12 @@ namespace OpenWifi {
 		[[nodiscard]] std::string Sign(Poco::JWT::Token &T, const std::string &Algo);
 		void AddActivity(const std::string &Activity);
 
+        static void SetConsoleLogs(bool UseAsync, bool AllowWebSocket, const std::string & FormatterPattern);
+        static void SetColorConsoleLogs(bool UseAsync, bool AllowWebSocket, const std::string & FormatterPattern);
+        static void SetSQLLogs(bool UseAsync, bool AllowWebSocket, const std::string & FormatterPattern);
+        static void SetSyslogLogs(bool UseAsync, bool AllowWebSocket, const std::string & FormatterPattern);
+        static void SetFileLogs(bool UseAsync, bool AllowWebSocket, const std::string & FormatterPattern, const std::string & root_env_var);
+
 	  private:
 	    static MicroService         * instance_;
 		bool                        HelpRequested_ = false;
diff --git a/src/framework/RESTAPI_Handler.h b/src/framework/RESTAPI_Handler.h
index a1b9bd0..3d24078 100644
--- a/src/framework/RESTAPI_Handler.h
+++ b/src/framework/RESTAPI_Handler.h
@@ -550,6 +550,27 @@ namespace OpenWifi {
 			Poco::JSON::Stringifier::stringify(Object, Answer);
 		}
 
+		inline void ReturnRawJSON(const std::string &json_doc) {
+			PrepareResponse();
+			if(Request!= nullptr) {
+				//   can we compress ???
+				auto AcceptedEncoding = Request->find("Accept-Encoding");
+				if(AcceptedEncoding!=Request->end()) {
+					if( AcceptedEncoding->second.find("gzip")!=std::string::npos ||
+						AcceptedEncoding->second.find("compress")!=std::string::npos) {
+						Response->set("Content-Encoding", "gzip");
+						std::ostream &Answer = Response->send();
+						Poco::DeflatingOutputStream deflater(Answer, Poco::DeflatingStreamBuf::STREAM_GZIP);
+                        deflater << json_doc;
+						deflater.close();
+						return;
+					}
+				}
+			}
+			std::ostream &Answer = Response->send();
+            Answer << json_doc;
+		}
+
 		inline void ReturnCountOnly(uint64_t Count) {
 			Poco::JSON::Object  Answer;
 			Answer.set("count", Count);
diff --git a/src/framework/ow_constants.h b/src/framework/ow_constants.h
index 15758aa..a3abd85 100644
--- a/src/framework/ow_constants.h
+++ b/src/framework/ow_constants.h
@@ -228,6 +228,7 @@ namespace OpenWifi::RESTAPI::Errors {
     static const struct msg ApiKeyNameDoesNotExist{1150,"API Key name does not exist."};
     static const struct msg ApiKeyDoesNotExist{1150,"API Key does not exist."};
 
+	static const struct msg DeviceIsRestricted{1151,"Device is protected by regulation. This function is not allowed."};
 }