scottk/wlan-cloud-owprov
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/wlan-cloud-owprov.git synced 2025-11-01 02:58:00 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity
Files
0b35942ef6977d41569e06395f6f9429d56b4781
wlan-cloud-owprov/src/RESTAPI/RESTAPI_inventory_handler.cpp
stephb9959 0b35942ef6 https://telecominfraproject.atlassian.net/browse/WIFI-12225 
Signed-off-by: stephb9959 <stephane.bourque@gmail.com>
2023-01-26 21:14:57 -08:00

432 lines
20 KiB
C++
Raw Blame History

//
// License type: BSD 3-Clause License
// License copy: https://github.com/Telecominfraproject/wlan-cloud-ucentralgw/blob/master/LICENSE
//
// Created by Stephane Bourque on 2021-03-04.
// Arilia Wireless Inc.
//
#include "RESTAPI_inventory_handler.h"
#include "StorageService.h"
#include "APConfig.h"
#include "AutoDiscovery.h"
#include "sdks/SDK_gw.h"
#include "sdks/SDK_sec.h"
#include "RESTAPI/RESTAPI_db_helpers.h"
#include "SerialNumberCache.h"
#include "DeviceTypeCache.h"
#include "framework/utils.h"
namespace OpenWifi{
void GetRejectedLines(const Poco::JSON::Object::Ptr &Response, Types::StringVec & Warnings) {
try {
if(Response->has("results")) {
auto Results = Response->get("results").extract<Poco::JSON::Object::Ptr>();
auto Status = Results->get("status").extract<Poco::JSON::Object::Ptr>();
auto Rejected = Status->getArray("rejected");
std::transform(Rejected->begin(),Rejected->end(),std::back_inserter(Warnings), [](auto i) -> auto { return i.toString(); });
// for(const auto &i:*Rejected)
// Warnings.push_back(i.toString());
}
} catch (...) {
}
}
void RESTAPI_inventory_handler::DoGet() {
ProvObjects::InventoryTag Existing;
std::string SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER, "");
poco_debug(Logger(),fmt::format("{}: Retrieving inventory information.", SerialNumber));
if (SerialNumber.empty() || !DB_.GetRecord(RESTAPI::Protocol::SERIALNUMBER, SerialNumber, Existing)) {
return NotFound();
}
poco_debug(Logger(), fmt::format("{},{}: Retrieving inventory information.", Existing.serialNumber, Existing.info.id));
Poco::JSON::Object Answer;
std::string Arg;
if (GetBoolParameter("config", false)) {
bool Explain = GetBoolParameter("explain", false);
APConfig Device(SerialNumber, Existing.deviceType, Logger(), Explain);
auto Configuration = Poco::makeShared<Poco::JSON::Object>();
if (Device.Get(Configuration)) {
Answer.set("config", Configuration);
if (Explain)
Answer.set("explanation", Device.Explanation());
} else {
Answer.set("config", "none");
}
return ReturnObject(Answer);
} else if (GetBoolParameter("firmwareOptions", false)) {
ProvObjects::DeviceRules Rules;
StorageService()->InventoryDB().EvaluateDeviceSerialNumberRules(SerialNumber, Rules);
Answer.set("firmwareUpgrade", Rules.firmwareUpgrade);
Answer.set("firmwareRCOnly", Rules.rcOnly == "yes");
return ReturnObject(Answer);
} else if(GetBoolParameter("rrmSettings",false)) {
ProvObjects::DeviceRules Rules;
StorageService()->InventoryDB().EvaluateDeviceSerialNumberRules(SerialNumber, Rules);
if(Rules.rrm=="no" || Rules.rrm=="inherit") {
Answer.set("rrm", Rules.rrm);
} else {
ProvObjects::RRMDetails D;
Poco::JSON::Parser P;
try {
auto Obj = P.parse(Rules.rrm).extract<Poco::JSON::Object::Ptr>();
Answer.set("rrm", Obj);
} catch (...) {
Answer.set("rrm", "invalid");
}
}
return ReturnObject(Answer);
} else if(GetBoolParameter("applyConfiguration", false)) {
poco_debug(Logger(), fmt::format("{}: Retrieving configuration.",Existing.serialNumber));
auto Device = std::make_shared<APConfig>(SerialNumber, Existing.deviceType, Logger(), false);
auto Configuration = Poco::makeShared<Poco::JSON::Object>();
Poco::JSON::Object ErrorsObj, WarningsObj;
ProvObjects::InventoryConfigApplyResult Results;
poco_debug(Logger(), fmt::format("{}: Computing configuration.",Existing.serialNumber));
if (Device->Get(Configuration)) {
std::ostringstream OS;
Configuration->stringify(OS);
Results.appliedConfiguration = OS.str();
auto Response=Poco::makeShared<Poco::JSON::Object>();
poco_debug(Logger(), fmt::format("{}: Sending configuration push.",Existing.serialNumber));
if (SDK::GW::Device::Configure(this, SerialNumber, Configuration, Response)) {
poco_debug(Logger(), fmt::format("{}: Sending configuration pushed.",Existing.serialNumber));
GetRejectedLines(Response, Results.warnings);
Results.errorCode = 0;
} else {
poco_debug(Logger(), fmt::format("{}: Sending configuration failed.",Existing.serialNumber));
Results.errorCode = 1;
}
} else {
poco_debug(Logger(), fmt::format("{}: Configuration is bad.",Existing.serialNumber));
Results.errorCode = 1;
}
Results.to_json(Answer);
return ReturnObject(Answer);
} else if(GetBoolParameter("resolveConfig", false)) {
poco_debug(Logger(),fmt::format("{}: Retrieving configuration.",Existing.serialNumber));
auto Device = std::make_shared<APConfig>(SerialNumber, Existing.deviceType, Logger(), false);
auto Configuration = Poco::makeShared<Poco::JSON::Object>();
Poco::JSON::Object ErrorsObj, WarningsObj;
ProvObjects::InventoryConfigApplyResult Results;
poco_debug(Logger(),Poco::format("{}: Computing configuration.",Existing.serialNumber));
if (Device->Get(Configuration)) {
Answer.set("configuration", Configuration);
} else {
Answer.set("error", 1);
}
return ReturnObject(Answer);
} else if(QB_.AdditionalInfo) {
AddExtendedInfo(Existing,Answer);
}
Existing.to_json(Answer);
ReturnObject(Answer);
}
void RESTAPI_inventory_handler::DoDelete() {
ProvObjects::InventoryTag Existing;
std::string SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER,"");
if(SerialNumber.empty() || !DB_.GetRecord(RESTAPI::Protocol::SERIALNUMBER,SerialNumber,Existing)) {
return NotFound();
}
MoveUsage(StorageService()->PolicyDB(),DB_,Existing.managementPolicy,"",Existing.info.id);
RemoveMembership(StorageService()->VenueDB(),&ProvObjects::Venue::configurations,Existing.venue,Existing.info.id);
RemoveMembership(StorageService()->EntityDB(),&ProvObjects::Entity::configurations,Existing.entity,Existing.info.id);
MoveUsage(StorageService()->LocationDB(),DB_,Existing.location,"",Existing.info.id);
MoveUsage(StorageService()->ContactDB(),DB_,Existing.contact,"",Existing.info.id);
if(!Existing.deviceConfiguration.empty()) {
ProvObjects::DeviceConfiguration DC;
if(StorageService()->ConfigurationDB().GetRecord("id", Existing.deviceConfiguration, DC)) {
if(DC.subscriberOnly)
StorageService()->ConfigurationDB().DeleteRecord("id", Existing.deviceConfiguration);
else
StorageService()->ConfigurationDB().DeleteInUse("id", Existing.deviceConfiguration, DB_.Prefix(),
Existing.info.id);
}
}
MoveUsage(StorageService()->PolicyDB(),DB_,Existing.managementPolicy,"",Existing.info.id);
MoveUsage(StorageService()->LocationDB(),DB_,Existing.location,"",Existing.info.id);
MoveUsage(StorageService()->ContactDB(),DB_,Existing.contact,"",Existing.info.id);
MoveUsage(StorageService()->ConfigurationDB(),DB_,Existing.deviceConfiguration,"",Existing.info.id);
ManageMembership(StorageService()->EntityDB(),&ProvObjects::Entity::devices,Existing.entity,"",Existing.info.id);
ManageMembership(StorageService()->VenueDB(),&ProvObjects::Venue::devices,Existing.venue,"",Existing.info.id);
DB_.DeleteRecord("id", Existing.info.id);
SerialNumberCache()->DeleteSerialNumber(SerialNumber);
return OK();
}
void RESTAPI_inventory_handler::DoPost() {
std::string SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER,"");
Poco::toLowerInPlace(SerialNumber);
if(SerialNumber.empty()) {
return BadRequest(RESTAPI::Errors::MissingSerialNumber);
}
if(!NormalizeMac(SerialNumber)) {
return BadRequest(RESTAPI::Errors::InvalidSerialNumber);
}
if(DB_.Exists(RESTAPI::Protocol::SERIALNUMBER,SerialNumber)) {
return BadRequest(RESTAPI::Errors::SerialNumberExists);
}
const auto & RawObject = ParsedBody_;
ProvObjects::InventoryTag NewObject;
if (!NewObject.from_json(RawObject)) {
return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
}
NormalizeMac(NewObject.serialNumber);
if(SerialNumber!=NewObject.serialNumber) {
return BadRequest(RESTAPI::Errors::SerialNumberMismatch);
}
if((RawObject->has("deviceRules") && !ValidDeviceRules(NewObject.deviceRules,*this))) {
return;
}
if(!Provisioning::DeviceClass::Validate(NewObject.devClass.c_str())) {
return BadRequest(RESTAPI::Errors::InvalidDeviceClass);
}
if(NewObject.devClass.empty()) {
NewObject.devClass = Provisioning::DeviceClass::ANY;
}
if(!ProvObjects::CreateObjectInfo(RawObject, UserInfo_.userinfo, NewObject.info)) {
return BadRequest( RESTAPI::Errors::NameMustBeSet);
}
if(NewObject.deviceType.empty() || !DeviceTypeCache()->IsAcceptableDeviceType(NewObject.deviceType)) {
return BadRequest(RESTAPI::Errors::InvalidDeviceTypes);
}
if(OpenWifi::EntityDB::IsRoot(NewObject.entity) || (!NewObject.entity.empty() && !StorageService()->EntityDB().Exists("id",NewObject.entity))) {
return BadRequest(RESTAPI::Errors::ValidNonRootUUID);
}
if(!NewObject.venue.empty() && !StorageService()->VenueDB().Exists("id",NewObject.venue)) {
return BadRequest(RESTAPI::Errors::VenueMustExist);
}
if(!NewObject.venue.empty() && !NewObject.entity.empty()) {
return BadRequest(RESTAPI::Errors::NotBoth);
}
if(!NewObject.location.empty() && !StorageService()->LocationDB().Exists("id",NewObject.location)) {
return BadRequest(RESTAPI::Errors::LocationMustExist);
}
if(!NewObject.contact.empty() && !StorageService()->ContactDB().Exists("id",NewObject.contact)) {
return BadRequest(RESTAPI::Errors::ContactMustExist);
}
if(!NewObject.deviceConfiguration.empty() && !StorageService()->ConfigurationDB().Exists("id",NewObject.deviceConfiguration)) {
return BadRequest(RESTAPI::Errors::ConfigurationMustExist);
}
if(!NewObject.managementPolicy.empty() && !StorageService()->PolicyDB().Exists("id",NewObject.managementPolicy)) {
return BadRequest(RESTAPI::Errors::UnknownManagementPolicyUUID);
}
std::vector<std::string> Errors;
auto ObjectsCreated = CreateObjects(NewObject,*this,Errors);
if(!Errors.empty()) {
return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
}
if(DB_.CreateRecord(NewObject)) {
SDK::GW::Device::SetOwnerShip(this, SerialNumber, NewObject.entity, NewObject.venue, NewObject.subscriber);
SerialNumberCache()->AddSerialNumber(SerialNumber,NewObject.deviceType);
MoveUsage(StorageService()->PolicyDB(),DB_,"",NewObject.managementPolicy,NewObject.info.id);
MoveUsage(StorageService()->LocationDB(),DB_,"",NewObject.location,NewObject.info.id);
MoveUsage(StorageService()->ContactDB(),DB_,"",NewObject.contact,NewObject.info.id);
MoveUsage(StorageService()->ConfigurationDB(),DB_,"",NewObject.deviceConfiguration,NewObject.info.id);
ManageMembership(StorageService()->EntityDB(),&ProvObjects::Entity::devices,"",NewObject.entity,NewObject.info.id);
ManageMembership(StorageService()->VenueDB(),&ProvObjects::Venue::devices,"",NewObject.venue,NewObject.info.id);
ProvObjects::InventoryTag NewTag;
DB_.GetRecord("id",NewObject.info.id,NewTag);
Poco::JSON::Object Answer;
NewTag.to_json(Answer);
return ReturnObject(Answer);
}
InternalError(RESTAPI::Errors::RecordNotCreated);
}
void RESTAPI_inventory_handler::DoPut() {
std::string SerialNumber = GetBinding(RESTAPI::Protocol::SERIALNUMBER,"");
if(SerialNumber.empty() || !Utils::ValidSerialNumber(SerialNumber)) {
return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
}
ProvObjects::InventoryTag Existing;
if(SerialNumber.empty() || !DB_.GetRecord(RESTAPI::Protocol::SERIALNUMBER,SerialNumber,Existing)) {
return NotFound();
}
auto RemoveSubscriber = GetParameter("removeSubscriber");
if(!RemoveSubscriber.empty()) {
if(Existing.subscriber == RemoveSubscriber) {
poco_information(Logger(),fmt::format("{}: removing subscriber ({})", SerialNumber, RemoveSubscriber));
ProvObjects::DeviceConfiguration DC;
if(StorageService()->ConfigurationDB().GetRecord("id",Existing.deviceConfiguration,DC)) {
poco_information(Logger(),fmt::format("{}: removing configuration for subscriber ({})", SerialNumber, RemoveSubscriber));
if(DC.subscriberOnly) {
if(!StorageService()->ConfigurationDB().DeleteRecord("id", Existing.deviceConfiguration)) {
poco_debug(Logger(),"Could not delete the subscriber configuration");
}
}
else {
poco_debug(Logger(),"Configurations is not for a subscriber.");
}
Existing.deviceConfiguration = "";
}
Existing.subscriber = "";
Poco::JSON::Object state;
state.set("date",Utils::Now());
state.set("method","auto-discovery");
state.set("last-operation", "returned to inventory");
std::ostringstream OO;
state.stringify(OO);
Existing.state = OO.str();
StorageService()->InventoryDB().UpdateRecord("id",Existing.info.id,Existing);
RemoveMembership(StorageService()->EntityDB(),&ProvObjects::Entity::devices,"id",Existing.info.id);
Poco::JSON::Object Answer;
Existing.to_json(Answer);
SDK::GW::Device::SetSubscriber(nullptr, SerialNumber, "");
return ReturnObject(Answer);
} else {
poco_information(Logger(),fmt::format("{}: wrong subscriber ({})", SerialNumber, RemoveSubscriber));
}
return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
}
const auto & RawObject = ParsedBody_;
ProvObjects::InventoryTag NewObject;
if(!NewObject.from_json(RawObject)) {
return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
}
if((RawObject->has("deviceRules") && !ValidDeviceRules(NewObject.deviceRules,*this))) {
return;
}
if(!Provisioning::DeviceClass::Validate(NewObject.devClass.c_str())) {
return BadRequest(RESTAPI::Errors::InvalidDeviceClass);
}
if(!NewObject.deviceType.empty()) {
if(!DeviceTypeCache()->IsAcceptableDeviceType(NewObject.deviceType)) {
return BadRequest(RESTAPI::Errors::InvalidDeviceTypes);
}
}
if(!UpdateObjectInfo(RawObject, UserInfo_.userinfo, Existing.info)) {
return BadRequest(RESTAPI::Errors::NameMustBeSet);
}
if(RawObject->has("deviceRules"))
Existing.deviceRules = NewObject.deviceRules;
std::string FromPolicy, ToPolicy;
if(!CreateMove(RawObject,"managementPolicy",&InventoryDB::RecordName::managementPolicy, Existing, FromPolicy,
ToPolicy, StorageService()->PolicyDB()))
return BadRequest(RESTAPI::Errors::EntityMustExist);
std::string FromEntity, ToEntity;
if(!CreateMove(RawObject,"entity",&InventoryDB::RecordName::entity, Existing, FromEntity, ToEntity,
StorageService()->EntityDB()))
return BadRequest(RESTAPI::Errors::EntityMustExist);
std::string FromVenue, ToVenue;
if(!CreateMove(RawObject,"venue",&InventoryDB::RecordName::venue, Existing, FromVenue, ToVenue,
StorageService()->VenueDB()))
return BadRequest(RESTAPI::Errors::VenueMustExist);
std::string FromLocation, ToLocation;
if(!CreateMove(RawObject,"location",&InventoryDB::RecordName::location, Existing, FromLocation, ToLocation,
StorageService()->LocationDB()))
return BadRequest(RESTAPI::Errors::VenueMustExist);
std::string FromContact, ToContact;
if(!CreateMove(RawObject,"contact",&InventoryDB::RecordName::contact, Existing, FromContact, ToContact,
StorageService()->ContactDB()))
return BadRequest(RESTAPI::Errors::VenueMustExist);
std::string FromConfiguration, ToConfiguration;
if(!CreateMove(RawObject,"deviceConfiguration",&InventoryDB::RecordName::deviceConfiguration, Existing,
FromConfiguration, ToConfiguration, StorageService()->ConfigurationDB()))
return BadRequest(RESTAPI::Errors::ConfigurationMustExist);
std::string NewSubScriber;
if(AssignIfPresent(RawObject, "subscriber", NewSubScriber)) {
if(!NewSubScriber.empty()) {
if(NewSubScriber!=Existing.subscriber) {
SecurityObjects::UserInfo U;
if(SDK::Sec::Subscriber::Get(this, NewSubScriber, U)) {
Existing.subscriber = NewSubScriber;
} else {
return BadRequest(RESTAPI::Errors::SubscriberMustExist);
}
}
} else {
Existing.subscriber = "";
}
}
AssignIfPresent(RawObject, "doNotAllowOverrides", Existing.doNotAllowOverrides);
if( RawObject->has("devClass") && NewObject.devClass!= Existing.devClass) {
Existing.devClass = NewObject.devClass;
}
if( RawObject->has("state") && NewObject.state!= Existing.state) {
Existing.state = NewObject.state;
}
std::vector<std::string> Errors;
auto ObjectsCreated = CreateObjects(NewObject,*this,Errors);
if(!Errors.empty()) {
return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
}
if(!ObjectsCreated.empty()) {
auto it = ObjectsCreated.find("configuration");
if(it!=ObjectsCreated.end()) {
FromConfiguration="";
ToConfiguration=it->second;
Existing.deviceConfiguration=ToConfiguration;
}
}
if(StorageService()->InventoryDB().UpdateRecord("id", Existing.info.id, Existing)) {
MoveUsage(StorageService()->PolicyDB(),DB_,FromPolicy,ToPolicy,Existing.info.id);
MoveUsage(StorageService()->LocationDB(),DB_,FromLocation,ToLocation,Existing.info.id);
MoveUsage(StorageService()->ContactDB(),DB_,FromContact,ToContact,Existing.info.id);
MoveUsage(StorageService()->ConfigurationDB(),DB_,FromConfiguration,ToConfiguration,Existing.info.id);
ManageMembership(StorageService()->EntityDB(),&ProvObjects::Entity::devices,FromEntity,ToEntity,Existing.info.id);
ManageMembership(StorageService()->VenueDB(),&ProvObjects::Venue::devices,FromVenue,ToVenue,Existing.info.id);
SDK::GW::Device::SetOwnerShip(this, SerialNumber, Existing.entity, Existing.venue, Existing.subscriber);
ProvObjects::InventoryTag NewObjectCreated;
DB_.GetRecord("id", Existing.info.id, NewObjectCreated);
Poco::JSON::Object Answer;
NewObject.to_json(Answer);
return ReturnObject(Answer);
}
InternalError(RESTAPI::Errors::RecordNotUpdated);
}
}
Reference in New Issue View Git Blame Copy Permalink