public static async Task CreateRelationship(DigitalTwinsClient client)
{
Console.Write("source twinId: ");
string sourceTwinId = Console.ReadLine();
Console.Write("target twinId: ");
string targetTwinId = Console.ReadLine();
string relationshipId = Guid.NewGuid().ToString();
string relationshipName = GetRelationshipFromDigitalTwinIds(client, sourceTwinId, targetTwinId);
var relationship = new BasicRelationship
{
Id = relationshipId,
SourceId = sourceTwinId,
TargetId = targetTwinId,
Name = relationshipName
};
string rel = JsonSerializer.Serialize(relationship);
try
{
await client.CreateRelationshipAsync(sourceTwinId, relationshipId, rel);
}
catch (RequestFailedException e)
{
Console.WriteLine($"Error {e.Status}: {e.Message}");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex}");
}
}
/// <summary>
/// Creates all the relationships defined in the \DTDL\Relationships directory
/// </summary>
public async Task ConnectTwinsTogetherAsync()
{
PrintHeader("CONNECT DIGITAL TWINS");
// First we load the relationships into memory
Dictionary <string, string> allRelationships = FileHelper.LoadAllFilesInPath(s_relationshipsPath);
foreach (KeyValuePair <string, string> relationshipSet in allRelationships)
{
// For each relationship array we deserialize it first
// We deserialize as BasicRelationship to get the entire custom relationship (custom relationship properties).
IEnumerable <BasicRelationship> relationships = JsonSerializer.Deserialize <IEnumerable <BasicRelationship> >(relationshipSet.Value);
// From loaded relationships, get the source Id and Id from each one,
// and create it with full relationship payload
foreach (BasicRelationship relationship in relationships)
{
try
{
string serializedRelationship = JsonSerializer.Serialize(relationship);
await client.CreateRelationshipAsync(
relationship.SourceId,
relationship.Id,
serializedRelationship);
Console.WriteLine($"Linked twin {relationship.SourceId} to twin {relationship.TargetId} as '{relationship.Name}'");
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.Conflict)
{
Console.WriteLine($"Relationship {relationship.Id} already exists: {ex.Message}");
}
}
}
}
public override async Task HandleMessageAsync(DeviceTelemetryMessage requestBody, RequestDetails requestDetails, RequestMessageHeaders headers, IExtensionGatewayClient client, ILogger log)
{
//write telemetry to statestore
await client.PutDeviceTelemetryAsync(requestDetails.DeviceName, requestBody);
// Create a secret client using the DefaultAzureCredential
DefaultAzureCredential cred = new DefaultAzureCredential();
DigitalTwinsClient dtcli = new DigitalTwinsClient(new Uri("https://mobility-vss.api.wus2.digitaltwins.azure.net"), cred);
BasicRelationship rel = JsonSerializer.Deserialize <BasicRelationship>((string)requestBody.Payload);
string relationshipId = Guid.NewGuid().ToString();
await dtcli.CreateRelationshipAsync(rel.SourceId, relationshipId, (string)requestBody.Payload);
}
public async static Task CreateRelationship(DigitalTwinsClient client, string srcId, string targetId)
{
var relationship = new BasicRelationship
{
TargetId = targetId,
Name = "contains"
};
try
{
string relId = $"{srcId}-contains->{targetId}";
await client.CreateRelationshipAsync(srcId, relId, JsonSerializer.Serialize(relationship));
Console.WriteLine("Created relationship successfully");
}
catch (RequestFailedException rex) {
Console.WriteLine($"Create relationship error: {rex.Status}:{rex.Message}");
}
}
public async Task CreateHouseTwin()
{
try
{
List <string> dtdlList = ParseDTDLModels();
Response <ModelData[]> res = await _client.CreateModelsAsync(dtdlList);
Console.WriteLine($"Model(s) created successfully!");
}
catch (RequestFailedException e)
{
Console.WriteLine($"Response {e.Status}: {e.Message}");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
var metaData = new Dictionary <string, object>()
{
{ "$model", "dtmi:demo:House;1" },
{ "$kind", "DigitalTwin" }
};
var twinData = new Dictionary <string, object>()
{
{ "$metadata", metaData },
{ "ConstructionYear", "1985" },
{ "Owner", "Glenn Colpaert" }
};
await _client.CreateDigitalTwinAsync("127.0.0.1", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Localhost Twin created successfully!");
metaData = new Dictionary <string, object>()
{
{ "$model", "dtmi:demo:Floor;1" },
{ "$kind", "DigitalTwin" }
};
twinData = new Dictionary <string, object>()
{
{ "$metadata", metaData }
};
await _client.CreateDigitalTwinAsync("Floor1", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Floor1 Twin created successfully!");
await _client.CreateDigitalTwinAsync("Floor2", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Floor2 Twin created successfully!");
await _client.CreateDigitalTwinAsync("Floor3", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Floor3 Twin created successfully!");
metaData = new Dictionary <string, object>()
{
{ "$model", "dtmi:demo:Room;1" },
{ "$kind", "DigitalTwin" }
};
twinData = new Dictionary <string, object>()
{
{ "$metadata", metaData }
};
await _client.CreateDigitalTwinAsync("Kitchen", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Kitchen Twin created successfully!");
await _client.CreateDigitalTwinAsync("LivingRoom", JsonSerializer.Serialize(twinData));
Console.WriteLine($"LivingRoom Twin created successfully!");
await _client.CreateDigitalTwinAsync("Bedroom1", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Bedroom1 Twin created successfully!");
await _client.CreateDigitalTwinAsync("Bedroom2", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Bedroom2 Twin created successfully!");
await _client.CreateDigitalTwinAsync("Bathroom", JsonSerializer.Serialize(twinData));
Console.WriteLine($"Bathroom Twin created successfully!");
await _client.CreateDigitalTwinAsync("MasterBedroom", JsonSerializer.Serialize(twinData));
Console.WriteLine($"MasterBedroom Twin created successfully!");
metaData = new Dictionary <string, object>()
{
{ "$model", "dtmi:demo:Sensor;1" },
{ "$kind", "DigitalTwin" }
};
//Yes you have to initialize Temp and Hum as default
//Unless you do an add (instead of replace) as update operation to the query interface.
twinData = new Dictionary <string, object>()
{
{ "$metadata", metaData },
{ "FirmwareVersion", "2020.ADT.5782.3" }
//,
// { "Temperature", 0 },
// { "Humidity", 0},
};
await _client.CreateDigitalTwinAsync("TStat001", JsonSerializer.Serialize(twinData));
Console.WriteLine($"TStat001 Twin created successfully!");
await _client.CreateDigitalTwinAsync("TStat002", JsonSerializer.Serialize(twinData));
Console.WriteLine($"TStat002 Twin created successfully!");
await _client.CreateDigitalTwinAsync("TStat003", JsonSerializer.Serialize(twinData));
Console.WriteLine($"TStat003 Twin created successfully!");
await _client.CreateDigitalTwinAsync("TStat004", JsonSerializer.Serialize(twinData));
Console.WriteLine($"TStat004 Twin created successfully!");
await _client.CreateDigitalTwinAsync("TStat005", JsonSerializer.Serialize(twinData));
Console.WriteLine($"TStat005 Twin created successfully!");
var body = new Dictionary <string, object>()
{
{ "$targetId", "Floor1" },
{ "$relationshipName", "floors" }
};
await _client.CreateRelationshipAsync("127.0.0.1", "localhost_to_Floor1", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship localhost_to_Floor1 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Floor2" },
{ "$relationshipName", "floors" }
};
await _client.CreateRelationshipAsync("127.0.0.1", "localhost_to_floor2", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship localhost_to_floor2 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Floor3" },
{ "$relationshipName", "floors" }
};
await _client.CreateRelationshipAsync("127.0.0.1", "localhost_to_floor3", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship localhost_to_floor3 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Kitchen" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor1", "Floor1_to_kitchen", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship Floor1_to_kitchen created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "LivingRoom" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor1", "Floor1_to_livingroom", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship Floor1_to_livingroom created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Bathroom" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor2", "floor2_to_bathroom", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship floor2_to_bathroom created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Bedroom1" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor2", "floor2_to_bedroom1", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship floor2_to_bedroom1 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "Bedroom2" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor2", "floor2_to_bedroom2", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship floor2_to_bedroom2 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "MasterBedroom" },
{ "$relationshipName", "rooms" }
};
await _client.CreateRelationshipAsync("Floor3", "floor3_to_masterbedroom", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship floor3_to_masterbedroom created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat001" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("Kitchen", "kitchen_to_tstat001", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship kitchen_to_tstat001 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat001" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("LivingRoom", "livingroom_to_tstat001", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship LivingRoom_to_tstat001 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat002" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("Bedroom1", "bedroom_to_tstat002", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship bedroom_to_tstat002 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat003" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("Bedroom2", "bedroom2_to_tstat003", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship bedroom2_to_tstat003 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat004" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("Bathroom", "bathroom_to_tstat004", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship bathroom_to_tstat004 created successfully!");
body = new Dictionary <string, object>()
{
{ "$targetId", "TStat005" },
{ "$relationshipName", "sensors" }
};
await _client.CreateRelationshipAsync("MasterBedroom", "masterbedroom_to_tstat005", JsonSerializer.Serialize(body));
Console.WriteLine($"Relationship masterbedroom_to_tstat005 created successfully!");
}
/// <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 });
Console.WriteLine($"Created model '{sampleFloorModelId}'");
// Create a building digital twin.
var buildingDigitalTwin = new BasicDigitalTwin
{
Id = "buildingTwinId",
Metadata = { ModelId = sampleBuildingModelId }
};
Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateDigitalTwinAsync <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.CreateDigitalTwinAsync <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",
CustomProperties =
{
{ "Prop1", "Prop1 value" },
{ "Prop2", 6 }
}
};
Response <BasicRelationship> createBuildingFloorRelationshipResponse = await client
.CreateRelationshipAsync <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.CustomProperties["Prop1"]}\n\t" +
$"Prop2: {basicRelationship.CustomProperties["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
.CreateRelationshipAsync <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 <string> relationships = client.GetRelationshipsAsync("buildingTwinId");
await foreach (var relationshipJson in relationships)
{
BasicRelationship relationship = JsonSerializer.Deserialize <BasicRelationship>(relationshipJson);
Console.WriteLine($"Retrieved relationship '{relationship.Id}' with source {relationship.SourceId}' and " +
$"target {relationship.TargetId}.\n\t" +
$"Prop1: {relationship.CustomProperties["Prop1"]}\n\t" +
$"Prop2: {relationship.CustomProperties["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 Relationships_Lifecycle()
{
// arrange
DigitalTwinsClient client = GetClient();
var floorContainsRoomRelationshipId = "FloorToRoomRelationship";
var floorCooledByHvacRelationshipId = "FloorToHvacRelationship";
var hvacCoolsFloorRelationshipId = "HvacToFloorRelationship";
var roomContainedInFloorRelationshipId = "RoomToFloorRelationship";
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
string hvacModelId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.HvacModelIdPrefix).ConfigureAwait(false);
string floorTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.FloorTwinIdPrefix).ConfigureAwait(false);
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string hvacTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.HvacTwinIdPrefix).ConfigureAwait(false);
try
{
// create floor, room and hvac model
string floorModel = TestAssetsHelper.GetFloorModelPayload(floorModelId, roomModelId, hvacModelId);
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
string hvacModel = TestAssetsHelper.GetHvacModelPayload(hvacModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
floorModel, roomModel, hvacModel
}).ConfigureAwait(false);
// create floor twin
BasicDigitalTwin floorTwin = TestAssetsHelper.GetFloorTwinPayload(floorModelId);
await client.CreateDigitalTwinAsync <BasicDigitalTwin>(floorTwinId, floorTwin).ConfigureAwait(false);
// Create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
// create hvac twin
BasicDigitalTwin hvacTwin = TestAssetsHelper.GetHvacTwinPayload(hvacModelId);
await client.CreateDigitalTwinAsync <BasicDigitalTwin>(hvacTwinId, hvacTwin).ConfigureAwait(false);
BasicRelationship floorContainsRoomPayload = TestAssetsHelper.GetRelationshipWithPropertyPayload(roomTwinId, ContainsRelationship, "isAccessRestricted", true);
BasicRelationship floorTwinCoolsRelationshipPayload = TestAssetsHelper.GetRelationshipPayload(floorTwinId, CoolsRelationship);
BasicRelationship floorTwinContainedInRelationshipPayload = TestAssetsHelper.GetRelationshipPayload(floorTwinId, ContainedInRelationship);
BasicRelationship floorCooledByHvacPayload = TestAssetsHelper.GetRelationshipPayload(hvacTwinId, CooledByRelationship);
JsonPatchDocument floorContainsRoomUpdatePayload = new JsonPatchDocument();
floorContainsRoomUpdatePayload.AppendReplace("/isAccessRestricted", false);
// CREATE relationships
// create Relationship from Floor -> Room
await client
.CreateRelationshipAsync <BasicRelationship>(
floorTwinId,
floorContainsRoomRelationshipId,
floorContainsRoomPayload)
.ConfigureAwait(false);
// create Relationship from Floor -> Hvac
await client
.CreateRelationshipAsync <BasicRelationship>(
floorTwinId,
floorCooledByHvacRelationshipId,
floorCooledByHvacPayload)
.ConfigureAwait(false);
// create Relationship from Hvac -> Floor
await client
.CreateRelationshipAsync <BasicRelationship>(
hvacTwinId,
hvacCoolsFloorRelationshipId,
floorTwinCoolsRelationshipPayload)
.ConfigureAwait(false);
// create Relationship from Room -> Floor
await client
.CreateRelationshipAsync <BasicRelationship>(
roomTwinId,
roomContainedInFloorRelationshipId,
floorTwinContainedInRelationshipPayload)
.ConfigureAwait(false);
// UPDATE relationships
// create Relationship from Floor -> Room
await client
.UpdateRelationshipAsync(
floorTwinId,
floorContainsRoomRelationshipId,
floorContainsRoomUpdatePayload)
.ConfigureAwait(false);
// GET relationship
Response <BasicRelationship> containsRelationshipId = await client
.GetRelationshipAsync <BasicRelationship>(
floorTwinId,
floorContainsRoomRelationshipId)
.ConfigureAwait(false);
// LIST incoming relationships
AsyncPageable <IncomingRelationship> incomingRelationships = client.GetIncomingRelationshipsAsync(floorTwinId);
int numberOfIncomingRelationshipsToFloor = 0;
await foreach (IncomingRelationship relationship in incomingRelationships)
{
++numberOfIncomingRelationshipsToFloor;
}
numberOfIncomingRelationshipsToFloor.Should().Be(2, "floor has incoming relationships from room and hvac");
// LIST relationships
AsyncPageable <string> floorRelationships = client.GetRelationshipsAsync(floorTwinId);
int numberOfFloorRelationships = 0;
await foreach (var relationship in floorRelationships)
{
++numberOfFloorRelationships;
}
numberOfFloorRelationships.Should().Be(2, "floor has an relationship to room and hvac");
// LIST relationships by name
AsyncPageable <string> roomTwinRelationships = client
.GetRelationshipsAsync(
roomTwinId,
ContainedInRelationship);
containsRelationshipId.Value.Id.Should().Be(floorContainsRoomRelationshipId);
int numberOfRelationships = 0;
await foreach (var relationship in roomTwinRelationships)
{
++numberOfRelationships;
}
numberOfRelationships.Should().Be(1, "room has only one containedIn relationship to floor");
await client
.DeleteRelationshipAsync(
floorTwinId,
floorContainsRoomRelationshipId)
.ConfigureAwait(false);
await client
.DeleteRelationshipAsync(
roomTwinId,
roomContainedInFloorRelationshipId)
.ConfigureAwait(false);
await client
.DeleteRelationshipAsync(
floorTwinId,
floorCooledByHvacRelationshipId)
.ConfigureAwait(false);
await client
.DeleteRelationshipAsync(
hvacTwinId,
hvacCoolsFloorRelationshipId)
.ConfigureAwait(false);
Func <Task> act = async() =>
{
await client
.GetRelationshipAsync <BasicRelationship>(
floorTwinId,
floorContainsRoomRelationshipId)
.ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.NotFound);
act = async() =>
{
await client
.GetRelationshipAsync <BasicRelationship>(
roomTwinId,
roomContainedInFloorRelationshipId)
.ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>().
And.Status.Should().Be((int)HttpStatusCode.NotFound);
act = async() =>
{
await client
.GetRelationshipAsync <BasicRelationship>(
floorTwinId,
floorCooledByHvacRelationshipId)
.ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>().
And.Status.Should().Be((int)HttpStatusCode.NotFound);
act = async() =>
{
await client
.GetRelationshipAsync <BasicRelationship>(
hvacTwinId,
hvacCoolsFloorRelationshipId)
.ConfigureAwait(false);
};
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.NotFound);
}
finally
{
// clean up
try
{
await Task
.WhenAll(
client.DeleteDigitalTwinAsync(floorTwinId),
client.DeleteDigitalTwinAsync(roomTwinId),
client.DeleteDigitalTwinAsync(hvacTwinId),
client.DeleteModelAsync(hvacModelId),
client.DeleteModelAsync(floorModelId),
client.DeleteModelAsync(roomModelId))
.ConfigureAwait(false);
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
public async Task Relationships_PaginationWorks()
{
DigitalTwinsClient client = GetClient();
string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
string roomModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
string hvacModelId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.HvacModelIdPrefix).ConfigureAwait(false);
string floorTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.FloorTwinIdPrefix).ConfigureAwait(false);
string roomTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
string hvacTwinId = await GetUniqueTwinIdAsync(client, TestAssetDefaults.HvacTwinIdPrefix).ConfigureAwait(false);
try
{
// create floor, room and hvac model
string floorModel = TestAssetsHelper.GetFloorModelPayload(floorModelId, roomModelId, hvacModelId);
string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
string hvacModel = TestAssetsHelper.GetHvacModelPayload(hvacModelId, floorModelId);
await client.CreateModelsAsync(new List <string> {
floorModel, roomModel, hvacModel
}).ConfigureAwait(false);
// create floor twin
BasicDigitalTwin floorTwin = TestAssetsHelper.GetFloorTwinPayload(floorModelId);
await client.CreateDigitalTwinAsync <BasicDigitalTwin>(floorTwinId, floorTwin).ConfigureAwait(false);
// Create room twin
BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
await client.CreateDigitalTwinAsync <BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
BasicRelationship floorContainsRoomPayload = TestAssetsHelper.GetRelationshipWithPropertyPayload(roomTwinId, ContainsRelationship, "isAccessRestricted", true);
BasicRelationship floorTwinContainedInRelationshipPayload = TestAssetsHelper.GetRelationshipPayload(floorTwinId, ContainedInRelationship);
// For the sake of test simplicity, we'll just add multiple relationships from the same floor to the same room.
for (int i = 0; i < bulkRelationshipCount; i++)
{
var floorContainsRoomRelationshipId = $"FloorToRoomRelationship-{GetRandom()}";
// create Relationship from Floor -> Room
await client
.CreateRelationshipAsync <BasicRelationship>(
floorTwinId,
floorContainsRoomRelationshipId,
floorContainsRoomPayload)
.ConfigureAwait(false);
}
// For the sake of test simplicity, we'll just add multiple relationships from the same room to the same floor.
for (int i = 0; i < bulkRelationshipCount; i++)
{
var roomContainedInFloorRelationshipId = $"RoomToFloorRelationship-{GetRandom()}";
// create Relationship from Room -> Floor
await client
.CreateRelationshipAsync <BasicRelationship>(
roomTwinId,
roomContainedInFloorRelationshipId,
floorTwinContainedInRelationshipPayload)
.ConfigureAwait(false);
}
// LIST incoming relationships by page
AsyncPageable <IncomingRelationship> incomingRelationships = client.GetIncomingRelationshipsAsync(floorTwinId);
int incomingRelationshipPageCount = 0;
await foreach (Page <IncomingRelationship> incomingRelationshipPage in incomingRelationships.AsPages())
{
incomingRelationshipPageCount++;
if (incomingRelationshipPage.ContinuationToken != null)
{
incomingRelationshipPage.Values.Count.Should().Be(defaultRelationshipPageSize, "Unexpected page size for a non-terminal page");
}
}
incomingRelationshipPageCount.Should().BeGreaterThan(1, "Expected more than one page of incoming relationships");
// LIST outgoing relationships by page
AsyncPageable <string> outgoingRelationships = client.GetRelationshipsAsync(floorTwinId);
int outgoingRelationshipPageCount = 0;
await foreach (Page <string> outgoingRelationshipPage in outgoingRelationships.AsPages())
{
outgoingRelationshipPageCount++;
if (outgoingRelationshipPage.ContinuationToken != null)
{
outgoingRelationshipPage.Values.Count.Should().Be(defaultRelationshipPageSize, "Unexpected page size for a non-terminal page");
}
}
outgoingRelationshipPageCount.Should().BeGreaterThan(1, "Expected more than one page of outgoing relationships");
}
finally
{
// clean up
try
{
await Task
.WhenAll(
client.DeleteDigitalTwinAsync(floorTwinId),
client.DeleteDigitalTwinAsync(roomTwinId),
client.DeleteDigitalTwinAsync(hvacTwinId),
client.DeleteModelAsync(hvacModelId),
client.DeleteModelAsync(floorModelId),
client.DeleteModelAsync(roomModelId))
.ConfigureAwait(false);
}
catch (Exception ex)
{
Assert.Fail($"Test clean up failed: {ex.Message}");
}
}
}
