public async Task DigitalTwins_CreateOrReplaceTwinFailsWhenIfNoneMatchStar()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// act
Func <Task> act = async() =>
{
// "ifNoneMatch = *" header should cause the server to throw 412 since an entity does match
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin, ETag.All).ConfigureAwait(false);
};
// assert
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.PreconditionFailed);
}
catch (Exception ex)
{
Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public async Task DigitalTwins_CreateOrReplaceTwinSucceedsWithNoIfNoneMatchHeader()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// Deliberately not passing in ifNoneMatch header, request should succeed because of that
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.PreconditionFailed)
{
throw new AssertionException("CreateOrReplaceDigitalTwin should not fail with PreconditionFailed when ifNoneMatch header wasn't set", ex);
}
catch (Exception ex)
{
Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public async Task Query_GetTwinAliasing()
{
DigitalTwinsClient client = GetClient();
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// Create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// Create a room twin, with property "IsOccupied": true
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync(roomTwinId, roomTwin).ConfigureAwait(false);
await WaitIfLiveAsync(TimeSpan.FromSeconds(10));
// Use aliasing in the query to test deserialization when each digital twin in the response will be wrapped by the alias name.
string queryString = $"SELECT D FROM DIGITALTWINS D";
// act
AsyncPageable <AliasedBasicDigitalTwin> asyncPageableResponse = client.QueryAsync <AliasedBasicDigitalTwin>(queryString);
await foreach (AliasedBasicDigitalTwin twin in asyncPageableResponse)
{
twin.Twin.Id.Should().NotBeNull();
}
}
catch (Exception ex)
{
Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public static async Task <string> FindOrCreateTwinAsync(string dtmi, string regId, ILogger log)
{
// Create Digital Twins client
var cred = new ManagedIdentityCredential(adtAppId);
var client = new DigitalTwinsClient(
new Uri(adtInstanceUrl),
cred,
new DigitalTwinsClientOptions
{
Transport = new HttpClientTransport(singletonHttpClientInstance)
});
// Find existing DigitalTwin with registration ID
try
{
// Get DigitalTwin with Id `regId`
BasicDigitalTwin dt = await GetDigitalTwin <BasicDigitalTwin>(regId).ConfigureAwait(false);
// Check to make sure it is of model type `dtmi`
if (StringComparer.OrdinalIgnoreCase.Equals(dtmi, dt.Metadata.ModelId))
{
return(dt.Id);
}
// Found DigitalTwin with `regId` but it is not of model type `dtmi`
log.LogInformation($"Found DigitalTwin {dt.Id} but it is not of model {dtmi}");
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.NotFound)
{
log.LogInformation($"Did not find DigitalTwin {dt.Id}");
}
// Either the DigitalTwin was not found, or we found it but it is of a different model type
// Create or replace it with what it needs to be, meaning if it was not found a brand new DigitalTwin will be created
// and if it was of a different model, it will replace that existing DigitalTwin
// If it was intended to only create the DigitalTwin if there is no matching DigitalTwin with the same Id,
// ETag.All could have been used as the ifNonMatch parameter to the CreateOrReplaceDigitalTwinAsync method call.
// Read more in the CreateOrReplaceDigitalTwinAsync documentation here:
// https://docs.microsoft.com/en-us/dotnet/api/azure.digitaltwins.core.digitaltwinsclient.createorreplacedigitaltwinasync?view=azure-dotnet
BasicDigitalTwin dt = await client.CreateOrReplaceDigitalTwinAsync(
regId,
new BasicDigitalTwin
{
Metadata = { ModelId = dtmi },
Contents =
{
{ "Temperature", 0.0 }
}
}
).ConfigureAwait(false);
log.LogInformation($"Digital Twin '{dtId}' created.");
return(dt.Id);
}
public async Task Query_ValidQuery_Success()
{
DigitalTwinsClient client = GetClient();
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// Create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
roomModel
}).ConfigureAwait(false);
// Create a room twin, with property "IsOccupied": true
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
string queryString = "SELECT * FROM digitaltwins where IsOccupied = true";
// act
AsyncPageable <string> asyncPageableResponse = client.QueryAsync(queryString);
// assert
await foreach (string response in asyncPageableResponse)
{
JsonElement jsonElement = JsonSerializer.Deserialize <JsonElement>(response);
JsonElement isOccupied = jsonElement.GetProperty("IsOccupied");
isOccupied.GetRawText().Should().Be("true");
}
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
private async Task CreateOrReplaceTwinAsync(BasicDigitalTwin twinData)
{
try
{
await _client.CreateOrReplaceDigitalTwinAsync(twinData.Id, twinData);
_logger.LogInformation($"Created twin: {twinData.Id}");
}
catch (RequestFailedException e)
{
_logger.LogError($"Create twin error: {e.Status}: {e.Message}");
}
}
public static async Task <List <BasicDigitalTwin> > CreateRoomTwinsForTestIdAsync(DigitalTwinsClient client, string testId, long countOftwins)
{
List <BasicDigitalTwin> createdTwins = new List <BasicDigitalTwin>();
string batchTwinPrefix = $"room-{testId}-{Guid.NewGuid().ToString().Substring(0, 8)}";
for (long i = 0; i < countOftwins; i++)
{
string twinId = $"{batchTwinPrefix}-{i}";
createdTwins.Add(await client.CreateOrReplaceDigitalTwinAsync(twinId, GetRoomTwin(testId)).ConfigureAwait(false));
}
return(createdTwins);
}
public async Task CreateTwinAsync(DigitalTwinsClient client)
{
// Initialize the twin properties
var myTwin = new CustomDigitalTwin
{
Metadata = { ModelId = "dtmi:example:Room;1" },
Temperature = 25.0,
Humidity = 50.0,
};
// Create the twin
const string twinId = "<twin-ID>";
Response <CustomDigitalTwin> response = await client.CreateOrReplaceDigitalTwinAsync(twinId, myTwin);
Console.WriteLine($"Temperature last updated on {response.Value.Metadata.Temperature.LastUpdatedOn}");
}
public static async Task <string> FindOrCreateTwinAsync(string dtmi, string regId, ILogger log)
{
// Create Digital Twins client
var cred = new ManagedIdentityCredential(adtAppId);
var client = new DigitalTwinsClient(
new Uri(adtInstanceUrl),
cred,
new DigitalTwinsClientOptions
{
Transport = new HttpClientTransport(singletonHttpClientInstance)
});
// Find existing twin with registration ID
string query = $"SELECT * FROM DigitalTwins T WHERE $dtId = '{regId}' AND IS_OF_MODEL('{dtmi}')";
AsyncPageable <BasicDigitalTwin> twins = client.QueryAsync(query);
string dtId;
await foreach (BasicDigitalTwin digitalTwin in twins)
{
dtId = digitalTwin.Id;
log.LogInformation($"Twin '{dtId}' with Registration ID '{regId}' found in DT");
break;
}
if (String.IsNullOrWhiteSpace(dtId))
{
// Not found, so create new twin
log.LogInformation($"Twin ID not found - setting DT ID to regID");
dtId = regId; // use the Registration ID as the DT ID
// Initialize the twin properties
var digitalTwin = new BasicDigitalTwin
{
Metadata = { ModelId = dtmi },
Contents =
{
{ "Temperature", 0.0 },
},
};
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(dtId, digitalTwin);
log.LogInformation($"Twin '{dtId}' created in DT");
}
return(dtId);
}
public static async Task <string> FindOrCreateTwin(string dtmi, string regId, ILogger log)
{
// Create Digital Twins client
var cred = new ManagedIdentityCredential(adtAppId);
var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), cred, new DigitalTwinsClientOptions {
Transport = new HttpClientTransport(httpClient)
});
// Find existing twin with registration ID
string dtId;
string query = $"SELECT * FROM DigitalTwins T WHERE $dtId = '{regId}' AND IS_OF_MODEL('{dtmi}')";
AsyncPageable <string> twins = client.QueryAsync(query);
await foreach (string twinJson in twins)
{
// Get DT ID from the Twin
JObject twin = (JObject)JsonConvert.DeserializeObject(twinJson);
dtId = (string)twin["$dtId"];
log.LogInformation($"Twin '{dtId}' with Registration ID '{regId}' found in DT");
return(dtId);
}
// Not found, so create new twin
log.LogInformation($"Twin ID not found, setting DT ID to regID");
dtId = regId; // use the Registration ID as the DT ID
// Define the model type for the twin to be created
Dictionary <string, object> meta = new Dictionary <string, object>()
{
{ "$model", dtmi }
};
// Initialize the twin properties
Dictionary <string, object> twinProps = new Dictionary <string, object>()
{
{ "$metadata", meta }
};
twinProps.Add("Temperature", 0.0);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(dtId, twinProps);
log.LogInformation($"Twin '{dtId}' created in DT");
return(dtId);
}
private async Task CreateModelsAndTwins(DigitalTwinsClient client, string wifiModelId, string roomWithWifiModelId, string wifiComponentName, string roomWithWifiTwinId)
{
// Generate the payload needed to create the WiFi component model.
string wifiModel = TestAssetsHelper.GetWifiModelPayload(wifiModelId);
// Generate the payload needed to create the room with WiFi model.
string roomWithWifiModel = TestAssetsHelper.GetRoomWithWifiModelPayload(roomWithWifiModelId, wifiModelId, wifiComponentName);
// Create the room and WiFi models.
await client.CreateModelsAsync(new List <string> {
roomWithWifiModel, wifiModel
}).ConfigureAwait(false);
// Generate the payload needed to create the room with WiFi twin.
BasicDigitalTwin roomWithWifiTwin = TestAssetsHelper.GetRoomWithWifiTwinPayload(roomWithWifiModelId, wifiComponentName);
// Create the room with WiFi component digital twin.
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomWithWifiTwinId, roomWithWifiTwin).ConfigureAwait(false);
}
public async Task DigitalTwinOperationsWithCustomObjectSerializer_Succeeds()
{
// arrange
var serializer = new TestObjectSerializer();
DigitalTwinsClientOptions options = new DigitalTwinsClientOptions
{
Serializer = serializer
};
DigitalTwinsClient client = GetClient(options);
serializer.WasDeserializeCalled.Should().BeFalse();
serializer.WasSerializeCalled.Should().BeFalse();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync(roomTwinId, roomTwin).ConfigureAwait(false);
roomTwin = await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false);
// assert
roomTwin.Should().NotBeNull();
serializer.WasDeserializeCalled.Should().BeTrue();
serializer.WasSerializeCalled.Should().BeTrue();
}
public async Task Execute(AddThermostat command, CancellationToken cancellationToken)
{
var thermostat = new Thermostat
{
Id = command.Id,
Name = command.Name
};
try
{
await _twins.CreateOrReplaceDigitalTwinAsync(command.Id, thermostat, cancellationToken : cancellationToken);
}
catch (RequestFailedException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Creates all twins specified in the \DTDL\DigitalTwins directory
/// </summary>
public async Task CreateAllTwinsAsync()
{
PrintHeader("CREATE DIGITAL TWINS");
Dictionary <string, string> twins = FileHelper.LoadAllFilesInPath(s_twinsPath);
// Call APIs to create the twins.
foreach (KeyValuePair <string, string> twin in twins)
{
try
{
BasicDigitalTwin basicDigitalTwin = JsonSerializer.Deserialize <BasicDigitalTwin>(twin.Value);
Response <BasicDigitalTwin> response = await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twin.Key, basicDigitalTwin);
Console.WriteLine($"Created digital twin '{twin.Key}'.");
Console.WriteLine($"\tBody: {JsonSerializer.Serialize(response?.Value)}");
}
catch (Exception ex)
{
FatalError($"Could not create digital twin '{twin.Key}' due to {ex}");
}
}
}
public async Task SetPropertyValuesAsync(DigitalTwinsClient client)
{
// ------------------ SET TAG PROPERTY VALUES: CSHARP ---------------------
// <TagPropertiesCsharp>
IDictionary <string, bool> tags = new Dictionary <string, bool>
{
{ "oceanview", true },
{ "VIP", true }
};
var twin = new BasicDigitalTwin
{
Metadata = { ModelId = "dtmi:example:Room;1" },
Contents =
{
{ "Temperature", 75 },
{ "tags", tags },
},
};
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>("myTwinID", twin);
// </TagPropertiesCsharp>
}
public async Task Component_Lifecycle()
{
// arrange
DigitalTwinsClient client = GetClient();
string wifiModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WifiModelIdPrefix).ConfigureAwait(false);
string roomWithWifiModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomWithWifiModelIdPrefix).ConfigureAwait(false);
string roomWithWifiTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomWithWifiTwinIdPrefix).ConfigureAwait(false);
string wifiComponentName = "wifiAccessPoint";
try
{
// CREATE
// create roomWithWifi model
string wifiModel = TestAssetsHelper.GetWifiModelPayload(wifiModelId);
// create wifi model
string roomWithWifiModel = TestAssetsHelper.GetRoomWithWifiModelPayload(roomWithWifiModelId, wifiModelId, wifiComponentName);
await client.CreateModelsAsync(new List <string> {
roomWithWifiModel, wifiModel
}).ConfigureAwait(false);
// create room digital twin
BasicDigitalTwin roomWithWifiTwin = TestAssetsHelper.GetRoomWithWifiTwinPayload(roomWithWifiModelId, wifiComponentName);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomWithWifiTwinId, roomWithWifiTwin);
// Get the component
Response <object> getComponentResponse = await client
.GetComponentAsync <object>(
roomWithWifiTwinId,
wifiComponentName)
.ConfigureAwait(false);
// The response to the GET request should be 200 (OK)
getComponentResponse.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK);
// Patch component
JsonPatchDocument componentUpdatePatchDocument = new JsonPatchDocument();
componentUpdatePatchDocument.AppendReplace("/Network", "New Network");
Response updateComponentResponse = await client
.UpdateComponentAsync(
roomWithWifiTwinId,
wifiComponentName,
componentUpdatePatchDocument)
.ConfigureAwait(false);
// The response to the Patch request should be 204 (No content)
updateComponentResponse.Status.Should().Be((int)HttpStatusCode.NoContent);
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomWithWifiTwinId))
{
await client.DeleteDigitalTwinAsync(roomWithWifiTwinId).ConfigureAwait(false);
}
if (!string.IsNullOrWhiteSpace(roomWithWifiModelId))
{
await client.DeleteModelAsync(roomWithWifiModelId).ConfigureAwait(false);
}
if (!string.IsNullOrWhiteSpace(wifiModelId))
{
await client.DeleteModelAsync(wifiModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public async Task Query_ValidQuery_Success()
{
DigitalTwinsClient client = GetClient();
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// Create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// Create a room twin, with property "IsOccupied": true
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync(roomTwinId, roomTwin).ConfigureAwait(false);
// Construct a query string to find the twins with the EXACT model id and provided version. If EXACT is not specified, the query
// call will get all twins with the same model id but that implement any version higher than the provided version
string queryString = $"SELECT * FROM digitaltwins WHERE IS_OF_MODEL('{roomModelId}', EXACT) AND IsOccupied = true";
// act
AsyncPageable <BasicDigitalTwin> asyncPageableResponse = client.QueryAsync <BasicDigitalTwin>(queryString);
// assert
// It takes a few seconds for the service to be able to fetch digital twins through queries after being created. Hence, adding the retry logic
var digitalTwinFound = false;
await TestRetryHelper.RetryAsync <AsyncPageable <BasicDigitalTwin> >(async() =>
{
await foreach (BasicDigitalTwin response in asyncPageableResponse)
{
digitalTwinFound = true;
bool isOccupied = ((JsonElement)response.Contents["IsOccupied"]).GetBoolean();
isOccupied.Should().BeTrue();
break;
}
if (!digitalTwinFound)
{
throw new Exception($"Digital twin based on model Id {roomModelId} not found");
}
return(null);
}, s_retryCount, s_retryDelay);
digitalTwinFound.Should().BeTrue();
}
catch (Exception ex)
{
Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public async Task Query_PaginationWorks()
{
DigitalTwinsClient client = GetClient();
int pageSize = 5;
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
TimeSpan QueryWaitTimeout = TimeSpan.FromMinutes(1); // Wait at most one minute for the created twins to become queryable
try
{
// Create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await CreateAndListModelsAsync(client, new List <string> {
roomModel
}).ConfigureAwait(false);
// Create a room twin, with property "IsOccupied": true
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
for (int i = 0; i < pageSize * 2; i++)
{
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
}
string queryString = "SELECT * FROM digitaltwins";
// act
CancellationTokenSource queryTimeoutCancellationToken = new CancellationTokenSource(QueryWaitTimeout);
bool queryHasExpectedCount = false;
while (!queryHasExpectedCount)
{
if (queryTimeoutCancellationToken.IsCancellationRequested)
{
throw new AssertionException($"Timed out waiting for at least {pageSize + 1} twins to be queryable");
}
AsyncPageable <BasicDigitalTwin> asyncPageableResponse = client.QueryAsync <BasicDigitalTwin>(queryString, queryTimeoutCancellationToken.Token);
int count = 0;
await foreach (Page <BasicDigitalTwin> queriedTwinPage in asyncPageableResponse.AsPages(pageSizeHint: pageSize))
{
count += queriedTwinPage.Values.Count;
}
// Once at least (page + 1) twins are query-able, then page size control can be tested.
queryHasExpectedCount = count >= pageSize + 1;
}
// assert
// Test that page size hint works, and that all returned pages either have the page size hint amount of
// elements, or have no continuation token (signaling that it is the last page)
int pageCount = 0;
await foreach (Page <BasicDigitalTwin> page in client.QueryAsync <BasicDigitalTwin>(queryString).AsPages(pageSizeHint: pageSize))
{
pageCount++;
if (page.ContinuationToken != null)
{
page.Values.Count.Should().Be(pageSize, "Unexpected page size for a non-terminal page");
}
}
pageCount.Should().BeGreaterThan(1, "Expected more than one page of query results");
}
catch (Exception ex)
{
Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
string adtInstanceUrl = "<youradturl>";
var credential = new DefaultAzureCredential();
DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential);
Console.WriteLine($"Service client created – ready to go");
// uploading data
Console.WriteLine();
Console.WriteLine($"Upload a model");
var typeList = new List <string>();
string dtdl = File.ReadAllText("new.json");
typeList.Add(dtdl);
// Upload the model to the service
try
{
await client.CreateModelsAsync(typeList);
}
catch (RequestFailedException rex)
{
Console.WriteLine($"Load model: {rex.Status}:{rex.Message}");
}
// now lets add more models based on the one just uploaded
// Initialize twin data
BasicDigitalTwin twinData = new BasicDigitalTwin();
twinData.Metadata.ModelId = "dtmi:example:SampleModel;1";
twinData.Contents.Add("data", $"Hello World!");
string prefix = "sampleTwin-";
for (int i = 0; i < 3; i++)
{
try
{
twinData.Id = $"{prefix}{i}";
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twinData.Id, twinData);
Console.WriteLine($"Created twin: {prefix}{i}");
}
catch (RequestFailedException rex)
{
Console.WriteLine($"Create twin error: {rex.Status}:{rex.Message}");
}
}
// Connect the twins with relationships
await CreateRelationship(client, "sampleTwin-0", "sampleTwin-1");
await CreateRelationship(client, "sampleTwin-0", "sampleTwin-2");
//List the relationships
await ListRelationships(client, "sampleTwin-0");
// Run a query for all twins
string query = "SELECT * FROM digitaltwins";
AsyncPageable <BasicDigitalTwin> result = client.QueryAsync <BasicDigitalTwin>(query);
Console.WriteLine("---------------");
await foreach (BasicDigitalTwin twin in result)
{
Console.WriteLine(JsonSerializer.Serialize(twin));
Console.WriteLine("---------------");
}
}
public static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
// Create the Azure Digital Twins client for API calls
string adtInstanceUrl = "https://<your-instance-hostname>";
var credentials = new DefaultAzureCredential();
var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credentials);
Console.WriteLine($"Service client created – ready to go");
// Upload models
Console.WriteLine($"Upload a model");
string dtdl = File.ReadAllText("<path-to>/Room.json");
var models = new List <string> {
dtdl
};
// Upload the model to the service
await client.CreateModelsAsync(models);
// Create new digital twin
// <CreateTwin_withHelper>
string twinId = "myTwinID";
var initData = new BasicDigitalTwin
{
Id = twinId,
Metadata = { ModelId = "dtmi:example:Room;1" },
// Initialize properties
Contents =
{
{ "Temperature", 25.0 },
{ "Humidity", 50.0 },
},
};
// <CreateTwinCall>
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twinId, initData);
// </CreateTwinCall>
// </CreateTwin_withHelper>
Console.WriteLine("Twin created successfully");
//Print twin
Console.WriteLine("--- Printing twin details:");
twin = await FetchAndPrintTwinAsync(twinId, client);
Console.WriteLine("--------");
//Update twin data
var updateTwinData = new JsonPatchDocument();
updateTwinData.AppendAdd("/Temperature", 25.0);
// <UpdateTwinCall>
await client.UpdateDigitalTwinAsync(twin_ID, updateTwinData);
// </UpdateTwinCall>
Console.WriteLine("Twin properties updated");
Console.WriteLine();
//Print twin again
Console.WriteLine("--- Printing twin details (after update):");
FetchAndPrintTwin(twin_ID, client);
Console.WriteLine("--------");
Console.WriteLine();
//Delete twin
await DeleteTwin(client, twin_ID);
}
public async Task DigitalTwins_Lifecycle()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// get twin
await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false);
// update twin
JsonPatchDocument updateTwinPatchDocument = new JsonPatchDocument();
updateTwinPatchDocument.AppendAdd("/Humidity", 30);
updateTwinPatchDocument.AppendReplace("/Temperature", 70);
updateTwinPatchDocument.AppendRemove("/EmployeeId");
var requestOptions = new UpdateDigitalTwinOptions
{
IfMatch = "*"
};
await client.UpdateDigitalTwinAsync(roomTwinId, updateTwinPatchDocument, requestOptions).ConfigureAwait(false);
// delete a twin
await client.DeleteDigitalTwinAsync(roomTwinId).ConfigureAwait(false);
// assert
Func <Task> act = async() =>
{
await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.NotFound);
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
// Create the Azure Digital Twins client for API calls
DigitalTwinsClient client = createDtClient();
Console.WriteLine($"Service client created – ready to go");
Console.WriteLine();
// Upload models
Console.WriteLine($"Upload models");
Console.WriteLine();
string dtdl = File.ReadAllText("<path-to>/Room.json");
string dtdl1 = File.ReadAllText("<path-to>/Floor.json");
var models = new List <string>
{
dtdl,
dtdl1,
};
// Upload the models to the service
await client.CreateModelsAsync(models);
// Create new (Floor) digital twin
var floorTwin = new BasicDigitalTwin();
string srcId = "myFloorID";
floorTwin.Metadata.ModelId = "dtmi:example:Floor;1";
// Floor twins have no properties, so nothing to initialize
// Create the twin
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(srcId, floorTwin);
Console.WriteLine("Twin created successfully");
// Create second (Room) digital twin
var roomTwin = new BasicDigitalTwin();
string targetId = "myRoomID";
roomTwin.Metadata.ModelId = "dtmi:example:Room;1";
// Initialize properties
roomTwin.Contents.Add("Temperature", 35.0);
roomTwin.Contents.Add("Humidity", 55.0);
// Create the twin
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(targetId, roomTwin);
// Create relationship between them
var properties = new Dictionary <string, object>
{
{ "ownershipUser", "ownershipUser original value" },
};
// <UseCreateRelationship>
await CustomMethod_CreateRelationshipAsync(client, srcId, targetId, "contains", properties);
// </UseCreateRelationship>
Console.WriteLine();
// Update relationship's Name property
// <UseUpdateRelationship>
var updatePropertyPatch = new JsonPatchDocument();
updatePropertyPatch.AppendAdd("/ownershipUser", "ownershipUser NEW value");
await CustomMethod_UpdateRelationshipAsync(client, srcId, $"{srcId}-contains->{targetId}", updatePropertyPatch);
// </UseUpdateRelationship>
Console.WriteLine();
//Print twins and their relationships
Console.WriteLine("--- Printing details:");
Console.WriteLine($"Outgoing relationships from source twin, {srcId}:");
// <UseFetchAndPrint>
await CustomMethod_FetchAndPrintTwinAsync(srcId, client);
// </UseFetchAndPrint>
Console.WriteLine();
Console.WriteLine($"Incoming relationships to target twin, {targetId}:");
await CustomMethod_FetchAndPrintTwinAsync(targetId, client);
Console.WriteLine("--------");
Console.WriteLine();
// Delete the relationship
// <UseDeleteRelationship>
await CustomMethod_DeleteRelationshipAsync(client, srcId, $"{srcId}-contains->{targetId}");
// </UseDeleteRelationship>
Console.WriteLine();
// Print twins and their relationships again
Console.WriteLine("--- Printing details (after relationship deletion):");
Console.WriteLine("Outgoing relationships from source twin:");
await CustomMethod_FetchAndPrintTwinAsync(srcId, client);
Console.WriteLine();
Console.WriteLine("Incoming relationships to target twin:");
await CustomMethod_FetchAndPrintTwinAsync(targetId, client);
Console.WriteLine("--------");
Console.WriteLine();
}
public async Task DigitalTwins_DeleteTwinSucceedsIfMatchProvidesCorrectEtag()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// update twin
JsonPatchDocument updateTwinPatchDocument = new JsonPatchDocument();
updateTwinPatchDocument.AppendAdd("/Humidity", 30);
updateTwinPatchDocument.AppendReplace("/Temperature", 70);
updateTwinPatchDocument.AppendRemove("/EmployeeId");
await client.UpdateDigitalTwinAsync(roomTwinId, updateTwinPatchDocument, ETag.All).ConfigureAwait(false);
// get twin
ETag?correctETag = (await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false)).Value.ETag;
Assert.IsNotNull(correctETag);
try
{
// since the ETag is not out of date, this call should not throw a 412
await client.DeleteDigitalTwinAsync(roomTwinId, correctETag).ConfigureAwait(false);
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.PreconditionFailed)
{
throw new AssertionException("UpdateRelationship should not have thrown PreconditionFailed because the ETag was up to date", ex);
}
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
/// <summary>
/// Create a temporary component model, twin model and digital twin instance.
/// Publish a telemetry message and a component telemetry message to the digital twin instance.
/// </summary>
public async Task RunSamplesAsync(DigitalTwinsClient client)
{
PrintHeader("PUBLISH TELEMETRY MESSAGE SAMPLE");
// For the purpose of this example we will create temporary models using a random model Ids.
// We will also create temporary twin instances to publish the telemetry to.
string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, client);
string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, client);
string twinId = 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 the models.
await client
.CreateModelsAsync(new[] { newComponentModelPayload, newModelPayload });
// Get the models we just created
AsyncPageable <DigitalTwinsModelData> models = client.GetModelsAsync();
await foreach (DigitalTwinsModelData model in models)
{
Console.WriteLine($"Successfully created model '{model.Id}'");
}
// Create digital twin with Component payload.
string twinPayload = SamplesConstants.TemporaryTwinPayload
.Replace(SamplesConstants.ModelId, modelId);
BasicDigitalTwin basicDigitalTwin = JsonSerializer.Deserialize <BasicDigitalTwin>(twinPayload);
Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twinId, basicDigitalTwin);
Console.WriteLine($"Created digital twin '{createDigitalTwinResponse.Value.Id}'.");
try
{
#region Snippet:DigitalTwinsSamplePublishTelemetry
// construct your json telemetry payload by hand.
await client.PublishTelemetryAsync(twinId, Guid.NewGuid().ToString(), "{\"Telemetry1\": 5}");
Console.WriteLine($"Published telemetry message to twin '{twinId}'.");
#endregion Snippet:DigitalTwinsSamplePublishTelemetry
#region Snippet:DigitalTwinsSamplePublishComponentTelemetry
// construct your json telemetry payload by serializing a dictionary.
var telemetryPayload = new Dictionary <string, int>
{
{ "ComponentTelemetry1", 9 }
};
await client.PublishComponentTelemetryAsync(
twinId,
"Component1",
Guid.NewGuid().ToString(),
JsonSerializer.Serialize(telemetryPayload));
Console.WriteLine($"Published component telemetry message to twin '{twinId}'.");
#endregion Snippet:DigitalTwinsSamplePublishComponentTelemetry
}
catch (Exception ex)
{
FatalError($"Failed to publish a telemetry message due to: {ex.Message}");
}
try
{
// Delete the twin.
await client.DeleteDigitalTwinAsync(twinId);
// Delete the models.
await client.DeleteModelAsync(modelId);
await client.DeleteModelAsync(componentModelId);
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.NotFound)
{
// Digital twin or models do not exist.
}
catch (RequestFailedException ex)
{
FatalError($"Failed to delete due to: {ex.Message}");
}
}
/// <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
await client.CreateModelsAsync(
new[]
{
newComponentModelPayload,
newModelPayload
});
Console.WriteLine($"Created models {componentModelId} and {modelId}.");
#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 },
Contents =
{
// digital twin properties
{ "Prop1", "Value1" },
{ "Prop2", 987 },
// component
{
"Component1",
new BasicDigitalTwinComponent
{
// component properties
Contents =
{
{ "ComponentProp1", "Component value 1" },
{ "ComponentProp2", 123 },
},
}
},
},
};
Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync(basicDtId, basicTwin);
Console.WriteLine($"Created digital twin '{createDigitalTwinResponse.Value.Id}'.");
#endregion Snippet:DigitalTwinsSampleCreateBasicTwin
// You can also get a digital twin as a BasicDigitalTwin type.
// 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 <BasicDigitalTwin> getBasicDtResponse = await client.GetDigitalTwinAsync <BasicDigitalTwin>(basicDtId);
if (getBasicDtResponse.GetRawResponse().Status == (int)HttpStatusCode.OK)
{
BasicDigitalTwin basicDt = 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.Contents["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.Contents["Prop1"]}\n\t" +
$"Prop2: {basicDt.Contents["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 MyCustomComponent
{
ComponentProp1 = "Component prop1 val",
ComponentProp2 = 123,
},
};
Response <CustomDigitalTwin> createCustomDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync(customDtId, customTwin);
Console.WriteLine($"Created digital twin '{createCustomDigitalTwinResponse.Value.Id}'.");
#endregion Snippet:DigitalTwinsSampleCreateCustomTwin
// Getting a digital twin as a custom data type is extremely easy.
// Custom types provide the best possible experience.
#region Snippet:DigitalTwinsSampleGetCustomDigitalTwin
Response <CustomDigitalTwin> getCustomDtResponse = await client.GetDigitalTwinAsync <CustomDigitalTwin>(customDtId);
CustomDigitalTwin customDt = 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,
// using an optional utility to build the payload.
var componentJsonPatchDocument = new JsonPatchDocument();
componentJsonPatchDocument.AppendReplace("/ComponentProp1", "Some new value");
await client.UpdateComponentAsync(basicDtId, "Component1", componentJsonPatchDocument);
Console.WriteLine($"Updated component for digital twin '{basicDtId}'.");
#endregion Snippet:DigitalTwinsSampleUpdateComponent
// Get Component
#region Snippet:DigitalTwinsSampleGetComponent
await client.GetComponentAsync <MyCustomComponent>(basicDtId, SamplesConstants.ComponentName);
Console.WriteLine($"Retrieved component for digital twin '{basicDtId}'.");
#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}");
}
}
public async Task Component_UpdateComponentSucceedsWhenIfMatchHeaderIsCorrect()
{
// arrange
DigitalTwinsClient client = GetClient();
string wifiModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WifiModelIdPrefix).ConfigureAwait(false);
string roomWithWifiModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomWithWifiModelIdPrefix).ConfigureAwait(false);
string roomWithWifiTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomWithWifiTwinIdPrefix).ConfigureAwait(false);
string wifiComponentName = "wifiAccessPoint";
try
{
// CREATE
// create roomWithWifi model
string wifiModel = TestAssetsHelper.GetWifiModelPayload(wifiModelId);
// create wifi model
string roomWithWifiModel = TestAssetsHelper.GetRoomWithWifiModelPayload(roomWithWifiModelId, wifiModelId, wifiComponentName);
await client.CreateModelsAsync(new List <string> {
roomWithWifiModel, wifiModel
}).ConfigureAwait(false);
// create room digital twin
BasicDigitalTwin roomWithWifiTwin = TestAssetsHelper.GetRoomWithWifiTwinPayload(roomWithWifiModelId, wifiComponentName);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomWithWifiTwinId, roomWithWifiTwin);
// Get the component
Response <object> getComponentResponse = await client
.GetComponentAsync <object>(
roomWithWifiTwinId,
wifiComponentName)
.ConfigureAwait(false);
// Patch component
JsonPatchDocument componentUpdatePatchDocument = new JsonPatchDocument();
componentUpdatePatchDocument.AppendReplace("/Network", "New Network");
Response updateComponentResponse = await client
.UpdateComponentAsync(
roomWithWifiTwinId,
wifiComponentName,
componentUpdatePatchDocument)
.ConfigureAwait(false);
// Get the latest ETag
ETag?etagBeforeUpdate = (await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomWithWifiTwinId)).Value.ETag;
Assert.IsNotNull(etagBeforeUpdate);
// Patch component again, but with the now out of date ETag
JsonPatchDocument secondComponentUpdatePatchDocument = new JsonPatchDocument();
componentUpdatePatchDocument.AppendReplace("/Network", "Even newer Network");
try
{
await client
.UpdateComponentAsync(
roomWithWifiTwinId,
wifiComponentName,
secondComponentUpdatePatchDocument,
etagBeforeUpdate)
.ConfigureAwait(false);
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.PreconditionFailed)
{
throw new AssertionException("UpdateComponent should not have thrown PreconditionFailed because the ETag was up to date", ex);
}
}
finally
{
// clean up
try
{
if (!string.IsNullOrWhiteSpace(roomWithWifiTwinId))
{
await client.DeleteDigitalTwinAsync(roomWithWifiTwinId).ConfigureAwait(false);
}
if (!string.IsNullOrWhiteSpace(roomWithWifiModelId))
{
await client.DeleteModelAsync(roomWithWifiModelId).ConfigureAwait(false);
}
if (!string.IsNullOrWhiteSpace(wifiModelId))
{
await client.DeleteModelAsync(wifiModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
static async Task Main(string[] args)
{
var relationshipRecordList = new List <BasicRelationship>();
var twinList = new List <BasicDigitalTwin>();
List <List <string> > data = ReadData();
DigitalTwinsClient client = CreateDtClient();
// Interpret the CSV file data, by each row
foreach (List <string> row in data)
{
string modelID = row.Count > 0 ? row[0].Trim() : null;
string srcID = row.Count > 1 ? row[1].Trim() : null;
string relName = row.Count > 2 ? row[2].Trim() : null;
string targetID = row.Count > 3 ? row[3].Trim() : null;
string initProperties = row.Count > 4 ? row[4].Trim() : null;
Console.WriteLine($"ModelID: {modelID}, TwinID: {srcID}, RelName: {relName}, TargetID: {targetID}, InitData: {initProperties}");
var props = new Dictionary <string, object>();
// Parse properties into dictionary (left out for compactness)
// ...
// Null check for source and target IDs
if (!string.IsNullOrWhiteSpace(srcID) && !string.IsNullOrWhiteSpace(targetID) && !string.IsNullOrWhiteSpace(relName))
{
relationshipRecordList.Add(
new BasicRelationship
{
SourceId = srcID,
TargetId = targetID,
Name = relName,
});
}
if (!string.IsNullOrWhiteSpace(srcID) && !string.IsNullOrWhiteSpace(modelID))
{
twinList.Add(
new BasicDigitalTwin
{
Id = srcID,
Metadata = { ModelId = modelID },
Contents = props,
});
}
}
// Create digital twins
foreach (BasicDigitalTwin twin in twinList)
{
try
{
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twin.Id, twin);
Console.WriteLine("Twin is created");
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Error {ex.Status}: {ex.Message}");
}
}
// Create relationships between the twins
foreach(BasicRelationship rec in relationshipRecordList)
{
string relId = $"{rec.SourceId}-{rec.Name}->{rec.TargetId}";
try
{
await client.CreateOrReplaceRelationshipAsync <BasicRelationship>(rec.SourceId, relId, rec);
Console.WriteLine($"Relationship {relId} is created");
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Error creating relationship {relId}. {ex.Status}: {ex.Message}");
}
}
}
public async Task DigitalTwins_PatchTwinFailsIfInvalidETagProvided()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// get twin
ETag?etagBeforeUpdate = (await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false)).Value.ETag;
Assert.IsNotNull(etagBeforeUpdate);
// update twin once to make the previous etag fall out of date
JsonPatchDocument updateTwinPatchDocument = new JsonPatchDocument();
updateTwinPatchDocument.AppendAdd("/Humidity", 30);
updateTwinPatchDocument.AppendReplace("/Temperature", 70);
updateTwinPatchDocument.AppendRemove("/EmployeeId");
await client.UpdateDigitalTwinAsync(roomTwinId, updateTwinPatchDocument, ETag.All).ConfigureAwait(false);
// update twin again, but with an out of date etag, which should cause a 412 from service
JsonPatchDocument secondUpdateTwinPatchDocument = new JsonPatchDocument();
secondUpdateTwinPatchDocument.AppendReplace("/Humidity", 80);
Func <Task> act = async() =>
{
await client.UpdateDigitalTwinAsync(roomTwinId, secondUpdateTwinPatchDocument, etagBeforeUpdate).ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.PreconditionFailed);
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
/// <summary>
/// Creates two digital twins, and connect them with relationships.
/// </summary>
public async Task RunSamplesAsync(DigitalTwinsClient client)
{
// For the purpose of keeping code snippets readable to the user, hardcoded string literals are used in place of assigned variables, eg Ids.
// Despite not being a good code practice, this prevents code snippets from being out of context for the user when making API calls that accept Ids as parameters.
PrintHeader("RELATIONSHIP SAMPLE");
string sampleBuildingModelId = "dtmi:com:samples:SampleBuilding;1";
string sampleFloorModelId = "dtmi:com:samples:SampleFloor;1";
await ModelLifecycleSamples.TryDeleteModelAsync(client, sampleBuildingModelId);
await ModelLifecycleSamples.TryDeleteModelAsync(client, sampleFloorModelId);
// Create a building digital twin model.
string buildingModelPayload = SamplesConstants.TemporaryModelWithRelationshipPayload
.Replace(SamplesConstants.RelationshipTargetModelId, sampleFloorModelId)
.Replace(SamplesConstants.ModelId, sampleBuildingModelId)
.Replace(SamplesConstants.ModelDisplayName, "Building")
.Replace(SamplesConstants.RelationshipName, "contains");
await client.CreateModelsAsync(
new[]
{
buildingModelPayload
});
Console.WriteLine($"Created model '{sampleBuildingModelId}'.");
// Create a floor digital twin model.
string floorModelPayload = SamplesConstants.TemporaryModelWithRelationshipPayload
.Replace(SamplesConstants.RelationshipTargetModelId, sampleBuildingModelId)
.Replace(SamplesConstants.ModelId, sampleFloorModelId)
.Replace(SamplesConstants.ModelDisplayName, "Floor")
.Replace(SamplesConstants.RelationshipName, "containedIn");
await client.CreateModelsAsync(new[] { floorModelPayload });
// Get the model we just created
Response <DigitalTwinsModelData> getFloorModelResponse = await client.GetModelAsync(sampleFloorModelId).ConfigureAwait(false);
Console.WriteLine($"Created model '{getFloorModelResponse.Value.Id}'");
// Create a building digital twin.
var buildingDigitalTwin = new BasicDigitalTwin
{
Id = "buildingTwinId",
Metadata = { ModelId = sampleBuildingModelId }
};
Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>("buildingTwinId", buildingDigitalTwin);
Console.WriteLine($"Created twin '{createDigitalTwinResponse.Value.Id}'.");
// Create a floor digital.
var floorDigitalTwin = new BasicDigitalTwin
{
Id = "floorTwinId",
Metadata = { ModelId = sampleFloorModelId }
};
Response <BasicDigitalTwin> createFloorDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>("floorTwinId", floorDigitalTwin);
Console.WriteLine($"Created twin '{createFloorDigitalTwinResponse.Value.Id}'.");
// Create a relationship between building and floor using the BasicRelationship serialization helper.
#region Snippet:DigitalTwinsSampleCreateBasicRelationship
var buildingFloorRelationshipPayload = new BasicRelationship
{
Id = "buildingFloorRelationshipId",
SourceId = "buildingTwinId",
TargetId = "floorTwinId",
Name = "contains",
Properties =
{
{ "Prop1", "Prop1 value" },
{ "Prop2", 6 }
}
};
Response <BasicRelationship> createBuildingFloorRelationshipResponse = await client
.CreateOrReplaceRelationshipAsync <BasicRelationship>("buildingTwinId", "buildingFloorRelationshipId", buildingFloorRelationshipPayload);
Console.WriteLine($"Created a digital twin relationship '{createBuildingFloorRelationshipResponse.Value.Id}' " +
$"from twin '{createBuildingFloorRelationshipResponse.Value.SourceId}' to twin '{createBuildingFloorRelationshipResponse.Value.TargetId}'.");
#endregion Snippet:DigitalTwinsSampleCreateBasicRelationship
// You can get a relationship as a BasicRelationship type.
#region Snippet:DigitalTwinsSampleGetBasicRelationship
Response <BasicRelationship> getBasicRelationshipResponse = await client.GetRelationshipAsync <BasicRelationship>(
"buildingTwinId",
"buildingFloorRelationshipId");
if (getBasicRelationshipResponse.GetRawResponse().Status == (int)HttpStatusCode.OK)
{
BasicRelationship basicRelationship = getBasicRelationshipResponse.Value;
Console.WriteLine($"Retrieved relationship '{basicRelationship.Id}' from twin {basicRelationship.SourceId}.\n\t" +
$"Prop1: {basicRelationship.Properties["Prop1"]}\n\t" +
$"Prop2: {basicRelationship.Properties["Prop2"]}");
}
#endregion Snippet:DigitalTwinsSampleGetBasicRelationship
// Alternatively, you can create your own custom data types and use these types when calling into the APIs.
// This requires less code or knowledge of the type for interaction.
// Create a relationship between floorTwinId and buildingTwinId using a custom data type.
#region Snippet:DigitalTwinsSampleCreateCustomRelationship
var floorBuildingRelationshipPayload = new CustomRelationship
{
Id = "floorBuildingRelationshipId",
SourceId = "floorTwinId",
TargetId = "buildingTwinId",
Name = "containedIn",
Prop1 = "Prop1 val",
Prop2 = 4
};
Response <CustomRelationship> createCustomRelationshipResponse = await client
.CreateOrReplaceRelationshipAsync <CustomRelationship>("floorTwinId", "floorBuildingRelationshipId", floorBuildingRelationshipPayload);
Console.WriteLine($"Created a digital twin relationship '{createCustomRelationshipResponse.Value.Id}' " +
$"from twin '{createCustomRelationshipResponse.Value.SourceId}' to twin '{createCustomRelationshipResponse.Value.TargetId}'.");
#endregion Snippet:DigitalTwinsSampleCreateCustomRelationship
// Getting a relationship as a custom data type is extremely easy.
#region Snippet:DigitalTwinsSampleGetCustomRelationship
Response <CustomRelationship> getCustomRelationshipResponse = await client.GetRelationshipAsync <CustomRelationship>(
"floorTwinId",
"floorBuildingRelationshipId");
CustomRelationship getCustomRelationship = getCustomRelationshipResponse.Value;
Console.WriteLine($"Retrieved and deserialized relationship '{getCustomRelationship.Id}' from twin '{getCustomRelationship.SourceId}'.\n\t" +
$"Prop1: {getCustomRelationship.Prop1}\n\t" +
$"Prop2: {getCustomRelationship.Prop2}");
#endregion Snippet:DigitalTwinsSampleGetCustomRelationship
// Get all relationships in the graph where buildingTwinId is the source of the relationship.
#region Snippet:DigitalTwinsSampleGetAllRelationships
AsyncPageable <BasicRelationship> relationships = client.GetRelationshipsAsync <BasicRelationship>("buildingTwinId");
await foreach (BasicRelationship relationship in relationships)
{
Console.WriteLine($"Retrieved relationship '{relationship.Id}' with source {relationship.SourceId}' and " +
$"target {relationship.TargetId}.\n\t" +
$"Prop1: {relationship.Properties["Prop1"]}\n\t" +
$"Prop2: {relationship.Properties["Prop2"]}");
}
#endregion Snippet:DigitalTwinsSampleGetAllRelationships
// Get all incoming relationships in the graph where buildingTwinId is the target of the relationship.
#region Snippet:DigitalTwinsSampleGetIncomingRelationships
AsyncPageable <IncomingRelationship> incomingRelationships = client.GetIncomingRelationshipsAsync("buildingTwinId");
await foreach (IncomingRelationship incomingRelationship in incomingRelationships)
{
Console.WriteLine($"Found an incoming relationship '{incomingRelationship.RelationshipId}' from '{incomingRelationship.SourceId}'.");
}
#endregion Snippet:DigitalTwinsSampleGetIncomingRelationships
// Delete the contains relationship, created earlier in the sample code, from building to floor.
#region Snippet:DigitalTwinsSampleDeleteRelationship
await client.DeleteRelationshipAsync("buildingTwinId", "buildingFloorRelationshipId");
Console.WriteLine($"Deleted relationship 'buildingFloorRelationshipId'.");
#endregion Snippet:DigitalTwinsSampleDeleteRelationship
// Delete the containedIn relationship, created earlier in the sample code, from floor to building.
await client.DeleteRelationshipAsync("floorTwinId", "floorBuildingRelationshipId");
Console.WriteLine($"Deleted relationship 'floorBuildingRelationshipId'.");
// Clean up.
try
{
// Delete all twins
await client.DeleteDigitalTwinAsync("buildingTwinId");
await client.DeleteDigitalTwinAsync("floorTwinId");
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete twin due to {ex}.");
}
try
{
await client.DeleteModelAsync(sampleBuildingModelId);
await client.DeleteModelAsync(sampleFloorModelId);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed to delete model due to {ex}.");
}
}
public async Task DigitalTwins_DeleteTwinFailsIfMatchProvidesOutdatedEtag()
{
DigitalTwinsClient client = GetClient();
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
try
{
// arrange
// create room model
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
roomModel
}).ConfigureAwait(false);
// act
// create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// get twin
ETag?etagBeforeUpdate = (await client.GetDigitalTwinAsync <BasicDigitalTwin>(roomTwinId).ConfigureAwait(false)).Value.ETag;
// update twin
JsonPatchDocument updateTwinPatchDocument = new JsonPatchDocument();
updateTwinPatchDocument.AppendAdd("/Humidity", 30);
updateTwinPatchDocument.AppendReplace("/Temperature", 70);
updateTwinPatchDocument.AppendRemove("/EmployeeId");
await client.UpdateDigitalTwinAsync(roomTwinId, updateTwinPatchDocument, ETag.All).ConfigureAwait(false);
// assert
Func <Task> act = async() =>
{
// since the ETag is out of date, this call should throw a 412
await client.DeleteDigitalTwinAsync(roomTwinId, etagBeforeUpdate).ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.PreconditionFailed);
}
finally
{
// cleanup
try
{
if (!string.IsNullOrWhiteSpace(roomModelId))
{
await client.DeleteModelAsync(roomModelId).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
