/* **************************************************************************** * * deleteIndividualContextEntityAttribute - * * DELETE /v1/contextEntities/{entityId::id}/attributes/{attributeName} * DELETE /ngsi10/contextEntities/{entityId::id}/attributes/{attributeName} * * Payload In: None * Payload Out: StatusCode * * URI parameters: * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that use the standard operation UpdateContext as there is no restriction within UpdateContext. * [ attributesFormat=object: makes no sense for this operation as StatusCode is returned ] * * 0. Take care of URI params * 1. Fill in UpdateContextRequest from URL-path components * 2. Call postUpdateContext standard service routine * 3. Translate UpdateContextResponse to StatusCode * 4. Cleanup and return result */ std::string deleteIndividualContextEntityAttribute ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { std::string answer; std::string entityId = compV[2]; std::string entityType = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; std::string attributeName = compV[4]; StatusCode response; // 1. Fill in UpdateContextRequest from URL-path components parseDataP->upcr.res.fill(entityId, entityType, "false", attributeName, "", "DELETE"); // 2. Call postUpdateContext standard service routine postUpdateContext(ciP, components, compV, parseDataP); // 3. Translate UpdateContextResponse to StatusCode response.fill(parseDataP->upcrs.res); // 4. Cleanup and return result TIMED_RENDER(answer = response.render("", false, false)); response.release(); parseDataP->upcr.res.release(); return answer; }
/* **************************************************************************** * * putAttributeValueInstance - * * PUT /v1/contextEntities/{entity::id}/attributes/{attribute::name}/{metaID} * PUT /ngsi10/contextEntities/{entity::id}/attributes/{attribute::name}/{metaID} * * Payload In: UpdateContextAttributeRequest * Payload Out: StatusCode * * URI parameters * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that don't use the standard operation QueryContext as there is no Restriction otherwise. * Here, entity::type can be empty though, and it is, unless the URI parameter 'entity::type=TYPE' is used. * * 01. Check validity of path components VS payload * 02. Fill in UpdateContextRequest * 03. Call postUpdateContext * 04. Fill in StatusCode from UpdateContextResponse * 05. Render result * 06. Cleanup and return result */ std::string putAttributeValueInstance ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { std::string entityId = compV[2]; std::string attributeName = compV[4]; std::string metaID = compV[5]; std::string entityType = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; std::string answer; StatusCode response; // 01. Check validity of path components VS payload Metadata* mP = parseDataP->upcar.res.metadataVector.lookupByName("ID"); if ((mP != NULL) && (mP->value != metaID)) { std::string details = "unmatching metadata ID value URI/payload: /" + metaID + "/ vs /" + mP->value + "/"; response.fill(SccBadRequest, details); answer = response.render(ciP->outFormat, "", false, false); parseDataP->upcar.res.release(); return answer; } // 02. Fill in UpdateContextRequest parseDataP->upcr.res.fill(&parseDataP->upcar.res, entityId, entityType, attributeName, metaID, "UPDATE"); // 03. Call postUpdateContext postUpdateContext(ciP, components, compV, parseDataP); // 04. Fill in StatusCode from UpdateContextResponse response.fill(parseDataP->upcrs.res); // 05. Render result answer = response.render(ciP->outFormat, "", false, false); // 06. Cleanup and return result response.release(); parseDataP->upcar.res.release(); parseDataP->upcr.res.release(); parseDataP->upcrs.res.release(); return answer; }
/* **************************************************************************** * * deleteAttributeValueInstanceWithTypeAndId - * * DELETE /v1/contextEntities/type/{entity::type}/id/{entity::id}/attributes/{attribute::name}/{metaID} * DELETE /ngsi10/contextEntities/type/{entity::type}/id/{entity::id}/attributes/{attribute::name}/{metaID} * * Mapped Standard Operation: UpdateContextRequest/DELETE * * URI params: * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that use the standard operation UpdateContext as there is no restriction within UpdateContext. * * 01. URI parameters * 02. Check validity of URI params * 03. Fill in UpdateContextRequest * 04. Call postUpdateContext standard service routine * 05. Translate UpdateContextResponse to StatusCode * 06. Cleanup and return result */ std::string deleteAttributeValueInstanceWithTypeAndId ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { StatusCode response; std::string answer; std::string entityTypeFromUriParam; std::string entityTypeFromPath = compV[3]; std::string entityId = compV[5]; std::string attributeName = compV[7]; std::string metaId = compV[8]; // 01. URI parameters entityTypeFromUriParam = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; // 02. Check validity of URI params if ((entityTypeFromUriParam != "") && (entityTypeFromUriParam != entityTypeFromPath)) { LM_W(("Bad Input non-matching entity::types in URL")); response.fill(SccBadRequest, "non-matching entity::types in URL"); answer = response.render(ciP->outFormat, "", false, false); return answer; } // 03. Fill in UpdateContextRequest parseDataP->upcr.res.fill(entityId, entityTypeFromPath, "false", attributeName, metaId, "DELETE"); // 04. Call postUpdateContext standard service routine answer = postUpdateContext(ciP, components, compV, parseDataP); // 05. Translate UpdateContextResponse to StatusCode response.fill(parseDataP->upcrs.res); // 06. Cleanup and return result answer = response.render(ciP->outFormat, "", false, false); response.release(); parseDataP->upcr.res.release(); return answer; }
/* **************************************************************************** * * deleteIndividualContextEntity - */ std::string deleteIndividualContextEntity(ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP) { std::string answer; std::string entityId = "unknown entityId"; StatusCode response; if (compV.size() > 2) entityId = compV[2]; LM_T(LmtConvenience, ("CONVENIENCE: got a 'DELETE' request for entityId '%s'", entityId.c_str())); ciP->httpStatusCode = mapDeleteIndividualContextEntity(entityId, &response, ciP); answer = response.render(ciP->outFormat, "", false, false); response.release(); return answer; }
/* **************************************************************************** * * deleteAttributeValueInstance - * * DELETE /v1/contextEntities/{entity::id}/attributes/{attribute::name}/{metaID} * DELETE /ngsi10/contextEntities/{entity::id}/attributes/{attribute::name}/{metaID} * * Payload In: None * Payload Out: StatusCode * * Mapped Standard Operation: UpdateContextRequest/DELETE * * URI params: * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that use the standard operation UpdateContext as there is no restriction within UpdateContext. * * 01. URI parameters * 02. Fill in UpdateContextRequest * 03. Call postUpdateContext standard service routine * 04. Translate UpdateContextResponse to StatusCode * 05. Cleanup and return result * */ std::string deleteAttributeValueInstance ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { StatusCode response; std::string answer; std::string entityId = compV[2]; std::string attributeName = compV[4]; std::string metaId = compV[5]; std::string entityType; // 01. URI parameters entityType = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; // 02. Fill in UpdateContextRequest parseDataP->upcr.res.fill(entityId, entityType, "false", attributeName, metaId, "DELETE"); // 03. Call postUpdateContext standard service routine postUpdateContext(ciP, components, compV, parseDataP); // 04. Translate UpdateContextResponse to StatusCode response.fill(parseDataP->upcrs.res); // 05. Cleanup and return result TIMED_RENDER(answer = response.render("", false, false)); response.release(); parseDataP->upcr.res.release(); return answer; }
/* **************************************************************************** * * deleteIndividualContextEntity - * * Corresponding Standard Operation: UpdateContext/DELETE * * DELETE /v1/contextEntities/{entityId::id} * * Payload In: None * Payload Out: StatusCode * * URI parameters: * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that use the standard operation UpdateContext as there is no restriction within UpdateContext. * * 00. URI params * 01. Fill in UpdateContextRequest from URL-data + URI params * 02. Call postUpdateContext standard service routine * 03. Translate UpdateContextResponse to StatusCode * 04. If not found, put entity info in details * 05. Cleanup and return result */ std::string deleteIndividualContextEntity ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { std::string answer; std::string entityId = compV[2]; std::string entityType = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; StatusCode response; // 01. Fill in UpdateContextRequest fromURL-data + URI params parseDataP->upcr.res.fill(entityId, entityType, "false", "", "", "DELETE"); // 02. Call postUpdateContext standard service routine answer = postUpdateContext(ciP, components, compV, parseDataP); // 03. Translate UpdateContextResponse to StatusCode response.fill(parseDataP->upcrs.res); // 04. If not found, put entity info in details if ((response.code == SccContextElementNotFound) && (response.details == "")) { response.details = entityId; } // 05. Cleanup and return result TIMED_RENDER(answer = response.render(ciP->outFormat, "", false, false)); response.release(); parseDataP->upcr.res.release(); return answer; }
/* **************************************************************************** * * deleteAllEntitiesWithTypeAndId - * * DELETE /v1/contextEntities/type/{entity::type}/id/{entity::id} * * Payload In: None * Payload Out: StatusCode * * URI parameters: * - entity::type=TYPE (must coincide with type in URL-path) * - !exist=entity::type (if set - error -- entity::type cannot be empty) * - exist=entity::type (not supported - ok if present, ok if not present ...) * * 01. Get values from URL (+ entityId::type, exist, !exist) * 02. Check validity of URI params * 03. Fill in UpdateContextRequest * 04. Call Standard Operation * 05. Fill in response from UpdateContextResponse * 06. Cleanup and return result */ std::string deleteAllEntitiesWithTypeAndId ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { std::string entityType = compV[3]; std::string entityId = compV[5]; EntityTypeInfo typeInfo = EntityTypeEmptyOrNotEmpty; std::string typeNameFromUriParam = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; std::string answer; StatusCode response; // 01. Get values from URL (+ entityId::type, exist, !exist) if (ciP->uriParam[URI_PARAM_NOT_EXIST] == URI_PARAM_ENTITY_TYPE) { typeInfo = EntityTypeEmpty; } else if (ciP->uriParam[URI_PARAM_EXIST] == URI_PARAM_ENTITY_TYPE) { typeInfo = EntityTypeNotEmpty; } // 02. Check validity of URI params if (typeInfo == EntityTypeEmpty) { alarmMgr.badInput(clientIp, "entity::type cannot be empty for this request"); response.fill(SccBadRequest, "entity::type cannot be empty for this request"); TIMED_RENDER(answer = response.render("", false, false)); return answer; } else if ((typeNameFromUriParam != entityType) && (typeNameFromUriParam != "")) { alarmMgr.badInput(clientIp, "non-matching entity::types in URL"); response.fill(SccBadRequest, "non-matching entity::types in URL"); TIMED_RENDER(answer = response.render("", false, false)); return answer; } // 03. Fill in UpdateContextRequest parseDataP->upcr.res.fill(entityId, entityType, "", "", "", "DELETE"); // 04. Call Standard Operation postUpdateContext(ciP, components, compV, parseDataP); // 05. Fill in response from UpdateContextResponse response.fill(parseDataP->upcrs.res); // 06. Cleanup and return result TIMED_RENDER(answer = response.render("", false, false)); parseDataP->upcr.res.release(); response.release(); return answer; }
/* **************************************************************************** * * postAttributeValueInstanceWithTypeAndId - * * POST /v1/contextEntities/type/{entity::type}/id/{entity::id}/attributes/{attribute::name}/{metaID} * POST /ngsi10/contextEntities/type/{entity::type}/id/{entity::id}/attributes/{attribute::name}/{metaID} * * Payload In: UpdateContextAttributeRequest * Payload Out: StatusCode * * Mapped Standard Operation: UpdateContextRequest/APPEND * * URI parameters * - entity::type=TYPE * - note that '!exist=entity::type' and 'exist=entity::type' are not supported by convenience operations * that use the standard operation UpdateContext as there is no restriction within UpdateContext. * * 00. Get values from URI path * 01. Get values URI parameters * 02. Check validity of URI params VS URI path components * 03. Check validity of path components VS payload * 04. Fill in UpdateContextRequest * 05. Call postUpdateContext * 06. Fill in StatusCode from UpdateContextResponse * 07. Render result * 08. Cleanup and return result */ std::string postAttributeValueInstanceWithTypeAndId ( ConnectionInfo* ciP, int components, std::vector<std::string>& compV, ParseData* parseDataP ) { std::string entityType = compV[3]; std::string entityId = compV[5]; std::string attributeName = compV[7]; std::string metaID = compV[8]; std::string entityTypeFromUriParam; StatusCode response; std::string answer; // 01. Get values URI parameters entityTypeFromUriParam = ciP->uriParam[URI_PARAM_ENTITY_TYPE]; // 02. Check validity of URI params VS URI path components if ((entityTypeFromUriParam != "") && (entityTypeFromUriParam != entityType)) { LM_W(("Bad Input non-matching entity::types in URL")); response.fill(SccBadRequest, "non-matching entity::types in URL"); answer = response.render(ciP->outFormat, "", false, false); parseDataP->upcar.res.release(); return answer; } // 03. Check validity of path components VS payload Metadata* mP = parseDataP->upcar.res.metadataVector.lookupByName("ID"); if ((mP != NULL) && (mP->value != metaID)) { std::string details = "unmatching metadata ID value URI/payload: /" + metaID + "/ vs /" + mP->value + "/"; response.fill(SccBadRequest, details); answer = response.render(ciP->outFormat, "", false, false); parseDataP->upcar.res.release(); return answer; } // 04. Fill in UpdateContextRequest parseDataP->upcr.res.fill(&parseDataP->upcar.res, entityId, entityType, attributeName, metaID, "APPEND"); // 05. Call postUpdateContext postUpdateContext(ciP, components, compV, parseDataP); // 06. Fill in StatusCode from UpdateContextResponse response.fill(parseDataP->upcrs.res); // 07. Render result answer = response.render(ciP->outFormat, "", false, false); // 08. Cleanup and return result response.release(); parseDataP->upcar.res.release(); parseDataP->upcr.res.release(); parseDataP->upcrs.res.release(); return answer; }