{"info":{"_postman_id":"e1310099-92e2-46e5-b6d1-b2472e0bac51","name":"FIWARE Accessing Context","description":"

This tutorial teaches FIWARE users how to alter the context programmatically

The tutorial builds on the entities created in the previous \nstock management example\nand enables a user understand how to write code in an NGSI\ncapable Node.js Express application in order to retrieve and alter context \ndata. This removes the need to use the command line to invoke cUrl commands.

The docker-compose file for this tutorial can be found on GitHub:

$\"GitHub\"$ FIWARE 105: Accessing Context Programmatically

Accessing the Context Data

For a typical smart solution you will be retrieving context data from diverse sources (such as a CRM system, social\nnetworks, mobile apps or IoT sensors for example) and then analysing the context programmatically to make appropriate\nbusiness logic decisions. For example in the stock management demo, the application will need to ensure that the prices\npaid for each item always reflect the current price held within the Product entity. For a dynamic system, the \napplication will also need to be able to amend the current context. (e.g. creating or updating data or accuating a sensor\nfor example)

In general terms, three basic scenarios are defined below:

Reading Data - e.g. Give me all the data for the Store entity urn:ngsi-ld:Store:001
Aggregation - e.g. Combine the InventoryItems entities for Store urn:ngsi-ld:Store:001 with \nthe names and prices of the Product entities for sale
Altering the Context - e.g. Make a sale of a product:
- Update the daily sales records by the price of the Product
- decrement the shelfCount of the InventoryItem entity
- Create a new Transaction Log record showing the sale has occurred
- Raise an alert in the warehouse if less than 10 objects remain on sale
- etc.
\n

As you can see the business logic behind each request to access/amend context can range from the simple to complex\ndepending upon business needs.

Making HTTP Requests in the language of your choice

The NGSI specification defines a language agnostic REST API based on the standard usage of HTTP verbs. Therefore context data can be accessed by any programming language, simply through making HTTP requests.

Here for example is the same HTTP request written in PHP, Node.js and Java

PHP (with `HTTPRequest`)

<?php\n\n$request = new HttpRequest();\n$request->setUrl('http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001');\n$request->setMethod(HTTP_METH_GET);\n\n$request->setQueryData(array(\n  'options' => 'keyValues'\n));\n\ntry {\n  $response = $request->send();\n\n  echo $response->getBody();\n} catch (HttpException $ex) {\n  echo $ex;\n}\n

Node.js (with `request` library)

const request = require(\"request\");\n\nconst options = { method: 'GET',\n  url: 'http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001',\n  qs: { options: 'keyValues' }};\n\nrequest(options, function (error, response, body) {\n  if (error) throw new Error(error);\n  console.log(body);\n});\n

Java (with `CloseableHttpClient` library)

CloseableHttpClient httpclient = HttpClients.createDefault();\ntry {\n    HttpGet httpget = new HttpGet(\"http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001?options=keyValues\");\n\n    ResponseHandler<String> responseHandler = new ResponseHandler<String>() {\n        @Override\n        public String handleResponse(\n                final HttpResponse response) throws ClientProtocolException, IOException {\n            int status = response.getStatusLine().getStatusCode();\n            if (status >= 200 && status < 300) {\n                HttpEntity entity = response.getEntity();\n                return entity != null ? EntityUtils.toString(entity) : null;\n            } else {\n                throw new ClientProtocolException(\"Unexpected response status: \" + status);\n            }\n        }\n\n    };\n    String body = httpclient.execute(httpget, responseHandler);\n    System.out.println(body);\n} finally {\n    httpclient.close();\n}\n

Generating NGSI API Clients

As you can see from the examples above, each one uses their own programming paradigm to do the following:

Create a well formed URL.
Make an HTTP GET request.
Retrieve the response.
Check for an error status and throw an exception if necessary.
Return the body of the request for further processing.

Since such boilerplate code is frequently re-used it is usually hidden within a library.

The swagger-codegen tool is able to generate boilerplate API client libraries in a wide variety of programming languages directly from the NGSI v2 Swagger Specification

swagger-codegen generate \\\n  -l javascript \\\n  -i http://fiware.github.io/specifications/OpenAPI/ngsiv2/ngsiv2-openapi.json \n

The generated client can then be used by the code within your own application.

The teaching goal of this tutorial

The aim of this tutorial is to improve developer understanding of programmatic access of context data\nthrough defining and discussing a series of generic code examples covering common data access scenarios. \nFor this purpose a simple Node.js Express application will be created.

The intention here is not to teach users how to write an application in Express - indeed any language could\nhave been chosen. It is merely to show how any sample programming language could be used alter the\ncontext to achieve the business logic goals.

Obviously, your choice of programming language will depend upon your own business needs - when reading the code\nbelow please keep this in mind and substitute Node.js with your own programming language as appropriate.

Entities within a stock management system

The relationship between our entities is defined as shown:

$\"\"$

The Store, Product and InventoryItem entities will be used to display data on the front-end of our demo application.

Architecture

This application will make use of only one FIWARE component - the Orion Context Broker. Usage of the Orion Context Broker is sufficient for an application to qualify as “Powered by FIWARE”.

Currently, the Orion Context Broker relies on open source MongoDB technology to keep\npersistence of the context data it holds. To request context data from external sources, a simple Context Provider NGSI \nproxy has also been added. To visualise and interact with the Context we will add a simple Express application

Therefore, the architecture will consist of four elements:

The Orion Context Broker server which will receive requests using NGSI
The underlying MongoDB database associated to the Orion Context Broker server
The Context Provider NGSI proxy which will will:
- receive requests using NGSI
- makes requests to publicly available data sources using their own APIs in a proprietory format
- returns context data back to the Orion Context Broker in NGSI format.
\n
The Stock Management Frontend which will will:
- Display store information
- Show which products can be bought at each store
- Allow users to \"buy\" products and reduce the stock count.
\n

Since all interactions between the elements are initiated by HTTP requests, the entities can be containerized and run\nfrom exposed ports.

$\"\"$

The necessary configuration information can be seen in the services section of the associated docker-compose.yml file. It\nhas been described in a previous tutorial

Prerequisites

Docker

To keep things simple both components will be run using Docker. Docker is a container technology\nwhich allows to different components isolated into their respective environments.

To install Docker on Windows follow the instructions here
To install Docker on Mac follow the instructions here
To install Docker on Linux follow the instructions here

Docker Compose is a tool for defining and running multi-container Docker applications. A \nYAML file is used\nconfigure the required services for the application. This means all container sevices can be brought up in a single \ncommmand. Docker Compose is installed by default as part of Docker for Windows and Docker for Mac, however Linux users \nwill need to follow the instructions found here

Cygwin

We will start up our services using a simple bash script. Windows users should download cygwin to provide a\ncommand line functionality similar to a Linux distribution on Windows.

Start Up

All services can be initialised from the command line by running the bash script provided within the repository:

./services create; ./services start;\n

This command will also import seed data from the previous Stock Management example on startup.

\n
:information_source: Note: If you want to clean up and start over again you can do so with the following command:
\n
./services stop\n
\n

Stock Management Frontend

All the code Node.js Express for the demo can be found within the proxy folder within the GitHub repository.Stock Management example. The application runs on the following URLs:

http://localhost:3000/app/store/urn:ngsi-ld:Store:001
http://localhost:3000/app/store/urn:ngsi-ld:Store:002
http://localhost:3000/app/store/urn:ngsi-ld:Store:003
http://localhost:3000/app/store/urn:ngsi-ld:Store:004

\n
:information_source: Tip Additionally, you can also watch the status of recent requests yourself by\nfollowing the container logs or viewing information on localhost:3000/app/monitor on a web browser.
\n
$\"FIWARE$
\n

NGSI v2 npm library

An NGSI v2 compatible npm library has been developed by the\nSmartSDK team. This is a callback-based library which will be used to take care of\nour low level HTTP requests and will simplify the code to be written. The methods exposed in the library map\ndirectly onto the NGSI v2 CRUD operations\nwith the following names:

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

HTTP Verb	`/v2/entities`	`/v2/entities/<entity>`
POST	`createEntity()`	Not used
GET	`listEntities()`	`retrieveEntity()`
PUT	Not used	Not used
PATCH	Not used	Not used
DELETE	Not used	`removeEntity()`

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

HTTP Verb	`.../attrs`	`.../attrs/<attribute>`	`.../attrs/<attribute>/value`
POST	`updateOrAppendEntityAttributes()`	Not used	Not used
GET	`retrieveEntityAttributes()`	Not used	`getAttributeValue()`
PUT	Not used	Not used	`updateAttributeValue()`
PATCH	`updateExistingEntityAttributes()`	Not used	Not used
DELETE.	Not used	`removeASingleAttribute()`	Not used

Analysing the Code

The code under discussion can be found within the store controller in the Git Repository

Initializing the library

We don't want to reinvent the wheel and spend time writing a unnecessary boilerplate code for HTTP access. Therefore\nwe will use the exising ngsi_v2 NPM library. This needs to be included in the header of the file as shown. The\nbasePath must also be set - this defines the location of the Orion Context Broker.

const NgsiV2 = require('ngsi_v2');\nconst defaultClient = NgsiV2.ApiClient.instance;\ndefaultClient.basePath = process.env.CONTEXT_BROKER || 'http://localhost:1026/v2';\n

Reading Store Data

This example reads the context data of a given Store entity to display the results on screen.\nReading entity data can be done using the apiInstance.retrieveEntity() method. Since the library uses callbacks,\nthey have been wrapped by a Promise function as shown below. The libary function apiInstance.retrieveEntity() \nwill fill out the URL for the GET request and make the necessary HTTP call:

function retrieveEntity(entityId, opts) {\n  return new Promise(function(resolve, reject) {\n    const apiInstance = new NgsiV2.EntitiesApi();\n    apiInstance.retrieveEntity(entityId, opts, (error, data) => {\n      return error ? reject(error) : resolve(data);\n    });\n  });\n}\n

This enables us to wrap the requests in Promises as shown:

function displayStore(req, res) {\n  retrieveEntity(\n    req.params.storeId, { options: 'keyValues', type: 'Store' })\n  .then(store => {\n    // If a store has been found display it on screen\n    return res.render('store', { title: store.name, store});\n  })\n  .catch(error => {\n    debug(error);\n    // If no store has been found, display an error screen\n      return res.render('store-error', {title: 'Error', error});\n  });\n}\n

Indirectly this is making an HTTP GET request to http://localhost:1026/v2/entities/<store-id>?type=Store&options=keyValues.\nNote the re-use of the Store URN in the incoming request.

The equivalent cUrl command would be as shown:

curl -X GET \\\n  'http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001?options=keyValues'\n

The response will be as shown below:

{\n    \"id\": \"urn:ngsi-ld:Store:001\",\n    \"type\": \"Store\",\n    \"address\": {\n        \"streetAddress\": \"Bornholmer Straße 65\",\n        \"addressRegion\": \"Berlin\",\n        \"addressLocality\": \"Prenzlauer Berg\",\n        \"postalCode\": \"10439\"\n    },\n    \"location\": {\n        \"type\": \"Point\",\n        \"coordinates\": [\n            13.3986,\n            52.5547\n        ]\n    },\n    \"name\": \"Bösebrücke Einkauf\"\n}\n

The store data from the HTTP response body is then passed to the PUG rendering engine to display on screen as\nshown below:

`http://localhost:3000/app/store/urn:ngsi-ld:Store:005`

$\"Store$

For efficiency, it is important to request as few attributes as possible, in order to reduce network traffic.\nThis optimization has not been made in the code yet.

An error handler is necessary in case the context data is not available - for example if a user queries for a\nstore that does not exist. This will forward to an error page as shown:

`http://localhost:3000/app/store/urn:ngsi-ld:Store:005`

$\"Store$

The equivalent cUrl command would be as shown:

curl -X GET \\\n  'http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001?options=keyValues'\n

The response has a status of 404 Not Found with a body as shown below:

{\n    \"error\": \"NotFound\",\n    \"description\": \"The requested entity has not been found. Check type and id\"\n}\n

The error object in the catch method hold the error response. This is then displayed on the front end.

Aggregating Products and Inventory Items

This example reads the context data of the current InventoryItem entities for a given store and combines\nthe information with the prices from the Product entities. The result is information to be displayed on\nthe cash till.

$\"Till\"$

Multiple entities can be requested and aggregated by creating a Promise chain or by usign Promise.all. \nHere the Product and InventoryItems entities have been requested using the apiInstance.listEntities() \nlibrary method. The presence of the q parameter in the request will filter the list of entities received.

function displayTillInfo(req, res) {\n  Promise.all([ \n    listEntities({\n    options: 'keyValues',\n    type: 'Product',\n  }), listEntities({\n    q: 'refStore==' + req.params.storeId,\n    options: 'keyValues',\n    type: 'InventoryItem',\n  })])\n  .then(values => {\n    // If values have been found display it on screen\n    return res.render('till', { products : values[0], inventory : values[1] });\n  })\n  .catch(error => {\n    debug(error);\n    // An error occurred, return with no results\n    return res.render('till', { products : {}, inventory : {}});\n  });\n}\n\n\nfunction listEntities(opts) {\n  return new Promise(function(resolve, reject) {\n    const apiInstance = new NgsiV2.EntitiesApi();\n    apiInstance.listEntities(opts, (error, data) => {\n      return error ? reject(error) : resolve(data);\n    });\n  });\n}\n

The code used for aggregating the results (displaying the product names for each item stocked) has been delegated\nto a mixin on the front-end. The foreign key aggregation (item.refProduct === product.id) could have been\nadded to the Node.js code if we were passing on aggregated data to another component:

mixin product(item, products)\n  each product in products\n    if (item.refProduct === product.id)\n      span(id=`${product.id}`)\n        strong\n          | #{product.name}\n\n        | &nbsp; @ #{product.price /100} &euro; each\n        | - #{item.shelfCount} in stock\n        |\n\n

Again an error handler has been created to ensure that if any of the HTTP requests to the Orion Context Broker fail, an empty list of products is returned.

Retrieving the full list of Product entities for each request is not efficient. It would be better to load the list of products from cache, and only update the list if prices have changed. This could be achieved using the NGSI Subscription mechanism which is the subject of a subsequent tutorial.

Updating Context

Buying an item will involve decrementing the number of items left on a shelf. The example consists of two linked requests.\nThe reading of the InventoryItem entity data can be done using the apiInstance.retrieveEntity() method as shown \npreviously. The data is then ammended in memory before being sent to the Orion Context Broker using the \napiInstance.updateExistingEntityAttributes() method. This is effectively just a wrapper around an HTTP PATCH request to\nhttp://localhost:1026/v2/entities/<inventory-id>?type=InventoryItem, with a body containing the elements to be updated.\nThere is no error handling on this function, it has been left to a function on the router.

async function buyItem(req, res) {\n  const inventory = await retrieveEntity(req.params.inventoryId, {\n    options: 'keyValues',\n    type: 'InventoryItem',\n  });\n  const count = inventory.shelfCount - 1;\n  await updateExistingEntityAttributes(\n    req.params.inventoryId,\n    { shelfCount: { type: 'Integer', value: count } },\n    {\n      type: 'InventoryItem',\n    }\n  );\n  res.redirect(`/app/store/${inventory.refStore}/till`);\n}\n\nfunction updateExistingEntityAttributes(entityId, body, opts) {\n  return new Promise(function(resolve, reject) {\n    const apiInstance = new NgsiV2.EntitiesApi();\n    apiInstance.updateExistingEntityAttributes(entityId, body, opts, (error, data) => {\n      return error ? reject(error) : resolve(data);\n    });\n  });\n}\n

Care should be taken when amending the context to ensure that changes of state are committed atomically. This is not an issue in Node.JS since it is single threaded - each request but will execute each request one by one. However in multithreaded environments (such as Java for example) it could be possible to service two buy requests concurrently - meaning that the shelfCount will only be reduced once if the requests interleave. This issue can be resolved by the use of a monitor mechanism.

This is the equivalent of the following cURL commands (plus some business logic)

curl -X GET \\\n  'http://localhost:1026/v2/entities/urn:ngsi-ld:InventoryItem:001/attrs/shelfCount/value'\ncurl -X PATCH \\\n  'http://localhost:1026/v2/entities/urn:ngsi-ld:InventoryItem:006/attrs' \\\n  -H 'Cache-Control: no-cache' \\\n  -H 'Content-Type: application/json' \\\n  -H 'Postman-Token: af6d60fe-ef9f-4d54-8382-3ddd48d43b82' \\\n  -d '{ \"shelfCount\": \n  { \"type\": \"Integer\", \"value\": \"13\" } \n}'\n

","schema":"https://schema.getpostman.com/json/collection/v2.0.0/collection.json","toc":[{"content":"Accessing the Context Data","slug":"accessing-the-context-data"},{"content":"Architecture","slug":"architecture"},{"content":"Prerequisites","slug":"prerequisites"},{"content":"Start Up","slug":"start-up"},{"content":"Stock Management Frontend","slug":"stock-management-frontend"}],"owner":"513743","collectionId":"e1310099-92e2-46e5-b6d1-b2472e0bac51","publishedId":"RW1bnetD","public":true,"customColor":{"top-bar":"FFFFFF","right-sidebar":"4C4C4C","highlight":"233C68"},"publishDate":"2020-01-02T11:02:28.000Z"},"item":[{"name":"Retrieve Data for Store 1","id":"569a70c9-57f4-42e2-bc20-f461b48429f2","request":{"method":"GET","header":[],"body":{"mode":"formdata","formdata":[]},"url":"http://localhost:1026/v2/entities/urn:ngsi-ld:Store:001?options=keyValues","description":"

This example returns the context data of urn:ngsi-ld:Store:001.

It is the equivalent of the following Node.js code:

function displayStore(req, res) {\n    retrieveEntity(\n        req.params.storeId, { options: 'keyValues', type: 'Store' })\n    .then(store => {\n        // If a store has been found display it on screen\n        return res.render('store', { title: store.name, store});\n    })\n    .catch(error => {\n        debug(error);\n        // If no store has been found, display an error screen\n        return res.render('store-error', {title: 'Error', error});\n    });\n}\n

\n","urlObject":{"protocol":"http","path":["v2","entities","urn:ngsi-ld:Store:001"],"host":["localhost:1026"],"query":[{"description":{"content":"

keyValues option in order to get a more compact and brief representation, including just attribute values
values option combined with a list of attribute values attrs for an ordered list of attributes only

\n","type":"text/plain"},"key":"options","value":"keyValues"},{"disabled":true,"description":{"content":"

Entity type, to avoid ambiguity in case there are several entities with the same entity id

\n","type":"text/plain"},"key":"type","value":"Store"},{"disabled":true,"description":{"content":"

Ordered list of attribute names to display

\n","type":"text/plain"},"key":"attrs","value":"name"}],"variable":[]}},"response":[],"_postman_id":"569a70c9-57f4-42e2-bc20-f461b48429f2"},{"name":"Retrieve Data for Store 5","id":"67a92179-027d-473b-89ab-47705def2a81","request":{"method":"GET","header":[],"body":{"mode":"formdata","formdata":[]},"url":"http://localhost:1026/v2/entities/urn:ngsi-ld:Store:005?options=keyValues","description":"

This example returns the context data of urn:ngsi-ld:Store:005 which does not exist.

It is the equivalent of the following Node.js code:

function displayStore(req, res) {\n    retrieveEntity(\n        req.params.storeId, { options: 'keyValues', type: 'Store' })\n    .then(store => {\n        // If a store has been found display it on screen\n        return res.render('store', { title: store.name, store});\n    })\n    .catch(error => {\n        debug(error);\n        // If no store has been found, display an error screen\n        return res.render('store-error', {title: 'Error', error});\n    });\n}\n

Because the response is an error status, the catch clause will be activated and an error message displayed on screen.

\n","urlObject":{"protocol":"http","path":["v2","entities","urn:ngsi-ld:Store:005"],"host":["localhost:1026"],"query":[{"description":{"content":"

keyValues option in order to get a more compact and brief representation, including just attribute values
values option combined with a list of attribute values attrs for an ordered list of attributes only

\n","type":"text/plain"},"key":"options","value":"keyValues"},{"disabled":true,"description":{"content":"

Entity type, to avoid ambiguity in case there are several entities with the same entity id

\n","type":"text/plain"},"key":"type","value":"Store"},{"disabled":true,"description":{"content":"

Ordered list of attribute names to display

\n","type":"text/plain"},"key":"attrs","value":"name"}],"variable":[]}},"response":[],"_postman_id":"67a92179-027d-473b-89ab-47705def2a81"},{"name":"Retrieve All Product Data","id":"6f9391c8-b726-4fad-88c3-f1aceb2338f5","request":{"method":"GET","header":[],"body":{"mode":"formdata","formdata":[]},"url":"http://localhost:1026/v2/entities/?type=Product&options=keyValues","description":"

This example returns all the Product entities within the context data.

It is the equivalent of the following lines of Node.js code:

function displayProducts(req, res) {\n    listEntities({\n        options: 'keyValues',\n        type: 'Product',\n    })\n    .then(products => {\n        // If products have been found display it on screen\n        return res.render('till', { products });\n    })\n    .catch(error => {\n        debug(error);\n        // An error occurred, return with no results\n        return res.render('till', { products : {}});\n    });\n}\n

","urlObject":{"protocol":"http","path":["v2","entities",""],"host":["localhost:1026"],"query":[{"description":{"content":"

Entity type, to avoid ambiguity in case there are several entities with the same entity id

\n","type":"text/plain"},"key":"type","value":"Product"},{"description":{"content":"

keyValues option in order to get a more compact and brief representation, including just attribute values
values option combined with a list of attribute values attrs for an ordered list of attributes only

\n","type":"text/plain"},"key":"options","value":"keyValues"},{"disabled":true,"description":{"content":"

Ordered list of attribute names to display

\n","type":"text/plain"},"key":"attrs","value":"name"}],"variable":[]}},"response":[],"_postman_id":"6f9391c8-b726-4fad-88c3-f1aceb2338f5"},{"name":"Retrieve Inventory Items for Store 1","id":"8f03f03b-0e5d-44c1-8490-fbee1d22d972","request":{"method":"GET","header":[],"body":{"mode":"formdata","formdata":[]},"url":"http://localhost:1026/v2/entities/?type=InventoryItem&options=keyValues&q=refStore==urn:ngsi-ld:Store:001","description":"

This example returns a filtered list of all InventoryItem entities associated with urn:ngsi-ld:Store:001

It is the equivalent of the following lines of Node.js code:

function displayInventoryItems(req, res) {\n    listEntities({\n        q: 'refStore==' + req.params.storeId,\n        options: 'keyValues',\n        type: 'InventoryItem',\n    })\n    .then(inventory => {\n        // If inventory items have been found display it on screen\n        return res.render('till', { inventory });\n    })\n    .catch(error => {\n        debug(error);\n        // An error occurred, return with no results\n        return res.render('till', inventory : {}});\n    });\n

","urlObject":{"protocol":"http","path":["v2","entities",""],"host":["localhost:1026"],"query":[{"key":"type","value":"InventoryItem"},{"description":{"content":"

keyValues option in order to get a more compact and brief representation, including just attribute values
values option combined with a list of attribute values attrs for an ordered list of attributes only

\n","type":"text/plain"},"key":"options","value":"keyValues"},{"disabled":true,"description":{"content":"

Ordered list of attribute names to display

\n","type":"text/plain"},"key":"attrs","value":"name"},{"key":"q","value":"refStore==urn:ngsi-ld:Store:001"}],"variable":[]}},"response":[],"_postman_id":"8f03f03b-0e5d-44c1-8490-fbee1d22d972"},{"name":"Retrieve the Shelf Count of an Inventory Item","id":"46c6e18b-ae38-4241-b1d9-afa58ddd6af8","request":{"method":"GET","header":[],"body":{"mode":"formdata","formdata":[]},"url":"http://localhost:1026/v2/entities/urn:ngsi-ld:InventoryItem:001/attrs/shelfCount/value","description":"

This example returns the number of items left on the shelf for InventoryItem urn:ngsi-ld:InventoryItem:001.

It is the equivalent of the following Node.js code:

function getShelfCount(req, res){\n    const inventory = await getAttributeValue(req.params.inventoryId, 'shelfCount', {\n        type: 'InventoryItem',\n    });\n}\n

","urlObject":{"protocol":"http","path":["v2","entities","urn:ngsi-ld:InventoryItem:001","attrs","shelfCount","value"],"host":["localhost:1026"],"query":[],"variable":[]}},"response":[],"_postman_id":"46c6e18b-ae38-4241-b1d9-afa58ddd6af8"},{"name":"Update the Shelf Count of an Inventory Item","id":"dea46c63-38bc-4b7c-a693-59cbb598b8cf","request":{"method":"PATCH","header":[{"key":"Content-Type","value":"application/json"}],"body":{"mode":"raw","raw":"{ \"shelfCount\": \n { \"type\": \"Integer\", \"value\": \"13\" } \n}"},"url":"http://localhost:1026/v2/entities/urn:ngsi-ld:InventoryItem:006/attrs","description":"

This example amends the number of items left on the shelf for InventoryItem urn:ngsi-ld:InventoryItem:001 and sets the value to 13.

It is the equivalent of the following Node.js code:

function updateShelfCount(req, res, count){\n    await updateExistingEntityAttributes(\n        req.params.inventoryId,\n        { \n            shelfCount: { type: 'Integer', value: count } \n            \n        },\n        {\n            type: 'InventoryItem',\n        });\n}\n

","urlObject":{"protocol":"http","path":["v2","entities","urn:ngsi-ld:InventoryItem:006","attrs"],"host":["localhost:1026"],"query":[],"variable":[]}},"response":[],"_postman_id":"dea46c63-38bc-4b7c-a693-59cbb598b8cf"}],"event":[{"listen":"prerequest","script":{"id":"a25c858c-0646-4514-85e8-f6f9aeafc5be","type":"text/javascript","exec":[""]}},{"listen":"test","script":{"id":"f81ca278-51ac-41c1-a4e6-66baed8434f2","type":"text/javascript","exec":[""]}}],"variable":[{"key":"orion","value":"localhost:1026","type":"string"}]}

Accessing the Context Data

Making HTTP Requests in the language of your choice

PHP (with HTTPRequest)

Node.js (with request library)

Java (with CloseableHttpClient library)

Generating NGSI API Clients

The teaching goal of this tutorial

Entities within a stock management system

Architecture

Prerequisites

Docker

Cygwin

Start Up

Stock Management Frontend

NGSI v2 npm library

Analysing the Code

Initializing the library

Reading Store Data

http://localhost:3000/app/store/urn:ngsi-ld:Store:005

http://localhost:3000/app/store/urn:ngsi-ld:Store:005

Aggregating Products and Inventory Items

Updating Context

PHP (with `HTTPRequest`)

Node.js (with `request` library)

Java (with `CloseableHttpClient` library)

`http://localhost:3000/app/store/urn:ngsi-ld:Store:005`

`http://localhost:3000/app/store/urn:ngsi-ld:Store:005`