09 / 02 / 2017 13: 35: 27 > Device: [python - test - device], Data: [{
   "diagnosis": "[0L, ['HeadPitch', 'HeadYaw', 'LAnklePitch', 'LAnkleRoll', 'LElbowRoll', 'LElbowYaw', 'LHipPitch', 'LHipRoll', 'LHipYawPitch', 'LKneePitch', 'LShoulderPitch', 'LShoulderRoll', 'LWristYaw', 'RAnklePitch', 'RAnkleRoll', 'RElbowRoll', 'RElbowYaw', 'RHipPitch', 'RHipRoll', 'RKneePitch', 'RShoulderPitch', 'RShoulderRoll', 'RWristYaw']]",
   "msg_type": "error",
   "datetime": "2017-02-09T13:35:28.925774"
}]
09 / 02 / 2017 13: 35: 36 > Device: [python - test - device], Data: [{
   "life_state": "disabled",
   "focused_activity": "",
   "msg_type": "state",
   "system_version": "2.1.4.13",
   "ip_address": "192.168.8.1",
   "battery_charging": false,
   "battery_charge": 88,
   "cpu": "25.7904",
   "wifi_name": "wifiname",
   "datetime": "2017-02-09T13:35:37.256762"
}]

09 / 02 / 2017 13: 35: 18 > Device: [python - test - device], Data: [{
   "life_state": "disabled",
   "focused_activity": "",
   "msg_type": "state",
   "system_version": "2.1.4.13",
   "ip_address": "192.168.8.1",
   "battery_charging": false,
   "battery_charge": 88,
   "cpu": "25.7645",
   "wifi_name": "wifiname",
   "datetime": "2017-02-09T13:35:19.369717"
}]
09 / 02 / 2017 13: 35: 22 > Device: [python - test - device], Data: [{
   "life_state": "disabled",
   "focused_activity": "",
   "msg_type": "state",
   "system_version": "2.1.4.13",
   "ip_address": "192.168.8.1",
   "battery_charging": false,
   "battery_charge": 88,
   "cpu": "25.7723",
   "wifi_name": "wifiname",
   "datetime": "2017-02-09T13:35:23.499632"
}]

09/02/2017 13:29:49 > Device: [tablet], Data: [{
   "question": "What can you never eat for breakfast?",
   "answer": "Dinner.",
   "msg_type": "qna",
   "score": 1.0,
   "datetime": "2017-02-09T13:29:48.541994+01:00"
}]
09/02/2017 13:29:49 > Device: [tablet], Data: [{
   "question": "How can you lift an elephant with one hand?",
   "answer": "It is not a problem, since you will never find an elephant with one hand.",
   "msg_type": "qna",
   "score": 1.0,
   "datetime": "2017-02-09T13:29:48.53919+01:00"
}]
09/02/2017 13:29:49 > Device: [tablet], Data: [{
   "question": "If it took eight men ten hours to build a wall, how long would it take four men to build it?",
   "answer": "No time at all it is already built.",
   "msg_type": "qna",
   "score": 1.0,
   "datetime": "2017-02-09T13:29:46.503404+01:00"
}]

Sent to Device ID: [python-test-device], Message:"rest", message Id: 752b2aae-299f-4289-bf95-6fcc3d660a80
Message Feedback status: "Success", Description: "Success", Original Message Id: 752b2aae-299f-4289-bf95-6fcc3d660a80

""" 
Module Name: d2cMsgSender.py 
Project: IoTHubRestSample 
Copyright (c) Microsoft Corporation. 
This source is subject to the Microsoft Public License. 
See http://www.microsoft.com/en-us/openness/licenses.aspx#MPL 
All other rights reserved. 
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 
"""
	
	import base64
	import hmac
	import hashlib
	import time
	import requests
	import urllib
	
	class D2CMsgSender:
	
	API_VERSION = '2016-02-03'
	TOKEN_VALID_SECS = 10
	TOKEN_FORMAT = 'SharedAccessSignature sig=%s&se=%s&sr=%s'
	
	def __init__(self, connectionString=None):
    	if connectionString != None:
        	iotHost, keyName, keyValue = [sub[sub.index('=') + 1:] for sub in connectionString.split(";")]
        	self.iotHost = iotHost
        	self.keyName = keyName
        	self.keyValue = keyValue
        	
	def _buildExpiryOn(self):
    	return '%d' % (time.time() + self.TOKEN_VALID_SECS)
	
	def _buildIoTHubSasToken(self, deviceId):
    	resourceUri = '%s/devices/%s' % (self.iotHost, deviceId)
    	targetUri = resourceUri.lower()
    	expiryTime = self._buildExpiryOn()
    	toSign = '%s\n%s' % (targetUri, expiryTime)
    	key = base64.b64decode(self.keyValue.encode('utf-8'))
    	signature = urllib.quote(
        	base64.b64encode(
            	hmac.HMAC(key, toSign.encode('utf-8'), hashlib.sha256).digest()
        	)
    	).replace('/', '%2F')
    	return self.TOKEN_FORMAT % (signature, expiryTime, targetUri)
	
	def sendD2CMsg(self, deviceId, message):
    	sasToken = self._buildIoTHubSasToken(deviceId)
    	global log
    	log.info("SAS TOKEN " + str(sasToken))
    	url = 'https://%s/devices/%s/messages/events?api-version=%s' % (self.iotHost, deviceId, self.API_VERSION)
    	r = requests.post(url, headers={'Authorization': sasToken}, data=message)
    	return r.text, r.status_code
    	
	def getD2CMsg(self, deviceId):
    	sasToken = self._buildIoTHubSasToken(deviceId)
    	url = 'https://%s/devices/%s/messages/devicebound?api-version=%s' % (self.iotHost, deviceId, self.API_VERSION)
    	r = requests.get(url, headers={'Authorization': sasToken})
    	#return r.text, r.status_code
    	return r
    	
	def completeD2CMsg(self, etag):
    	sasToken = self._buildIoTHubSasToken(deviceId)
    	url = 'https://%s/devices/%s/messages/devicebound/%s?api-version=%s' % (self.iotHost, deviceId, etag, self.API_VERSION)
    	global log
    	log.info(url)
    	r = requests.delete(url, headers={'Authorization': sasToken})
    	return r
    	
	def rejectD2CMsg(self, etag):
    	sasToken = self._buildIoTHubSasToken(deviceId)
    	url = 'https://%s/devices/%s/messages/devicebound/%s?reject&api-version=%s' % (self.iotHost, deviceId, etag, self.API_VERSION)
    	global log
    	log.info(url)
    	r = requests.delete(url, headers={'Authorization': sasToken})
    	return r
	d2cMsgSender = None
	connectionString = "HostName=xxxxxxx.azure-devices.net;DeviceId=python-test-device;SharedAccessKey=xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
	deviceId = 'python-test-device'
	log = None
	
	def init(logger):
	global d2cMsgSender
	global log
	d2cMsgSender = D2CMsgSender(connectionString)
	log = logger
	#print d2cMsgSender.getD2CMsg(deviceId)
	
	def send(message):
	return d2cMsgSender.sendD2CMsg(deviceId, message)
	
	def get():
	return d2cMsgSender.getD2CMsg(deviceId)
	
	def complete(etag):
	return d2cMsgSender.completeD2CMsg(etag)
	
	def reject(etag):
	return d2cMsgSender.rejectD2CMsg(etag)

using System;
	using System.Text;
	using System.Threading.Tasks;
	using Microsoft.Azure.Devices.Client;
	using IotTest;
	
	static class AzureIoTHub
	{
   	
		const string deviceConnectionString = "HostName=xxxxx.azure-devices.net;DeviceId=tablet;SharedAccessKey=xxxxxxxxxxxxxxxxxxxxxxxxx";
	    	
		public static async Task SendDeviceToCloudMessageAsync(IotPayload pl)
		{
			var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, TransportType.Http1);
			
			var str = Newtonsoft.Json.JsonConvert.SerializeObject(pl);
			var message = new Message(Encoding.ASCII.GetBytes(str));
			
			await deviceClient.SendEventAsync(message);
		}
	
	
	}
	public class IotPayload
	{
		public String question { get; set; }
		public String answer{ get; set; }
		public String msg_type { get; set; }
		public double score{ get; set; }
		public DateTime datetime { get; set; }
	}

SELECT
IoTHub.ConnectionDeviceId as device_id,
ip_address,
datetime,
life_state,
focused_activity,
system_version,
battery_charging,
battery_charge,
CAST(cpu as bigint) as cpu,
wifi_name
INTO
[RobotStatus]
FROM
[RobotIOTHub]
WHERE msg_type = 'state';
SELECT
IoTHub.ConnectionDeviceId as device_id,
diagnosis,
datetime
INTO
[RobotError]
FROM
[RobotIOTHub]
WHERE msg_type = 'error';
SELECT
IoTHub.ConnectionDeviceId as device_id,
question,
answer,
score,
datetime
INTO
[RobotQNA]
FROM
[RobotIOTHub]
WHERE msg_type = 'qna';

protected async Task<QnAMakerResult> PostQNAQueryAsync(string customerquery)
	{
		string responseString;
var query = customerquery; //User Query 		
var knowledgebaseId = "xxxxxxxxxxxxxx"; // Use knowledge base id created. 	var qnamakerSubscriptionKey = "xxxxxxxxxxxxxxxxxxxxxxxxxx"; //Use subscription key assigned to you. 																	
		Uri qnamakerUriBase = new Uri("https://westus.api.cognitive.microsoft.com/qnamaker/v1.0");
		var builder = new UriBuilder($"{qnamakerUriBase}/knowledgebases/{knowledgebaseId}/generateAnswer");
		//Add the question as part of the body 		
var postBody = $"{{\"question\": \"{query}\"}}";
		//Set the encoding to UTF8 		
var content = new StringContent(postBody, Encoding.UTF8, "application/json");		
		//Send the POST request 		
HttpClient client = new HttpClient();
		client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", qnamakerSubscriptionKey);
		HttpResponseMessage response = await client.PostAsync(builder.ToString(), content);
		if(response.IsSuccessStatusCode)
		{
			responseString = await response.Content.ReadAsStringAsync();
			return JsonConvert.DeserializeObject<QnAMakerResult>(responseString);
		}
		return null;
	}