diff --git a/CMakeLists.txt b/CMakeLists.txt index a6397bd..d3d8690 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,6 +82,7 @@ add_executable( ucentralfms src/RESTAPI_firmwareAgeHandler.cpp src/RESTAPI_firmwareAgeHandler.h src/storage_deviceInfo.cpp src/storage_deviceInfo.h src/RESTAPI_connectedDevicesHandler.cpp src/RESTAPI_connectedDevicesHandler.h + src/FirmwareCache.cpp src/FirmwareCache.h src/RESTAPI_connectedDeviceHandler.cpp src/RESTAPI_connectedDeviceHandler.h src/RESTAPI_deviceReportHandler.cpp src/RESTAPI_deviceReportHandler.h) target_link_libraries(ucentralfms PUBLIC diff --git a/build b/build index f0b5c72..4e9e288 100644 --- a/build +++ b/build @@ -1 +1 @@ -57 \ No newline at end of file +63 \ No newline at end of file diff --git a/src/Daemon.cpp b/src/Daemon.cpp index 90024de..ddc999c 100644 --- a/src/Daemon.cpp +++ b/src/Daemon.cpp @@ -20,11 +20,11 @@ #include "RESTAPI_server.h" #include "RESTAPI_InternalServer.h" #include "ManifestCreator.h" -#include "ALBHealthCheckServer.h" #include "KafkaManager.h" #include "NewConnectionHandler.h" #include "LatestFirmwareCache.h" #include "DeviceCache.h" +#include "FirmwareCache.h" namespace uCentral { class Daemon *Daemon::instance_ = nullptr; @@ -37,6 +37,7 @@ namespace uCentral { vDAEMON_APP_NAME, vDAEMON_BUS_TIMER, Types::SubSystemVec{Storage(), + FirmwareCache(), LatestFirmwareCache(), DeviceCache(), NewConnectionHandler(), diff --git a/src/DeviceCache.cpp b/src/DeviceCache.cpp index 1dc5cc2..a077505 100644 --- a/src/DeviceCache.cpp +++ b/src/DeviceCache.cpp @@ -16,19 +16,19 @@ namespace uCentral { void DeviceCache::AddToCache( const std::string &SerialNumber, const std::string & DeviceType, - const std::string &Host, const std::string &Firmware) { + const std::string &Host, const std::string &Revision) { SubMutexGuard G(Mutex_); auto Device = DeviceCache_.find(SerialNumber); if(Device==DeviceCache_.end()) { DeviceCache_[SerialNumber]=DeviceCacheEntry{ - .compatible=DeviceType, + .deviceType=DeviceType, .host=Host, - .firmware=Firmware}; + .revision=Revision}; } else { - Device->second.firmware=Firmware; + Device->second.revision=Revision; Device->second.host=Host; - Device->second.compatible=DeviceType; + Device->second.deviceType=DeviceType; } } diff --git a/src/DeviceCache.h b/src/DeviceCache.h index 703a5eb..f627488 100644 --- a/src/DeviceCache.h +++ b/src/DeviceCache.h @@ -12,9 +12,9 @@ namespace uCentral { struct DeviceCacheEntry { - std::string compatible; + std::string deviceType; std::string host; - std::string firmware; + std::string revision; }; typedef std::map DeviceCacheMap; @@ -30,8 +30,7 @@ namespace uCentral { int Start() override; void Stop() override; void AddToCache(const std::string &serialNumber, const std::string & DeviceType, - const std::string &Host, const std::string &Firmware); - std::string FindLatestFirmware(std::string &DeviceType); + const std::string &Host, const std::string &Revision); void DumpCache(); bool GetDevice(const std::string &SerialNumber, DeviceCacheEntry & E); diff --git a/src/FirmwareCache.cpp b/src/FirmwareCache.cpp new file mode 100644 index 0000000..b0bff10 --- /dev/null +++ b/src/FirmwareCache.cpp @@ -0,0 +1,26 @@ +// +// Created by stephane bourque on 2021-07-26. +// + +#include "FirmwareCache.h" + +namespace uCentral { + class FirmwareCache *FirmwareCache::instance_ = nullptr; + + int FirmwareCache::Start() { + return 0; + } + + void FirmwareCache::Stop() { + + } + + std::shared_ptr GetFirmware(const std::string & DeviceType, const std::string & Revision) { + return nullptr; + } + + std::shared_ptr AddFirmware(const FMSObjects::Firmware &F) { + return nullptr; + } + +} diff --git a/src/FirmwareCache.h b/src/FirmwareCache.h new file mode 100644 index 0000000..18225d6 --- /dev/null +++ b/src/FirmwareCache.h @@ -0,0 +1,49 @@ +// +// Created by stephane bourque on 2021-07-26. +// + +#ifndef UCENTRALFMS_FIRMWARECACHE_H +#define UCENTRALFMS_FIRMWARECACHE_H + +#include +#include + +#include "RESTAPI_FMSObjects.h" +#include "SubSystemServer.h" + +namespace uCentral { + + typedef std::map> FirmwareCacheMap; + + class FirmwareCache: public SubSystemServer { + public: + static FirmwareCache *instance() { + if (instance_ == nullptr) { + instance_ = new FirmwareCache; + } + return instance_; + } + + int Start() override; + void Stop() override; + + std::shared_ptr GetFirmware(const std::string & DeviceType, const std::string & Revision); + std::shared_ptr AddFirmware(const FMSObjects::Firmware &F); + + + private: + static FirmwareCache *instance_; + std::atomic_bool Running_=false; + FirmwareCacheMap Cache_; + explicit FirmwareCache() noexcept: + SubSystemServer("FirmwareCache", "FIRMWARE-CACHE", "firmwarecache") + { + } + }; + + inline FirmwareCache * FirmwareCache() { return FirmwareCache::instance(); } + +} + + +#endif //UCENTRALFMS_FIRMWARECACHE_H diff --git a/src/LatestFirmwareCache.cpp b/src/LatestFirmwareCache.cpp index 227e015..80c0576 100644 --- a/src/LatestFirmwareCache.cpp +++ b/src/LatestFirmwareCache.cpp @@ -21,9 +21,9 @@ namespace uCentral { RevisionSet_.insert(Revision); DeviceSet_.insert(DeviceType); - auto E = FirmwareCache_.find(DeviceType); - if((E==FirmwareCache_.end()) || (TimeStamp > E->second.TimeStamp)) { - FirmwareCache_[DeviceType] = LatestFirmwareCacheEntry{.Id=Id, + auto E = Cache_.find(DeviceType); + if((E==Cache_.end()) || (TimeStamp > E->second.TimeStamp)) { + Cache_[DeviceType] = LatestFirmwareCacheEntry{.Id=Id, .TimeStamp=TimeStamp, .Revision=Revision}; } @@ -32,8 +32,8 @@ namespace uCentral { bool LatestFirmwareCache::FindLatestFirmware(const std::string &DeviceType, LatestFirmwareCacheEntry &Entry ) { SubMutexGuard G(Mutex_); - auto E=FirmwareCache_.find(DeviceType); - if(E!=FirmwareCache_.end()) { + auto E=Cache_.find(DeviceType); + if(E!=Cache_.end()) { Entry = E->second; return true; } @@ -44,8 +44,8 @@ namespace uCentral { bool LatestFirmwareCache::IsLatest(const std::string &DeviceType, const std::string &Revision) { SubMutexGuard G(Mutex_); - auto E=FirmwareCache_.find(DeviceType); - if(E!=FirmwareCache_.end()) { + auto E=Cache_.find(DeviceType); + if(E!=Cache_.end()) { return E->second.Revision==Revision; } return false; @@ -55,7 +55,7 @@ namespace uCentral { void LatestFirmwareCache::DumpCache() { SubMutexGuard G(Mutex_); - for( auto &[Id,E]:FirmwareCache_) { + for( auto &[Id,E]:Cache_) { std::cout << "Device: " << Id << " ID:" << E.Id << std::endl; } diff --git a/src/LatestFirmwareCache.h b/src/LatestFirmwareCache.h index 26b3f14..93b85f2 100644 --- a/src/LatestFirmwareCache.h +++ b/src/LatestFirmwareCache.h @@ -20,7 +20,7 @@ namespace uCentral { uint64_t TimeStamp=0; std::string Revision; }; - typedef std::map FirmwareCache; + typedef std::map LatestFirmwareCacheMap; class LatestFirmwareCache : public SubSystemServer { public: @@ -43,7 +43,7 @@ namespace uCentral { private: static LatestFirmwareCache *instance_; - FirmwareCache FirmwareCache_; + LatestFirmwareCacheMap Cache_; Types::StringSet RevisionSet_; Types::StringSet DeviceSet_; explicit LatestFirmwareCache() noexcept: diff --git a/src/ManifestCreator.cpp b/src/ManifestCreator.cpp index 553a4f6..9ebc322 100644 --- a/src/ManifestCreator.cpp +++ b/src/ManifestCreator.cpp @@ -179,8 +179,8 @@ namespace uCentral { Outcome = S3Client.ListObjectsV2(Request); if(!Outcome.IsSuccess()) { Logger_.error(Poco::format("Error while doing ListObjectsV2: %s, %s", - std::string{Outcome.GetError().GetExceptionName().c_str()}, - std::string{Outcome.GetError().GetMessage().c_str()})); + std::string{Outcome.GetError().GetExceptionName()}, + std::string{Outcome.GetError().GetMessage()})); return false; } Aws::Vector objects = Outcome.GetResult().GetContents(); @@ -263,8 +263,8 @@ namespace uCentral { // std::cout << "Count:" << Count << " Runs:" << Runs << std::endl; if(!Outcome.IsSuccess()) { Logger_.error(Poco::format("Error while doing ListObjectsV2: %s, %s", - std::string{Outcome.GetError().GetExceptionName().c_str()}, - std::string{Outcome.GetError().GetMessage().c_str()})); + std::string{Outcome.GetError().GetExceptionName()}, + std::string{Outcome.GetError().GetMessage()})); return false; } return true; diff --git a/src/NewConnectionHandler.cpp b/src/NewConnectionHandler.cpp index 836c618..eef6390 100644 --- a/src/NewConnectionHandler.cpp +++ b/src/NewConnectionHandler.cpp @@ -15,12 +15,8 @@ #include "DeviceCache.h" /* - { "system" : { "id" : 6715803232063 , "host" : "https://localhost:17002" } , "payload" : "{"capabilities":{"compatible":"linksys_ea8300","model":"Linksys EA8300 (Dallas)","network":{"lan":["eth0"],"wan":["eth1"]},"platform":"ap","switch":{"switch0":{"enable":true,"ports":[{"device":"eth0","need_tag":false,"num":0,"want_untag":true},{"num":1,"role":"lan"},{"num":2,"role":"lan"},{"num":3,"role":"lan"},{"num":4,"role":"lan"}],"reset":true,"roles":[{"device":"eth0","ports":"1 2 3 4 0","role":"lan"}]}},"wifi":{"platform/soc/a000000.wifi":{"band":["2G"],"channels":[1,2,3,4,5,6,7,8,9,10,11],"frequencies":[2412,2417,2422,2427,2432,2437,2442,2447,2452,2457,2462],"ht_capa":6639,"htmode":["HT20","HT40","VHT20","VHT40","VHT80"],"rx_ant":3,"tx_ant":3,"vht_capa":865687986},"platform/soc/a800000.wifi":{"band":["5G"],"channels":[36,40,44,48,52,56,60,64],"frequencies":[5180,5200,5220,5240,5260,5280,5300,5320],"ht_capa":6639,"htmode":["HT20","HT40","VHT20","VHT40","VHT80"],"rx_ant":3,"tx_ant":3,"vht_capa":865687986},"soc/40000000.pci/pci0000:00/0000:00:00.0/0000:01:00.0":{"band":["5G"],"channels":[100,104,108,112,116,120,124,128,132,136,140,144,149,153,157,161,165],"frequencies":[5500,5520,5540,5560,5580,5600,5620,5640,5660,5680,5700,5720,5745,5765,5785,5805,5825],"ht_capa":6639,"htmode":["HT20","HT40","VHT20","VHT40","VHT80"],"rx_ant":3,"tx_ant":3,"vht_capa":865696178}}},"firmware":"OpenWrt 21.02-SNAPSHOT r16011+53-6fd65c6573 / TIP-devel-0825cb93","serial":"24f5a207a130","uuid":1623866223}} - - - */ namespace uCentral { @@ -105,14 +101,12 @@ namespace uCentral { int NewConnectionHandler::Start() { Types::TopicNotifyFunction F = [this](std::string s1,std::string s2) { this->ConnectionReceived(s1,s2); }; ConnectionWatcherId_ = KafkaManager()->RegisterTopicWatcher(KafkaTopics::CONNECTION, F); -// HealthcheckWatcherId_ = KafkaManager()->RegisterTopicWatcher(KafkaTopics::HEALTHCHECK, F); Worker_.start(*this); return 0; }; void NewConnectionHandler::Stop() { KafkaManager()->UnregisterTopicWatcher(KafkaTopics::CONNECTION, ConnectionWatcherId_); -// KafkaManager()->UnregisterTopicWatcher(KafkaTopics::CONNECTION, HealthcheckWatcherId_); Running_ = false; Worker_.wakeUp(); Worker_.join(); diff --git a/src/RESTAPI_connectedDeviceHandler.cpp b/src/RESTAPI_connectedDeviceHandler.cpp index fef43be..0210a6e 100644 --- a/src/RESTAPI_connectedDeviceHandler.cpp +++ b/src/RESTAPI_connectedDeviceHandler.cpp @@ -5,6 +5,7 @@ #include "RESTAPI_connectedDeviceHandler.h" #include "RESTAPI_FMSObjects.h" #include "StorageService.h" +#include "RESTAPI_protocol.h" namespace uCentral { void RESTAPI_connectedDeviceHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -22,7 +23,7 @@ namespace uCentral { void RESTAPI_connectedDeviceHandler::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { - auto SerialNumber = GetBinding("serialNumber",""); + auto SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER,""); if(SerialNumber.empty()) { BadRequest(Request, Response, "SerialNumber must be specified."); diff --git a/src/RESTAPI_connectedDevicesHandler.cpp b/src/RESTAPI_connectedDevicesHandler.cpp index d938760..54765da 100644 --- a/src/RESTAPI_connectedDevicesHandler.cpp +++ b/src/RESTAPI_connectedDevicesHandler.cpp @@ -7,6 +7,7 @@ #include "Poco/JSON/Object.h" #include "Poco/JSON/Array.h" #include "StorageService.h" +#include "RESTAPI_protocol.h" namespace uCentral { void RESTAPI_connectedDevicesHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -36,7 +37,7 @@ namespace uCentral { AnswerArr.add(Obj); } Poco::JSON::Object AnswerObj; - AnswerObj.set("devices", AnswerArr); + AnswerObj.set(RESTAPI::Protocol::DEVICES, AnswerArr); ReturnObject(Request, AnswerObj, Response); return; } diff --git a/src/RESTAPI_firmwareAgeHandler.cpp b/src/RESTAPI_firmwareAgeHandler.cpp index 8e88db8..5d7df65 100644 --- a/src/RESTAPI_firmwareAgeHandler.cpp +++ b/src/RESTAPI_firmwareAgeHandler.cpp @@ -10,6 +10,7 @@ #include "Utils.h" #include "DeviceCache.h" #include "uCentralProtocol.h" +#include "RESTAPI_protocol.h" namespace uCentral { void RESTAPI_firmwareAgeHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -25,8 +26,7 @@ namespace uCentral { BadRequest(Request, Response); } - void - RESTAPI_firmwareAgeHandler::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { + void RESTAPI_firmwareAgeHandler::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { InitQueryBlock(); if (!QB_.Select.empty()) { @@ -36,7 +36,7 @@ namespace uCentral { DeviceCacheEntry E; if (DeviceCache()->GetDevice(i, E)) { FMSObjects::FirmwareAgeDetails FA; - if(Storage()->ComputeFirmwareAge(E.compatible,E.firmware,FA)) { + if(Storage()->ComputeFirmwareAge(E.deviceType,E.revision,FA)) { Poco::JSON::Object O; FA.to_json(O); O.set(uCentralProtocol::SERIALNUMBER,i); @@ -53,12 +53,12 @@ namespace uCentral { } } Poco::JSON::Object Answer; - Answer.set("ages", Objects); + Answer.set(RESTAPI::Protocol::AGES, Objects); ReturnObject(Request, Answer, Response); return; } else { - auto DeviceType = GetParameter("deviceType", ""); - auto Revision = GetParameter("revision", ""); + auto DeviceType = GetParameter(RESTAPI::Protocol::DEVICETYPE, ""); + auto Revision = GetParameter(RESTAPI::Protocol::REVISION, ""); if (DeviceType.empty() || Revision.empty()) { BadRequest(Request, Response, "Both deviceType and revision must be set."); diff --git a/src/RESTAPI_firmwareHandler.cpp b/src/RESTAPI_firmwareHandler.cpp index 729f93c..a62700b 100644 --- a/src/RESTAPI_firmwareHandler.cpp +++ b/src/RESTAPI_firmwareHandler.cpp @@ -2,11 +2,14 @@ // Created by stephane bourque on 2021-05-09. // +#include "Poco/JSON/Parser.h" + #include "RESTAPI_firmwareHandler.h" #include "StorageService.h" - -#include "Poco/JSON/Parser.h" #include "Daemon.h" +#include "uCentralProtocol.h" +#include "RESTAPI_protocol.h" +#include "RESTAPI_utils.h" namespace uCentral { void RESTAPI_firmwareHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -23,6 +26,8 @@ namespace uCentral { DoGet(Request, Response); else if (Request.getMethod() == Poco::Net::HTTPRequest::HTTP_POST) DoPost(Request, Response); + else if (Request.getMethod() == Poco::Net::HTTPRequest::HTTP_PUT) + DoPut(Request, Response); else if (Request.getMethod() == Poco::Net::HTTPRequest::HTTP_DELETE) DoDelete(Request, Response); else @@ -57,7 +62,7 @@ namespace uCentral { void RESTAPI_firmwareHandler::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { - auto UUID = GetBinding("id", ""); + auto UUID = GetBinding(uCentralProtocol::ID, ""); if (!UUID.empty()) { FMSObjects::Firmware F; @@ -79,7 +84,7 @@ namespace uCentral { void RESTAPI_firmwareHandler::DoDelete(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { - auto UUID = GetBinding("id", ""); + auto UUID = GetBinding(uCentralProtocol::ID, ""); if (!UUID.empty()) { if (Storage()->DeleteFirmware(UUID)) { @@ -95,4 +100,49 @@ namespace uCentral { } BadRequest(Request, Response); } + + void RESTAPI_firmwareHandler::DoPut(Poco::Net::HTTPServerRequest &Request, + Poco::Net::HTTPServerResponse &Response) { + try { + + auto UUID = GetBinding(uCentralProtocol::ID, ""); + if(UUID.empty()) { + BadRequest(Request, Response, "UUID must be included in the request"); + return; + } + + Poco::JSON::Parser IncomingParser; + Poco::JSON::Object::Ptr Obj = + IncomingParser.parse(Request.stream()).extract(); + + FMSObjects::Firmware F; + if(!Storage()->GetFirmware(UUID, F)) { + NotFound(Request, Response); + return; + } + + if(Obj->has(RESTAPI::Protocol::DESCRIPTION)) + F.description = Obj->get(RESTAPI::Protocol::DESCRIPTION).toString(); + if(Obj->has(RESTAPI::Protocol::NOTES)) { + SecurityObjects::NoteInfoVec NIV; + NIV = RESTAPI_utils::to_object_array(Obj->get(RESTAPI::Protocol::NOTES).toString()); + for(auto const &i:NIV) { + SecurityObjects::NoteInfo ii{.created=(uint64_t)std::time(nullptr), .createdBy=UserInfo_.userinfo.email, .note=i.note}; + F.notes.push_back(ii); + } + } + + if(Storage()->UpdateFirmware(UUID, F)) { + Poco::JSON::Object Answer; + F.to_json(Answer); + ReturnObject(Request, Answer, Response); + } else { + BadRequest(Request, Response, "Could not update the firmware entry. Please review your changes."); + } + return; + } catch (const Poco::Exception &E) { + Logger_.log(E); + } + BadRequest(Request, Response); + } } \ No newline at end of file diff --git a/src/RESTAPI_firmwaresHandler.cpp b/src/RESTAPI_firmwaresHandler.cpp index aad671d..687bd8a 100644 --- a/src/RESTAPI_firmwaresHandler.cpp +++ b/src/RESTAPI_firmwaresHandler.cpp @@ -5,6 +5,7 @@ #include "RESTAPI_firmwaresHandler.h" #include "StorageService.h" #include "LatestFirmwareCache.h" +#include "RESTAPI_protocol.h" namespace uCentral { void RESTAPI_firmwaresHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -26,11 +27,11 @@ namespace uCentral { try { InitQueryBlock(); - std::string DeviceType = GetParameter("deviceType",""); - bool IdOnly = GetBoolParameter("idOnly",false); - bool RevisionSet = GetBoolParameter("revisionSet",false); - bool LatestOnly = GetBoolParameter("latestOnly",false); - bool DeviceSet = GetBoolParameter("deviceSet",false); + std::string DeviceType = GetParameter(RESTAPI::Protocol::DEVICETYPE, ""); + bool IdOnly = GetBoolParameter(RESTAPI::Protocol::IDONLY, false); + bool RevisionSet = GetBoolParameter(RESTAPI::Protocol::REVISIONSET, false); + bool LatestOnly = GetBoolParameter(RESTAPI::Protocol::LATESTONLY, false); + bool DeviceSet = GetBoolParameter(RESTAPI::Protocol::DEVICESET, false); if(DeviceSet) { auto Revisions = LatestFirmwareCache()->GetDevices(); @@ -39,7 +40,7 @@ namespace uCentral { ObjectArray.add(i); } Poco::JSON::Object RetObj; - RetObj.set("deviceTypes", ObjectArray); + RetObj.set(RESTAPI::Protocol::DEVICETYPES, ObjectArray); ReturnObject(Request, RetObj, Response); return; } @@ -51,7 +52,7 @@ namespace uCentral { ObjectArray.add(i); } Poco::JSON::Object RetObj; - RetObj.set("revisions", ObjectArray); + RetObj.set(RESTAPI::Protocol::REVISIONS, ObjectArray); ReturnObject(Request, RetObj, Response); return; } @@ -88,7 +89,7 @@ namespace uCentral { } } Poco::JSON::Object RetObj; - RetObj.set("firmwares", ObjectArray); + RetObj.set(RESTAPI::Protocol::FIRMWARES, ObjectArray); ReturnObject(Request, RetObj, Response); return; } else { @@ -110,7 +111,7 @@ namespace uCentral { } } Poco::JSON::Object RetObj; - RetObj.set("firmwares", ObjectArray); + RetObj.set(RESTAPI::Protocol::FIRMWARES, ObjectArray); ReturnObject(Request, RetObj, Response); return; } diff --git a/src/RESTAPI_historyHandler.cpp b/src/RESTAPI_historyHandler.cpp index aa4b212..42a1067 100644 --- a/src/RESTAPI_historyHandler.cpp +++ b/src/RESTAPI_historyHandler.cpp @@ -10,6 +10,7 @@ #include "RESTAPI_historyHandler.h" #include "StorageService.h" +#include "RESTAPI_protocol.h" namespace uCentral { void RESTAPI_historyHandler::handleRequest(Poco::Net::HTTPServerRequest &Request, @@ -30,7 +31,7 @@ namespace uCentral { void RESTAPI_historyHandler::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { - auto SerialNumber = GetBinding("serialNumber", ""); + auto SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER, ""); if (!SerialNumber.empty()) { FMSObjects::RevisionHistoryEntryVec H; @@ -43,7 +44,7 @@ namespace uCentral { A.add(O); } Poco::JSON::Object Answer; - Answer.set("history", A); + Answer.set(RESTAPI::Protocol::HISTORY, A); ReturnObject(Request, Answer, Response); } else { NotFound(Request, Response); @@ -59,8 +60,8 @@ namespace uCentral { void RESTAPI_historyHandler::DoDelete(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { - auto SerialNumber = GetBinding("serialNumber", ""); - auto Id = GetParameter("id", ""); + auto SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER, ""); + auto Id = GetParameter(RESTAPI::Protocol::ID, ""); if (SerialNumber.empty() || Id.empty()) { BadRequest(Request, Response, "SerialNumber and Id must not be empty."); return; diff --git a/src/RESTAPI_protocol.h b/src/RESTAPI_protocol.h index e0083f1..c7c8d49 100644 --- a/src/RESTAPI_protocol.h +++ b/src/RESTAPI_protocol.h @@ -87,6 +87,42 @@ namespace uCentral::RESTAPI::Protocol { static const char * LIST = "list"; static const char * TAG = "tag"; static const char * TAGLIST = "tagList"; + static const char * DESCRIPTION = "description"; + static const char * NOTES = "notes"; + static const char * DEVICETYPE = "deviceType"; + static const char * REVISION = "revision"; + static const char * AGES = "ages"; + static const char * REVISIONS = "revisions"; + static const char * DEVICETYPES = "deviceTypes"; + static const char * LATESTONLY = "latestOnly"; + static const char * IDONLY = "idOnly"; + static const char * REVISIONSET = "revisionSet"; + static const char * DEVICESET = "deviceSet"; + static const char * HISTORY = "history"; + static const char * ID = "id"; + static const char * VERSION = "version"; + static const char * TIMES = "times"; + static const char * UPTIME = "uptime"; + static const char * START = "start"; + + static const char * NEWPASSWORD = "newPassword"; + static const char * USERS = "users"; + + static const char * ERRORTEXT = "errorText"; + static const char * ERRORCODE = "errorCode"; + static const char * AVATARID = "avatarId"; + static const char * UNNAMED = "(unnamed)"; + static const char * UNSPECIFIED = "(unspecified)"; + static const char * CONTENTDISPOSITION = "Content-Disposition"; + static const char * CONTENTTYPE = "Content-Type"; + + static const char * REQUIREMENTS = "requirements"; + static const char * PASSWORDPATTERN = "passwordPattern"; + static const char * ACCESSPOLICY = "accessPolicy"; + static const char * PASSWORDPOLICY = "passwordPolicy"; + static const char * FORGOTPASSWORD = "forgotPassword"; + static const char * ME = "me"; + } #endif // UCENTRALGW_RESTAPI_PROTOCOL_H diff --git a/src/RESTAPI_system_command.cpp b/src/RESTAPI_system_command.cpp index a29ca17..dfcf7d5 100644 --- a/src/RESTAPI_system_command.cpp +++ b/src/RESTAPI_system_command.cpp @@ -13,40 +13,6 @@ #include "Daemon.h" #include "RESTAPI_protocol.h" -/* - - SystemCommandDetails: - type: object - properties: - command: - type: string - enum: - - setloglevel - - getloglevel - - stats - parameters: - type: array - items: - properties: - name: - type: string - value: - type: string - - SystemCommandResults: - type: object - properties: - command: - type: string - result: - type: integer - resultTxt: - type: array - items: - type: string - - */ - namespace uCentral { void RESTAPI_system_command::handleRequest(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { @@ -134,26 +100,26 @@ namespace uCentral { void RESTAPI_system_command::DoGet(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) { try { ParseParameters(Request); - auto Command = GetParameter("command", ""); - if (!Poco::icompare(Command, "version")) { + auto Command = GetParameter(RESTAPI::Protocol::COMMAND, ""); + if (!Poco::icompare(Command, RESTAPI::Protocol::VERSION)) { Poco::JSON::Object Answer; - Answer.set("tag", "version"); - Answer.set("value", Daemon()->Version()); + Answer.set(RESTAPI::Protocol::TAG, RESTAPI::Protocol::VERSION); + Answer.set(RESTAPI::Protocol::VALUE, Daemon()->Version()); ReturnObject(Request, Answer, Response); return; } - if (!Poco::icompare(Command, "times")) { + if (!Poco::icompare(Command, RESTAPI::Protocol::TIMES)) { Poco::JSON::Array Array; Poco::JSON::Object Answer; Poco::JSON::Object UpTimeObj; - UpTimeObj.set("tag","uptime"); - UpTimeObj.set("value", Daemon()->uptime().totalSeconds()); + UpTimeObj.set(RESTAPI::Protocol::TAG,RESTAPI::Protocol::TIMES); + UpTimeObj.set(RESTAPI::Protocol::VALUE, Daemon()->uptime().totalSeconds()); Poco::JSON::Object StartObj; - StartObj.set("tag","start"); - StartObj.set("value", Daemon()->startTime().epochTime()); + StartObj.set(RESTAPI::Protocol::TAG,RESTAPI::Protocol::START); + StartObj.set(RESTAPI::Protocol::VALUE, Daemon()->startTime().epochTime()); Array.add(UpTimeObj); Array.add(StartObj); - Answer.set("times", Array); + Answer.set(RESTAPI::Protocol::TIMES, Array); ReturnObject(Request, Answer, Response); return; }