private static string generatePatchForTurbine(PowerValues powerValues)
{
UpdateOperationsUtility uou = new UpdateOperationsUtility();
uou.AppendReplaceOp("/powerObserved", powerValues.powerObserved);
uou.AppendReplaceOp("/powerPM", powerValues.powerPM);
uou.AppendReplaceOp("/powerDM", powerValues.powerDM);
return(uou.Serialize());
}
public async Task Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
// After this is deployed, you need to turn the Managed Identity Status to "On",
// Grab Object Id of the function and assigned "Azure Digital Twins Owner (Preview)" role
// to this function identity in order for this function to be authorized on ADT APIs.
if (adtInstanceUrl == null)
{
log.LogError("Application setting \"ADT_SERVICE_URL\" not set");
}
try
{
//Authenticate with Digital Twins
ManagedIdentityCredential cred = new ManagedIdentityCredential("https://digitaltwins.azure.net");
DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl),
cred,
new DigitalTwinsClientOptions
{
Transport = new HttpClientTransport(httpClient)
});
if (eventGridEvent != null && eventGridEvent.Data != null)
{
log.LogInformation(eventGridEvent.Data.ToString());
JObject deviceMessage = (JObject)JsonConvert.DeserializeObject(eventGridEvent.Data.ToString());
byte[] body_byte = System.Convert.FromBase64String(deviceMessage["body"].ToString());
var body_value = System.Text.ASCIIEncoding.ASCII.GetString(body_byte);
var body_json = (JObject)JsonConvert.DeserializeObject(body_value);
//log.LogInformation($"Body {body_json}");
log.LogInformation(deviceMessage.ToString());
string deviceId = (string)deviceMessage["systemProperties"]["iothub-connection-device-id"];
var temperature = body_json["temperature_hts221"];
var humidity = body_json["humidity"];
log.LogInformation($"Device:{deviceId} Temperature is:{temperature} Humidity is:{humidity}");
//Update twin using device temperature
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp("/Temperature", temperature.Value <double>());
uou.AppendReplaceOp("/HumidityLevel", humidity.Value <double>());
await client.UpdateDigitalTwinAsync(deviceId, uou.Serialize());
}
}
catch (Exception e)
{
log.LogError($"Error in ingest function: {e.Message}");
}
}
public static string GetRelationshipUpdatePayload(string propertyName, bool propertyValue)
{
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp(propertyName, propertyValue);
return(RemoveNewLines(uou.Serialize()));
}
public static string GetWifiComponentUpdatePayload()
{
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp("/Network", "New Network");
return(RemoveNewLines(uou.Serialize()));
}
public async void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
// After this is deployed, you need to turn the Managed Identity Status to "On",
// Grab Object Id of the function and assigned "Azure Digital Twins Owner (Preview)" role
// to this function identity in order for this function to be authorized on ADT APIs.
//Authenticate with Digital Twins
var credentials = new DefaultAzureCredential();
DigitalTwinsClient client = new DigitalTwinsClient(
new Uri(adtServiceUrl), credentials, new DigitalTwinsClientOptions
{
Transport = new HttpClientTransport(httpClient)
});
log.LogInformation($"ADT service client connection created.");
if (eventGridEvent != null && eventGridEvent.Data != null)
{
log.LogInformation(eventGridEvent.Data.ToString());
// Reading deviceId and temperature for IoT Hub JSON
JObject deviceMessage = (JObject)JsonConvert.DeserializeObject(eventGridEvent.Data.ToString());
string deviceId = (string)deviceMessage["systemProperties"]["iothub-connection-device-id"];
var temperature = deviceMessage["body"]["Temperature"];
log.LogInformation($"Device:{deviceId} Temperature is:{temperature}");
//Update twin using device temperature
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp("/Temperature", temperature.Value <double>());
await client.UpdateDigitalTwinAsync(deviceId, uou.Serialize());
}
}
public static string GetRoomTwinUpdatePayload()
{
var uou = new UpdateOperationsUtility();
uou.AppendAddOp("/Humidity", 30);
uou.AppendReplaceOp("/Temperature", 70);
uou.AppendRemoveOp("/EmployeeId");
return(RemoveNewLines(uou.Serialize()));
}
private static string generatePatchForSensor(WTInfo info, TemperatureValues tempValues)
{
UpdateOperationsUtility uou = new UpdateOperationsUtility();
uou.AppendReplaceOp("/blade1PitchAngle", info.Blade1PitchPosition);
uou.AppendReplaceOp("/blade2PitchAngle", info.Blade2PitchPosition);
uou.AppendReplaceOp("/blade3PitchAngle", info.Blade3PitchPosition);
uou.AppendReplaceOp("/yawPosition", info.YawPosition);
uou.AppendReplaceOp("/windDirection", info.WindDir);
uou.AppendReplaceOp("/windSpeed", info.WindSpeed);
uou.AppendReplaceOp("/temperatureNacelle", tempValues.nacelle);
uou.AppendReplaceOp("/temperatureGenerator", tempValues.generator);
uou.AppendReplaceOp("/temperatureGearBox", tempValues.gearBox);
return(uou.Serialize());
}
public void UpdateOperationsUtility_BuildAdd()
{
// arrange
const string addOp = "add";
const string replaceOp = "replace";
const string removeOp = "remove";
const string addPath = "/addComponentPath123";
const string addValue = "value123";
const string replacePath = "/replaceComponentPath123";
const string replaceValue = "value456";
const string removePath = "/removeComponentPath123";
var dtUpdateUtility = new UpdateOperationsUtility();
dtUpdateUtility.AppendAddOp(addPath, addValue);
dtUpdateUtility.AppendReplaceOp(replacePath, replaceValue);
dtUpdateUtility.AppendRemoveOp(removePath);
// act
string actual = dtUpdateUtility.Serialize();
// assert
JsonDocument parsed = JsonDocument.Parse(actual);
parsed.RootElement.ValueKind.Should().Be(JsonValueKind.Array, "operations should be nested in an array");
parsed.RootElement.GetArrayLength().Should().Be(3, "three operations were included");
JsonElement addElement = parsed.RootElement[0];
addElement.GetProperty("op").GetString().Should().Be(addOp);
addElement.GetProperty("path").GetString().Should().Be(addPath);
addElement.GetProperty("value").GetString().Should().Be(addValue);
JsonElement replaceElement = parsed.RootElement[1];
replaceElement.GetProperty("op").GetString().Should().Be(replaceOp);
replaceElement.GetProperty("path").GetString().Should().Be(replacePath);
replaceElement.GetProperty("value").GetString().Should().Be(replaceValue);
JsonElement removeElement = parsed.RootElement[2];
removeElement.GetProperty("op").GetString().Should().Be(removeOp);
removeElement.GetProperty("path").GetString().Should().Be(removePath);
removeElement.TryGetProperty("value", out _).Should().BeFalse();
}
public static async Task UpdateTwinPropertyAsync(DigitalTwinsClient client, string twinId, string propertyPath, object value, ILogger log)
{
// If the twin does not exist, this will log an error
try
{
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp(propertyPath, value);
string patchPayload = uou.Serialize();
log.LogInformation($"UpdateTwinPropertyAsync sending {patchPayload}");
await client.UpdateDigitalTwinAsync(twinId, patchPayload);
}
catch (RequestFailedException exc)
{
log.LogInformation($"*** Error:{exc.Status}/{exc.Message}");
}
}
private async Task UpdateDigitalTwinProperty(DigitalTwinsClient client, string deviceId, JToken body, string propertyName)
{
var propertyToken = body[propertyName];
if (propertyToken != null)
{
if (Constants.Telemetries.Contains(propertyName.ToUpper()))
{
var data = new Dictionary <string, double>();
data.Add(propertyName, propertyToken.Value <double>());
await client.PublishTelemetryAsync(deviceId, JsonConvert.SerializeObject(data));
}
else
{
// Update twin using device property
var uou = new UpdateOperationsUtility();
uou.AppendReplaceOp($"/{propertyName}", propertyToken.Value <double>());
await client.UpdateDigitalTwinAsync(deviceId, uou.Serialize());
}
}
}
/// <summary>
/// Creates a digital twin with Component and upates Component
/// </summary>
public async Task RunSamplesAsync()
{
PrintHeader("COMPONENT SAMPLE");
// For the purpose of this example we will create temporary models using a random model Ids.
// We have to make sure these model Ids are unique within the DT instance.
string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, DigitalTwinsClient).ConfigureAwait(false);
string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, DigitalTwinsClient).ConfigureAwait(false);
string dtId1 = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, DigitalTwinsClient).ConfigureAwait(false);
string newComponentModelPayload = SamplesConstants.TemporaryComponentModelPayload
.Replace(SamplesConstants.ComponentId, componentModelId);
string newModelPayload = SamplesConstants.TemporaryModelWithComponentPayload
.Replace(SamplesConstants.ModelId, modelId)
.Replace(SamplesConstants.ComponentId, componentModelId);
// Then we create models
Response <IReadOnlyList <Models.ModelData> > createModelsResponse = await DigitalTwinsClient
.CreateModelsAsync(new[] { newComponentModelPayload, newModelPayload })
.ConfigureAwait(false);
Console.WriteLine($"Successfully created models Ids {componentModelId} and {modelId} with response {createModelsResponse.GetRawResponse().Status}.");
#region Snippet:DigitalTwinsSampleCreateBasicTwin
// Create digital twin with Component payload using the BasicDigitalTwin serialization helper
var basicDigitalTwin = new BasicDigitalTwin
{
Id = dtId1
};
basicDigitalTwin.Metadata.ModelId = modelId;
basicDigitalTwin.CustomProperties.Add("Prop1", "Value1");
basicDigitalTwin.CustomProperties.Add("Prop2", "Value2");
var componentMetadata = new ModelProperties();
componentMetadata.Metadata.ModelId = componentModelId;
componentMetadata.CustomProperties.Add("ComponentProp1", "ComponentValue1");
componentMetadata.CustomProperties.Add("ComponentProp2", "ComponentValue2");
basicDigitalTwin.CustomProperties.Add("Component1", componentMetadata);
string dt1Payload = JsonSerializer.Serialize(basicDigitalTwin);
Response <string> createDt1Response = await DigitalTwinsClient.CreateDigitalTwinAsync(dtId1, dt1Payload).ConfigureAwait(false);
Console.WriteLine($"Created digital twin {dtId1} with response {createDt1Response.GetRawResponse().Status}.");
#endregion Snippet:DigitalTwinsSampleCreateBasicTwin
#region Snippet:DigitalTwinsSampleCreateCustomTwin
string dtId2 = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, DigitalTwinsClient).ConfigureAwait(false);
var customDigitalTwin = new CustomDigitalTwin
{
Id = dtId2,
Metadata = new CustomDigitalTwinMetadata {
ModelId = modelId
},
Prop1 = "Prop1 val",
Prop2 = "Prop2 val",
Component1 = new Component1
{
Metadata = new Component1Metadata {
ModelId = componentModelId
},
ComponentProp1 = "Component prop1 val",
ComponentProp2 = "Component prop2 val",
}
};
string dt2Payload = JsonSerializer.Serialize(customDigitalTwin);
Response <string> createDt2Response = await DigitalTwinsClient.CreateDigitalTwinAsync(dtId2, dt2Payload).ConfigureAwait(false);
Console.WriteLine($"Created digital twin {dtId2} with response {createDt2Response.GetRawResponse().Status}.");
#endregion Snippet:DigitalTwinsSampleCreateCustomTwin
#region Snippet:DigitalTwinsSampleUpdateComponent
// Update Component1 by replacing the property ComponentProp1 value
var componentUpdateUtility = new UpdateOperationsUtility();
componentUpdateUtility.AppendReplaceOp("/ComponentProp1", "Some new value");
string updatePayload = componentUpdateUtility.Serialize();
Response <string> response = await DigitalTwinsClient.UpdateComponentAsync(dtId1, "Component1", updatePayload);
Console.WriteLine($"Updated component for digital twin {dtId1}. Update response status: {response.GetRawResponse().Status}");
#endregion Snippet:DigitalTwinsSampleUpdateComponent
// Get Component
#region Snippet:DigitalTwinsSampleGetComponent
response = await DigitalTwinsClient.GetComponentAsync(dtId1, SamplesConstants.ComponentPath).ConfigureAwait(false);
Console.WriteLine($"Get component for digital twin: \n{response.Value}. Get response status: {response.GetRawResponse().Status}");
#endregion Snippet:DigitalTwinsSampleGetComponent
// Clean up
try
{
await DigitalTwinsClient.DeleteDigitalTwinAsync(dtId1).ConfigureAwait(false);
await DigitalTwinsClient.DeleteDigitalTwinAsync(dtId2).ConfigureAwait(false);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete digital twin due to {ex}");
}
try
{
await DigitalTwinsClient.DeleteModelAsync(modelId).ConfigureAwait(false);
await DigitalTwinsClient.DeleteModelAsync(componentModelId).ConfigureAwait(false);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete models due to {ex}");
}
}
/// <summary>
/// Creates a digital twin with Component and upates Component
/// </summary>
public async Task RunSamplesAsync(DigitalTwinsClient client)
{
PrintHeader("COMPONENT SAMPLE");
// For the purpose of this example we will create temporary models using a random model Ids.
// We have to make sure these model Ids are unique within the DT instance.
string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, client);
string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, client);
string basicDtId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, client);
string newComponentModelPayload = SamplesConstants.TemporaryComponentModelPayload
.Replace(SamplesConstants.ComponentId, componentModelId);
string newModelPayload = SamplesConstants.TemporaryModelWithComponentPayload
.Replace(SamplesConstants.ModelId, modelId)
.Replace(SamplesConstants.ComponentId, componentModelId);
// Then we create models
Response <IReadOnlyList <Models.ModelData> > createModelsResponse = await client.CreateModelsAsync(
new[]
{
newComponentModelPayload,
newModelPayload
});
Console.WriteLine($"Created models with Ids {componentModelId} and {modelId}. Response status: {createModelsResponse.GetRawResponse().Status}.");
#region Snippet:DigitalTwinsSampleCreateBasicTwin
// Create digital twin with component payload using the BasicDigitalTwin serialization helper
var basicTwin = new BasicDigitalTwin
{
Id = basicDtId,
// model Id of digital twin
Metadata = { ModelId = modelId },
CustomProperties =
{
// digital twin properties
{ "Prop1", "Value1" },
{ "Prop2", 987 },
// component
{
"Component1",
new ModelProperties
{
// component properties
CustomProperties =
{
{ "ComponentProp1", "Component value 1" },
{ "ComponentProp2", 123 },
},
}
},
},
};
string basicDtPayload = JsonSerializer.Serialize(basicTwin);
Response <string> createBasicDtResponse = await client.CreateDigitalTwinAsync(basicDtId, basicDtPayload);
Console.WriteLine($"Created digital twin with Id {basicDtId}. Response status: {createBasicDtResponse.GetRawResponse().Status}.");
#endregion Snippet:DigitalTwinsSampleCreateBasicTwin
// You can also get a digital twin and deserialize it into a BasicDigitalTwin.
// It works well for basic stuff, but as you can see it gets more difficult when delving into
// more complex properties, like components.
#region Snippet:DigitalTwinsSampleGetBasicDigitalTwin
Response <string> getBasicDtResponse = await client.GetDigitalTwinAsync(basicDtId);
if (getBasicDtResponse.GetRawResponse().Status == (int)HttpStatusCode.OK)
{
BasicDigitalTwin basicDt = JsonSerializer.Deserialize <BasicDigitalTwin>(getBasicDtResponse.Value);
// Must cast Component1 as a JsonElement and get its raw text in order to deserialize it as a dictionary
string component1RawText = ((JsonElement)basicDt.CustomProperties["Component1"]).GetRawText();
IDictionary <string, object> component1 = JsonSerializer.Deserialize <IDictionary <string, object> >(component1RawText);
Console.WriteLine($"Retrieved and deserialized digital twin {basicDt.Id}:\n\t" +
$"ETag: {basicDt.ETag}\n\t" +
$"Prop1: {basicDt.CustomProperties["Prop1"]}\n\t" +
$"Prop2: {basicDt.CustomProperties["Prop2"]}\n\t" +
$"ComponentProp1: {component1["ComponentProp1"]}\n\t" +
$"ComponentProp2: {component1["ComponentProp2"]}");
}
#endregion Snippet:DigitalTwinsSampleGetBasicDigitalTwin
string customDtId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, client);
// Alternatively, you can create your own custom data types to serialize and deserialize your digital twins.
// By specifying your properties and types directly, it requires less code or knowledge of the type for
// interaction.
#region Snippet:DigitalTwinsSampleCreateCustomTwin
var customTwin = new CustomDigitalTwin
{
Id = customDtId,
Metadata = { ModelId = modelId },
Prop1 = "Prop1 val",
Prop2 = 987,
Component1 = new Component1
{
ComponentProp1 = "Component prop1 val",
ComponentProp2 = 123,
}
};
string dt2Payload = JsonSerializer.Serialize(customTwin);
Response <string> createCustomDtResponse = await client.CreateDigitalTwinAsync(customDtId, dt2Payload);
Console.WriteLine($"Created digital twin with Id {customDtId}. Response status: {createCustomDtResponse.GetRawResponse().Status}.");
#endregion Snippet:DigitalTwinsSampleCreateCustomTwin
// Getting and deserializing a digital twin into a custom data type is extremely easy.
// Custom types provide the best possible experience.
#region Snippet:DigitalTwinsSampleGetCustomDigitalTwin
Response <string> getCustomDtResponse = await client.GetDigitalTwinAsync(customDtId);
if (getCustomDtResponse.GetRawResponse().Status == (int)HttpStatusCode.OK)
{
CustomDigitalTwin customDt = JsonSerializer.Deserialize <CustomDigitalTwin>(getCustomDtResponse.Value);
Console.WriteLine($"Retrieved and deserialized digital twin {customDt.Id}:\n\t" +
$"ETag: {customDt.ETag}\n\t" +
$"Prop1: {customDt.Prop1}\n\t" +
$"Prop2: {customDt.Prop2}\n\t" +
$"ComponentProp1: {customDt.Component1.ComponentProp1}\n\t" +
$"ComponentProp2: {customDt.Component1.ComponentProp2}");
}
#endregion Snippet:DigitalTwinsSampleGetCustomDigitalTwin
#region Snippet:DigitalTwinsSampleUpdateComponent
// Update Component1 by replacing the property ComponentProp1 value
var componentUpdateUtility = new UpdateOperationsUtility();
componentUpdateUtility.AppendReplaceOp("/ComponentProp1", "Some new value");
string updatePayload = componentUpdateUtility.Serialize();
Response <string> response = await client.UpdateComponentAsync(basicDtId, "Component1", updatePayload);
Console.WriteLine($"Updated component for digital twin with Id {basicDtId}. Response status: {response.GetRawResponse().Status}");
#endregion Snippet:DigitalTwinsSampleUpdateComponent
// Get Component
#region Snippet:DigitalTwinsSampleGetComponent
response = await client.GetComponentAsync(basicDtId, SamplesConstants.ComponentPath);
Console.WriteLine($"Retrieved component for digital twin with Id {basicDtId}. Response status: {response.GetRawResponse().Status}");
#endregion Snippet:DigitalTwinsSampleGetComponent
// Clean up
try
{
await client.DeleteDigitalTwinAsync(basicDtId);
await client.DeleteDigitalTwinAsync(customDtId);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete digital twin due to {ex}");
}
try
{
await client.DeleteModelAsync(modelId);
await client.DeleteModelAsync(componentModelId);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete models due to {ex}");
}
}
/// <summary>
/// Creates a digital twin with Component and upates Component
/// </summary>
public async Task RunSamplesAsync()
{
PrintHeader("COMPONENT SAMPLE");
// For the purpose of this example we will create temporary models using a random model Ids.
// We have to make sure these model Ids are unique within the DT instance.
string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, DigitalTwinsClient).ConfigureAwait(false);
string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, DigitalTwinsClient).ConfigureAwait(false);
string twinId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, DigitalTwinsClient).ConfigureAwait(false);
string newComponentModelPayload = SamplesConstants.TemporaryComponentModelPayload
.Replace(SamplesConstants.ComponentId, componentModelId);
string newModelPayload = SamplesConstants.TemporaryModelPayload
.Replace(SamplesConstants.ModelId, modelId)
.Replace(SamplesConstants.ComponentId, componentModelId);
// Then we create models
await DigitalTwinsClient.CreateModelsAsync(new[] { newComponentModelPayload, newModelPayload }).ConfigureAwait(false);
Console.WriteLine($"Successfully created models with Ids: {componentModelId}, {modelId}");
// Create digital twin with Component payload
string twinPayload = SamplesConstants.TemporaryTwinPayload
.Replace(SamplesConstants.ModelId, modelId)
.Replace(SamplesConstants.ComponentId, componentModelId);
await DigitalTwinsClient.CreateDigitalTwinAsync(twinId, twinPayload).ConfigureAwait(false);
Console.WriteLine($"Created digital twin {twinId}.");
#region Snippet:DigitalTwinSampleUpdateComponent
// Update Component with replacing property value
string propertyPath = "/ComponentProp1";
string propValue = "New Value";
var componentUpdateUtility = new UpdateOperationsUtility();
componentUpdateUtility.AppendReplaceOp(propertyPath, propValue);
Response <string> response = await DigitalTwinsClient.UpdateComponentAsync(twinId, SamplesConstants.ComponentPath, componentUpdateUtility.Serialize());
#endregion Snippet:DigitalTwinSampleUpdateComponent
Console.WriteLine($"Updated component for digital twin {twinId}. Update response status: {response.GetRawResponse().Status}");
// Get Component
#region Snippet:DigitalTwinSampleGetComponent
response = await DigitalTwinsClient.GetComponentAsync(twinId, SamplesConstants.ComponentPath).ConfigureAwait(false);
#endregion Snippet:DigitalTwinSampleGetComponent
Console.WriteLine($"Get component for digital twin: \n{response.Value}. Get response status: {response.GetRawResponse().Status}");
// Now delete a Twin
await DigitalTwinsClient.DeleteDigitalTwinAsync(twinId).ConfigureAwait(false);
// Delete models
try
{
await DigitalTwinsClient.DeleteModelAsync(modelId).ConfigureAwait(false);
await DigitalTwinsClient.DeleteModelAsync(componentModelId).ConfigureAwait(false);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete models due to {ex}");
}
}
public async static void Run([EventGridTrigger] EventGridEvent ev, ILogger log)
{
if (adtInstanceUrl == null)
{
log.LogError("Application setting \"ADT_SERVICE_URL\" not set");
}
try
{
// Authenticate with Digital Twins
ManagedIdentityCredential cred = new ManagedIdentityCredential("https://digitaltwins.azure.net");
DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), cred, new DigitalTwinsClientOptions {
Transport = new HttpClientTransport(httpClient)
});
log.LogInformation("ADT service client connection created.");
if (ev != null && ev.Data != null)
{
// Extract JSON body from event
JObject deviceMessage = (JObject)JsonConvert.DeserializeObject(ev.Data.ToString());
byte[] data = System.Convert.FromBase64String((string)deviceMessage ["body"]);
JObject body = (JObject)JsonConvert.DeserializeObject(System.Text.ASCIIEncoding.ASCII.GetString(data));
// Extract device twin id from message and digital twin id from system properties
string deviceId = (string)deviceMessage ["systemProperties"]["iothub-connection-device-id"];
string twinId = (string)body ["twin_id"];
log.LogInformation($"Routing from device_id: {deviceId}");
log.LogInformation($"Routing to twin_id: {twinId}");
// Iterate set of readings and create change set for twin
JObject readings = (JObject)body ["readings"];
var uou = new UpdateOperationsUtility();
foreach (var reading in readings)
{
string type = (string)reading.Value ["type"];
string key = (string)reading.Key;
var value = reading.Value ["value"];
log.LogInformation($"key: {key} value: {value} type: {type}");
switch (type.ToLower())
{
case "bool":
uou.AppendReplaceOp($"/{key}", value.Value <bool>());
break;
case "int8":
uou.AppendReplaceOp($"/{key}", value.Value <SByte>());
break;
case "int16":
uou.AppendReplaceOp($"/{key}", value.Value <Int16>());
break;
case "int32":
uou.AppendReplaceOp($"/{key}", value.Value <Int32>());
break;
case "uint8":
uou.AppendReplaceOp($"/{key}", value.Value <Byte>());
break;
case "uint16":
uou.AppendReplaceOp($"/{key}", value.Value <UInt16>());
break;
case "float32":
uou.AppendReplaceOp($"/{key}", value.Value <float>());
break;
case "float64":
uou.AppendReplaceOp($"/{key}", value.Value <double>());
break;
default:
log.LogWarning($"{key} using {type} type isn't supported");
break;
}
}
// Update digital twin
string digitalTwinPatch = uou.Serialize();
log.LogInformation($"Updating twin: {twinId} with patch {digitalTwinPatch}");
await client.UpdateDigitalTwinAsync(twinId, digitalTwinPatch);
}
}
catch (Exception e)
{
log.LogError(e.Message);
}
}