Channel Feeds Data Forwarding
2018-11-26 05:08:10
Overview
The Channel Feeds Data Forwarding service will forward a copy of the original feed data from any UbiBot device to the given URL endpoint. This can be useful to seamlessly connect UbiBot devices to third-party platform business logic or third-party applications. This service requires activation on the UbiBot platform along with some development work on the data endpoint to correctly handle the incoming data feeds.
Activation Method
- Please login to https://console.ubibot.com
- From left side menu, click "Data Factory" -> "Data Forwarding".
- Follow the "Add new forwarding" instructions.
Data Forwarding Message Format
Data forwarding is achieved by sending POST requests to the given endpoint URL. The Content-Type header is set to "application / json". The original feed data is contained in the request body as follows:
- The feed data will be forwarded in JSON format to the given URL.
- The unique device channel_id: (string) can be used to distinguish the data from different devices.
- product_id: (string) device model
- serial: (string) serial number of the device.
- The feeds are an array consisting of:
- created_at: the time when the data feed was sampled in ISO 8601 format.
- field1..field10: sensor readings
- status: status information, such as SSID and ICCID
Note that you will need to send a response to the UbiBot platform within 15 seconds for each message.
Example Forwarded Data：
{
"channel_id": "123456",
"product_id": "ubibot-ws1p",
"serial": "123456XXXXX",
"feeds": [{
"created_at": "2022-04-24T09:06:56Z",
"field1": 24.495308
}, {
"created_at": "2022-04-24T09:06:56Z",
"field2": 82
}, {
"created_at": "2022-04-24T09:07:00Z",
"field5": -34
}],
"status": "mac=98:7b:f3:10:a1:e2,usb=1",
"ssid_base64": "VFBHUw=="
}
Requirements for Endpoint Response
- Please ensure the endpoint's response is made within 15 seconds, otherwise the platform will close the connection.
- If the endpoint sends a response with the string "SUCCESS", the platform will mark this forward request as successful. If the endpoint sends the string "ERROR" it means the request was unsuccessful. The UbiBot platform keeps track of all the response results for statistics purposes.
Simple PHP endpoint example:
<?php
try{
$data = file_get_contents('php://input'); //get POST payload forwarded from the UbiBot platform
$json = json_decode($data, true); //parse input data into json. You can handle the $json object from here.
//------Please make sure the response is made within 15 seconds, otherwise connection will be disconnected and marked unsuccessful.----------//
$myfile = file_put_contents('log.txt', $data.PHP_EOL , FILE_APPEND | LOCK_EX); //Write to a local log file for the demo.
echo "SUCCESS"; // if the request has been handled successfully.
}
catch (Exception $ex)
{
echo "ERROR";// if there is some error encountered
}
Simple NodeJS endpoint example:
const http = require('http');
const server = http.createServer(function (req, res) {
let type = req.headers["content-type"];
if (req.method.toLowerCase() === 'post' && type === "application/json") {
try{
////get POST payload
var jsonData = "";
req.on("data", function(chunk) {
jsonData += chunk;
});
req.on("end", function() {
//parse input data into json
var reqObj = JSON.parse(jsonData);
//-----------Make sure response is sent within 15 seconds------------//
var fs = require('fs');
fs.writeFile("log.txt", JSON.stringify(reqObj), function(err) {
if(err) {
res.end('ERROR');//mark request as error
}
});
res.end('SUCCESS');//mark request as successful
});
}catch{
res.end('ERROR');//mark request as error
}
}else{
res.end('ERROR');//mark request as error
}
});
//Setup listening IP and port
server.listen(8080, "127.0.0.1", function () {
console.log("server is started listen port 8080");
});Simple Python endpoint example:
from http.server import BaseHTTPRequestHandler, HTTPServer
import cgi
import json
class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
def do_POST(self):
try:
ctype, pdict = cgi.parse_header(self.headers.get('content-type'))
if ctype == 'application/json':
#get POST payload, parse input data into json
length = int(self.headers['content-length'])
jsonArray = json.loads(self.rfile.read(length))
#-----------Make sure response is made within 15 seconds------------#
myfile = open("log.txt",'a')
myfile.write(json.dumps(jsonArray))
myfile.write("\n")
myfile.close()
#request handled successfully
self.protocal_version = 'HTTP/1.1'
self.send_response(200)
self.send_header("Welcome", "Contect")
self.end_headers()
self.wfile.write(bytes("SUCCESS", "utf-8"))
return
else:
#request handled with error
self.protocal_version = 'HTTP/1.1'
self.send_response(300)
self.send_header("Welcome", "Contect")
self.end_headers()
self.wfile.write(bytes("ERROR", "utf-8"))
return
except:
#request handled with error
self.protocal_version = 'HTTP/1.1'
self.send_response(300)
self.send_header("Welcome", "Contect")
self.end_headers()
self.wfile.write(bytes("ERROR", "utf-8"))
return
def run():
port = 8080
print('starting server, port', port)
# Server settings
server_address = ('', port)
httpd = HTTPServer(server_address, testHTTPServer_RequestHandler)
print('running server...')
httpd.serve_forever()
if __name__ == '__main__':
run()
Simple C# ASP.NET endpoint example:
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace demo1.Controllers
{
public class FeedData
{
public DateTime created_at { get; set; }
public object field1 { get; set; }
public object field2 { get; set; }
public object field3 { get; set; }
public object field4 { get; set; }
public object field5 { get; set; }
public object field6 { get; set; }
public object field7 { get; set; }
public object field8 { get; set; }
public object field9 { get; set; }
public object field10 { get; set; }
}
public class DeviceData
{
public string channel_id { get; set; }
public string status { get; set; }
public List feeds { get; set; }
public string ssid_base64 { get; set; }
}
[Route("api/[controller]")]
[ApiController]
public class RestApiController : ControllerBase
{
[HttpPost]
[Route("recv")]
public string ReceiveData([FromBody] DeviceData data)
{
try
{
//Data is used for processing
return "SUCCESS";//Successfully processed a request
}
catch (Exception)
{
return "ERROR";//An error occurred while processing your request
}
}
}
}