/// <summary>
/// This sample demonstrates querying for raw events, series and aggregate series data from a Time Series Insights environment.
/// </summary>
/// <remarks>
/// The Query APIs make use Time Series Expressions (TSX) to build filters, value and aggregation expressions. Visit
/// <see href="https://docs.microsoft.com/rest/api/time-series-insights/reference-time-series-expression-syntax"/> to learn more about TSX.
/// </remarks>
public async Task RunSamplesAsync(TimeSeriesInsightsClient client, DeviceClient deviceClient)
{
PrintHeader("TIME SERIES INSIGHTS QUERY SAMPLE");
// Figure out what keys make up the Time Series Id
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesModelSettings modelSettings = await modelSettingsClient.GetAsync();
TimeSeriesId tsId = TimeSeriesIdHelper.CreateTimeSeriesId(modelSettings);
TimeSeriesInsightsQueries queriesClient = client.GetQueriesClient();
// In order to query for data, let's first send events to the IoT Hub
await SendEventsToIotHubAsync(deviceClient, tsId, modelSettings.TimeSeriesIdProperties.ToArray());
// Sleeping for a few seconds to allow data to fully propagate in the Time Series Insights service
Thread.Sleep(TimeSpan.FromSeconds(3));
await RunQueryEventsSample(queriesClient, tsId);
await RunQueryAggregateSeriesSample(queriesClient, tsId);
await RunQuerySeriesSampleWithInlineVariables(queriesClient, tsId);
await RunQuerySeriesSampleWithPreDefinedVariables(client, tsId);
}
public async Task TimeSeriesInsightsClient_ModelSettingsTest()
{
TimeSeriesInsightsClient client = GetClient();
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesInsightsTypes typesClient = client.GetTypesClient();
// GET model settings
Response <TimeSeriesModelSettings> currentSettings = await modelSettingsClient.GetAsync().ConfigureAwait(false);
currentSettings.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK);
string testName = "testModel";
// UPDATE model settings
string typeId = await createTimeSeriesTypeAsync(client).ConfigureAwait(false);
string defaultTypeId = await getDefaultTypeIdAsync(modelSettingsClient).ConfigureAwait(false);
try
{
Response <TimeSeriesModelSettings> updatedSettingsName = await modelSettingsClient.UpdateNameAsync(testName).ConfigureAwait(false);
updatedSettingsName.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK);
updatedSettingsName.Value.Name.Should().Be(testName);
await TestRetryHelper.RetryAsync <Response <TimeSeriesModelSettings> >(async() =>
{
Response <TimeSeriesModelSettings> updatedSettingsId = await modelSettingsClient.UpdateDefaultTypeIdAsync(typeId).ConfigureAwait(false);
updatedSettingsId.Value.DefaultTypeId.Should().Be(typeId);
// update it back to the default Type Id
updatedSettingsId = await modelSettingsClient.UpdateDefaultTypeIdAsync(defaultTypeId).ConfigureAwait(false);
updatedSettingsId.Value.DefaultTypeId.Should().Be(defaultTypeId);
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
// clean up
try
{
Response <TimeSeriesOperationError[]> deleteTypesResponse = await typesClient
.DeleteByIdAsync(new string[] { typeId })
.ConfigureAwait(false);
// Assert that the response array does not have any error object set
deleteTypesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null);
}
catch (Exception ex)
{
Console.WriteLine($"Test clean up failed: {ex.Message}");
throw;
}
}
}
public void UpdateModelSettingsWithInvalidType_ThrowsBadRequestException()
{
// arrange
TimeSeriesInsightsClient client = GetClient();
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
// act
Func <Task> act = async() => await modelSettingsClient.UpdateDefaultTypeIdAsync("testId").ConfigureAwait(false);
// assert
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.BadRequest);
}
/// <summary>
/// Main entry point to the sample.
/// </summary>
public static async Task Main(string[] args)
{
// Parse and validate paramters
Options options = null;
ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args)
.WithParsed(parsedOptions =>
{
options = parsedOptions;
})
.WithNotParsed(errors =>
{
Environment.Exit(1);
});
// Instantiate the Time Series Insights client
TimeSeriesInsightsClient tsiClient = GetTimeSeriesInsightsClient(
options.TenantId,
options.ClientId,
options.ClientSecret,
options.TsiEnvironmentFqdn);
// Instantiate an IoT Hub device client client in order to send telemetry to the hub
DeviceClient deviceClient = await GetDeviceClientAsync(options.IoTHubConnectionString).ConfigureAwait(false);
// Figure out what keys make up the Time Series Id
TimeSeriesInsightsModelSettings modelSettingsClient = tsiClient.GetModelSettingsClient();
TimeSeriesModelSettings modelSettings = await modelSettingsClient.GetAsync();
TimeSeriesId tsId = TimeSeriesIdHelper.CreateTimeSeriesId(modelSettings);
// In order to query for data, let's first send events to the IoT Hub
await SendEventsToIotHubAsync(deviceClient, tsId, modelSettings.TimeSeriesIdProperties.ToArray());
// Run the samples
var tsiInstancesSamples = new InstancesSamples();
await tsiInstancesSamples.RunSamplesAsync(tsiClient);
var tsiTypesSamples = new TypesSamples();
await tsiTypesSamples.RunSamplesAsync(tsiClient);
var tsiHierarchiesSamples = new HierarchiesSamples();
await tsiHierarchiesSamples.RunSamplesAsync(tsiClient);
var tsiModelSettingsSamples = new ModelSettingsSamples();
await tsiModelSettingsSamples.RunSamplesAsync(tsiClient);
var querySamples = new QuerySamples();
await querySamples.RunSamplesAsync(tsiClient, tsId);
}
/// <summary>
/// This sample demonstrates getting Time Series model settings, updating model settings and changing the default type Id for a model.
/// </summary>
public async Task RunSamplesAsync(TimeSeriesInsightsClient client)
{
PrintHeader("TIME SERIES INSIGHTS MODEL SETTINGS SAMPLE");
#region Snippet:TimeSeriesInsightsSampleGetModelSettings
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesInsightsTypes typesClient = client.GetTypesClient();
Response <TimeSeriesModelSettings> getModelSettingsResponse = await modelSettingsClient.GetAsync();
Console.WriteLine($"Retrieved Time Series Insights model settings \nname : '{getModelSettingsResponse.Value.Name}', " +
$"default type Id: {getModelSettingsResponse.Value.DefaultTypeId}'");
IReadOnlyList <TimeSeriesIdProperty> timeSeriesIdProperties = getModelSettingsResponse.Value.TimeSeriesIdProperties;
foreach (TimeSeriesIdProperty property in timeSeriesIdProperties)
{
Console.WriteLine($"Time Series Id property name : '{property.Name}', type : '{property.PropertyType}'.");
}
#endregion Snippet:TimeSeriesInsightsSampleGetModelSettings
// Store the default type Id so it can be used during clean up
string defaultTypeId = getModelSettingsResponse.Value.DefaultTypeId;
#region Snippet:TimeSeriesInsightsSampleUpdateModelSettingsName
Response <TimeSeriesModelSettings> updateModelSettingsNameResponse = await modelSettingsClient.UpdateNameAsync("NewModelSettingsName");
Console.WriteLine($"Updated Time Series Insights model settings name: " +
$"{updateModelSettingsNameResponse.Value.Name}");
#endregion Snippet:TimeSeriesInsightsSampleUpdateModelSettingsName
// For every Time Series Insights environment, there is a default type that any newly created Time Series instance will be associated with.
// You can change the default type for a TSI environment by creating a new type and calling the API to update the default type Id.
// Create a Time Series type.
var aggregateVariable = new AggregateVariable(new TimeSeriesExpression("count()"));
var variables = new Dictionary <string, TimeSeriesVariable>
{
{ "aggregateVariableName", aggregateVariable },
};
var type = new TimeSeriesType("tsiTypeName", variables);
var timeSeriesTypes = new List <TimeSeriesType> {
type
};
string tsiTypeId = null;
Response <TimeSeriesTypeOperationResult[]> createTsiTypeResponse = await typesClient
.CreateOrReplaceAsync(timeSeriesTypes);
// Ensure no error was reported as part of the response
if (createTsiTypeResponse.Value[0].Error == null)
{
// Store the Time Series type id to use it for updating default type in model settings
tsiTypeId = createTsiTypeResponse.Value[0].TimeSeriesType.Id;
#region Snippet:TimeSeriesInsightsSampleUpdateModelSettingsDefaultType
Response <TimeSeriesModelSettings> updateDefaultTypeIdResponse = await modelSettingsClient
.UpdateDefaultTypeIdAsync(tsiTypeId);
Console.WriteLine($"Updated Time Series Insights model settings default type Id: " +
$"{updateDefaultTypeIdResponse.Value.Name}");
#endregion Snippet:TimeSeriesInsightsSampleUpdateModelSettingsDefaultType
}
// Clean up
try
{
// Revert back to the original default type Id
await modelSettingsClient
.UpdateDefaultTypeIdAsync(defaultTypeId);
// Delete the type created
if (tsiTypeId != null)
{
await typesClient
.DeleteByIdAsync(new List <string> {
tsiTypeId
});
}
}
catch (Exception ex)
{
Console.WriteLine($"Failed at one of the clean up steps: {ex.Message}");
}
}
public async Task TimeSeriesInsightsInstances_Lifecycle()
{
// Arrange
TimeSeriesInsightsClient client = GetClient();
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient();
int numOfInstancesToSetup = 2;
var timeSeriesInstances = new List <TimeSeriesInstance>();
Response <TimeSeriesModelSettings> currentSettings = await modelSettingsClient.GetAsync().ConfigureAwait(false);
string defaultTypeId = currentSettings.Value.DefaultTypeId;
int numOfIdProperties = currentSettings.Value.TimeSeriesIdProperties.Count;
for (int i = 0; i < numOfInstancesToSetup; i++)
{
TimeSeriesId id = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, numOfIdProperties)
.ConfigureAwait(false);
var instance = new TimeSeriesInstance(id, defaultTypeId)
{
Name = Recording.GenerateAlphaNumericId("instance"),
};
timeSeriesInstances.Add(instance);
}
IEnumerable <TimeSeriesId> timeSeriesInstancesIds = timeSeriesInstances.Select((instance) => instance.TimeSeriesId);
// Act and assert
try
{
await TestRetryHelper.RetryAsync <Response <InstancesOperationResult[]> >((Func <Task <Response <InstancesOperationResult[]> > >)(async() =>
{
// Create TSI instances
Response <TimeSeriesOperationError[]> createInstancesResult = await instancesClient
.CreateOrReplaceAsync(timeSeriesInstances)
.ConfigureAwait(false);
// Assert that the result error array does not contain any object that is set
createInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult == null);
// Get the created instances by Ids
Response <InstancesOperationResult[]> getInstancesByIdsResult = await instancesClient
.GetByIdAsync(timeSeriesInstancesIds)
.ConfigureAwait(false);
getInstancesByIdsResult.Value.Length.Should().Be(timeSeriesInstances.Count);
foreach (InstancesOperationResult instanceResult in getInstancesByIdsResult.Value)
{
instanceResult.Instance.Should().NotBeNull();
instanceResult.Error.Should().BeNull();
instanceResult.Instance.TimeSeriesId.ToStringArray().Length.Should().Be(numOfIdProperties);
AssertionExtensions.Should(instanceResult.Instance.TimeSeriesTypeId).Be(defaultTypeId);
instanceResult.Instance.HierarchyIds.Count.Should().Be(0);
instanceResult.Instance.InstanceFields.Count.Should().Be(0);
}
// Update the instances by adding descriptions to them
timeSeriesInstances.ForEach((timeSeriesInstance) =>
timeSeriesInstance.Description = "Description");
Response <InstancesOperationResult[]> replaceInstancesResult = await instancesClient
.ReplaceAsync(timeSeriesInstances)
.ConfigureAwait(false);
replaceInstancesResult.Value.Length.Should().Be(timeSeriesInstances.Count);
replaceInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null);
// Get instances by name
Response <InstancesOperationResult[]> getInstancesByNameResult = await instancesClient
.GetByNameAsync(timeSeriesInstances.Select((instance) => instance.Name))
.ConfigureAwait(false);
getInstancesByNameResult.Value.Length.Should().Be(timeSeriesInstances.Count);
foreach (InstancesOperationResult instanceResult in getInstancesByNameResult.Value)
{
instanceResult.Instance.Should().NotBeNull();
instanceResult.Error.Should().BeNull();
instanceResult.Instance.TimeSeriesId.ToStringArray().Length.Should().Be(numOfIdProperties);
AssertionExtensions.Should(instanceResult.Instance.TimeSeriesTypeId).Be(defaultTypeId);
instanceResult.Instance.HierarchyIds.Count.Should().Be(0);
instanceResult.Instance.InstanceFields.Count.Should().Be(0);
}
// Get all Time Series instances in the environment
AsyncPageable <TimeSeriesInstance> getAllInstancesResponse = instancesClient.GetAsync();
int numOfInstances = 0;
await foreach (TimeSeriesInstance tsiInstance in getAllInstancesResponse)
{
numOfInstances++;
tsiInstance.Should().NotBeNull();
}
numOfInstances.Should().BeGreaterOrEqualTo(numOfInstancesToSetup);
return(null);
}), MaxNumberOfRetries, s_retryDelay);
}
finally
{
// clean up
try
{
Response <TimeSeriesOperationError[]> deleteInstancesResponse = await instancesClient
.DeleteByIdAsync(timeSeriesInstancesIds)
.ConfigureAwait(false);
// Assert that the response array does not have any error object set
deleteInstancesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null);
}
catch (Exception ex)
{
Console.WriteLine($"Test clean up failed: {ex.Message}");
throw;
}
}
}
protected async Task <string> getDefaultTypeIdAsync(TimeSeriesInsightsModelSettings modelSettingsClient)
{
Response <TimeSeriesModelSettings> currentSettings = await modelSettingsClient.GetAsync().ConfigureAwait(false);
return(currentSettings.Value.DefaultTypeId);
}
public async Task TimeSeriesInsightsQuery_AggregateSeriesWithNumericVariable()
{
// Arrange
TimeSeriesInsightsClient tsiClient = GetClient();
TimeSeriesInsightsModelSettings timeSeriesModelSettings = tsiClient.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = tsiClient.GetInstancesClient();
TimeSeriesInsightsQueries queriesClient = tsiClient.GetQueriesClient();
DeviceClient deviceClient = await GetDeviceClient().ConfigureAwait(false);
// Figure out what the Time Series Id is composed of
TimeSeriesModelSettings modelSettings = await timeSeriesModelSettings.GetAsync().ConfigureAwait(false);
// Create a Time Series Id where the number of keys that make up the Time Series Id is fetched from Model Settings
TimeSeriesId tsiId = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, modelSettings.TimeSeriesIdProperties.Count)
.ConfigureAwait(false);
try
{
// Send some events to the IoT hub with with a second between each event
await QueryTestsHelper.SendEventsToHubAsync(
deviceClient,
tsiId,
modelSettings.TimeSeriesIdProperties.ToArray(),
30)
.ConfigureAwait(false);
DateTimeOffset now = Recording.UtcNow;
DateTimeOffset endTime = now.AddMinutes(10);
DateTimeOffset startTime = now.AddMinutes(-10);
var temperatureNumericVariable = new NumericVariable(
new TimeSeriesExpression($"$event.{QueryTestsHelper.Temperature}"),
new TimeSeriesExpression("avg($value)"));
var queryAggregateSeriesRequestOptions = new QueryAggregateSeriesRequestOptions();
queryAggregateSeriesRequestOptions.InlineVariables[QueryTestsHelper.Temperature] = temperatureNumericVariable;
queryAggregateSeriesRequestOptions.ProjectedVariableNames.Add(QueryTestsHelper.Temperature);
// This retry logic was added as the TSI instance are not immediately available after creation
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryAggregateSeriesPages = queriesClient.CreateAggregateSeriesQuery(
tsiId,
startTime,
endTime,
TimeSpan.FromSeconds(5),
queryAggregateSeriesRequestOptions);
var nonNullFound = false;
await foreach (Page <TimeSeriesPoint> aggregateSeriesPage in queryAggregateSeriesPages.GetResultsAsync().AsPages())
{
foreach (TimeSeriesPoint point in aggregateSeriesPage.Values)
{
point.GetUniquePropertyNames().Should().HaveCount(1).And.Contain((property) => property == QueryTestsHelper.Temperature);
var value = (double?)point.GetValue(QueryTestsHelper.Temperature);
if (value != null)
{
nonNullFound = true;
}
}
nonNullFound.Should().BeTrue();
}
queryAggregateSeriesPages.Progress.Should().Be(100);
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Add an interpolated variable
var linearInterpolationNumericVariable = new NumericVariable(
new TimeSeriesExpression($"$event.{QueryTestsHelper.Temperature}"),
new TimeSeriesExpression("left($value)"));
linearInterpolationNumericVariable.Interpolation = new TimeSeriesInterpolation
{
Kind = InterpolationKind.Linear,
Boundary = new InterpolationBoundary()
{
Span = TimeSpan.FromSeconds(1),
},
};
const string linearInterpolation = "linearInterpolation";
queryAggregateSeriesRequestOptions.InlineVariables[linearInterpolation] = linearInterpolationNumericVariable;
queryAggregateSeriesRequestOptions.ProjectedVariableNames.Add(linearInterpolation);
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryAggregateSeriesPages = queriesClient.CreateAggregateSeriesQuery(
tsiId,
startTime,
endTime,
TimeSpan.FromSeconds(5),
queryAggregateSeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> aggregateSeriesPage in queryAggregateSeriesPages.GetResultsAsync().AsPages())
{
aggregateSeriesPage.Values.Should().HaveCountGreaterThan(0);
foreach (var point in aggregateSeriesPage.Values)
{
point.GetUniquePropertyNames().Should().HaveCount(2)
.And
.Contain((property) => property == QueryTestsHelper.Temperature)
.And
.Contain((property) => property == linearInterpolation);
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Send 2 events with a special condition that can be used later to query on
IDictionary <string, object> messageBase = QueryTestsHelper.BuildMessageBase(modelSettings.TimeSeriesIdProperties.ToArray(), tsiId);
messageBase[QueryTestsHelper.Temperature] = 1.2;
messageBase[QueryTestsHelper.Humidity] = 3.4;
string messageBody = JsonSerializer.Serialize(messageBase);
var message = new Message(Encoding.ASCII.GetBytes(messageBody))
{
ContentType = "application/json",
ContentEncoding = "utf-8",
};
Func <Task> sendEventAct = async() => await deviceClient.SendEventAsync(message).ConfigureAwait(false);
sendEventAct.Should().NotThrow();
// Send it again
sendEventAct.Should().NotThrow();
// Query for the two events with a filter
queryAggregateSeriesRequestOptions.Filter = new TimeSeriesExpression("$event.Temperature.Double = 1.2");
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryAggregateSeriesPages = queriesClient.CreateAggregateSeriesQuery(
tsiId,
startTime,
endTime,
TimeSpan.FromSeconds(5),
queryAggregateSeriesRequestOptions);
var valueFound = false;
await foreach (TimeSeriesPoint point in queryAggregateSeriesPages.GetResultsAsync())
{
point.GetUniquePropertyNames().Should().HaveCount(2)
.And
.Contain((property) => property == QueryTestsHelper.Temperature)
.And
.Contain((property) => property == linearInterpolation);
var value = (double?)point.GetValue(QueryTestsHelper.Temperature);
if (value == 1.2)
{
valueFound = true;
}
}
valueFound.Should().BeTrue();
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
deviceClient?.Dispose();
}
}
public async Task TimeSeriesInsightsQuery_AggregateSeriesWithCategoricalVariable()
{
// Arrange
TimeSeriesInsightsClient tsiClient = GetClient();
TimeSeriesInsightsModelSettings timeSeriesInsightsModelSettings = tsiClient.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = tsiClient.GetInstancesClient();
TimeSeriesInsightsQueries queriesClient = tsiClient.GetQueriesClient();
DeviceClient deviceClient = await GetDeviceClient().ConfigureAwait(false);
// Figure out what the Time Series Id is composed of
TimeSeriesModelSettings modelSettings = await timeSeriesInsightsModelSettings.GetAsync().ConfigureAwait(false);
// Create a Time Series Id where the number of keys that make up the Time Series Id is fetched from Model Settings
TimeSeriesId tsiId = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, modelSettings.TimeSeriesIdProperties.Count)
.ConfigureAwait(false);
try
{
// Send some events to the IoT hub with with a second between each event
await QueryTestsHelper.SendEventsToHubAsync(
deviceClient,
tsiId,
modelSettings.TimeSeriesIdProperties.ToArray(),
30)
.ConfigureAwait(false);
DateTimeOffset now = Recording.UtcNow;
DateTimeOffset endTime = now.AddMinutes(10);
DateTimeOffset startTime = now.AddMinutes(-10);
var queryAggregateSeriesRequestOptions = new QueryAggregateSeriesRequestOptions();
var categoricalVariable = new CategoricalVariable(
new TimeSeriesExpression($"tolong($event.{QueryTestsHelper.Temperature}.Double)"),
new TimeSeriesDefaultCategory("N/A"));
categoricalVariable.Categories.Add(new TimeSeriesAggregateCategory("good", new List <object> {
1
}));
queryAggregateSeriesRequestOptions.InlineVariables["categorical"] = categoricalVariable;
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryAggregateSeriesPages = queriesClient.CreateAggregateSeriesQuery(
tsiId,
startTime,
endTime,
TimeSpan.FromSeconds(5),
queryAggregateSeriesRequestOptions);
await foreach (TimeSeriesPoint point in queryAggregateSeriesPages.GetResultsAsync())
{
point.GetUniquePropertyNames().Should().HaveCount(3)
.And
.Contain((property) => property == "categorical[good]")
.And
.Contain((property) => property == "categorical[N/A]");
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
deviceClient?.Dispose();
}
}
public async Task TimeSeriesInsightsQuery_AggregateSeriesWithAggregateVariable()
{
// Arrange
TimeSeriesInsightsClient tsiClient = GetClient();
TimeSeriesInsightsModelSettings timeSeriesModelSettings = tsiClient.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = tsiClient.GetInstancesClient();
TimeSeriesInsightsQueries queriesClient = tsiClient.GetQueriesClient();
DeviceClient deviceClient = await GetDeviceClient().ConfigureAwait(false);
// Figure out what the Time Series Id is composed of
TimeSeriesModelSettings modelSettings = await timeSeriesModelSettings.GetAsync().ConfigureAwait(false);
// Create a Time Series Id where the number of keys that make up the Time Series Id is fetched from Model Settings
TimeSeriesId tsiId = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, modelSettings.TimeSeriesIdProperties.Count)
.ConfigureAwait(false);
try
{
// Send some events to the IoT hub with with a second between each event
await QueryTestsHelper.SendEventsToHubAsync(
deviceClient,
tsiId,
modelSettings.TimeSeriesIdProperties.ToArray(),
30)
.ConfigureAwait(false);
// Query for temperature events with two calculateions. First with the temperature value as is, and the second
// with the temperature value multiplied by 2.
DateTimeOffset now = Recording.UtcNow;
DateTimeOffset endTime = now.AddMinutes(10);
DateTimeOffset startTime = now.AddMinutes(-10);
var aggregateVariable = new AggregateVariable(
new TimeSeriesExpression("count()"));
var queryAggregateSeriesRequestOptions = new QueryAggregateSeriesRequestOptions();
queryAggregateSeriesRequestOptions.InlineVariables["Count"] = aggregateVariable;
queryAggregateSeriesRequestOptions.ProjectedVariableNames.Add("Count");
// This retry logic was added as the TSI instance are not immediately available after creation
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryAggregateSeriesPages = queriesClient.CreateAggregateSeriesQuery(
tsiId,
startTime,
endTime,
TimeSpan.FromSeconds(5),
queryAggregateSeriesRequestOptions);
long?totalCount = 0;
await foreach (TimeSeriesPoint point in queryAggregateSeriesPages.GetResultsAsync())
{
var currentCount = (long?)point.GetValue("Count");
totalCount += currentCount;
}
totalCount.Should().Be(30);
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
deviceClient?.Dispose();
}
}
/// <summary>
/// This sample demonstrates usage of Time Series Insights types APIs.
/// </summary>
public async Task RunSamplesAsync(TimeSeriesInsightsClient 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("TIME SERIES INSIGHTS TYPES SAMPLE");
#region Snippet:TimeSeriesInsightsSampleCreateType
TimeSeriesInsightsTypes typesClient = client.GetTypesClient();
// Create a type with an aggregate variable
var timeSeriesTypes = new List <TimeSeriesType>();
var countExpression = new TimeSeriesExpression("count()");
var aggregateVariable = new AggregateVariable(countExpression);
var variables = new Dictionary <string, TimeSeriesVariable>();
variables.Add("aggregateVariable", aggregateVariable);
timeSeriesTypes.Add(new TimeSeriesType("Type1", variables)
{
Id = "Type1Id"
});
timeSeriesTypes.Add(new TimeSeriesType("Type2", variables)
{
Id = "Type2Id"
});
Response <TimeSeriesTypeOperationResult[]> createTypesResult = await typesClient
.CreateOrReplaceAsync(timeSeriesTypes);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter array in the request.
// If the error object is set to null, this means the operation was a success.
for (int i = 0; i < createTypesResult.Value.Length; i++)
{
if (createTypesResult.Value[i].Error == null)
{
Console.WriteLine($"Created Time Series type successfully.");
}
else
{
Console.WriteLine($"Failed to create a Time Series Insights type: {createTypesResult.Value[i].Error.Message}.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleCreateType
#region Snippet:TimeSeriesInsightsSampleGetTypeById
// Code snippet below shows getting a default Type using Id
// The default type Id can be obtained programmatically by using the ModelSettings client.
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesModelSettings modelSettings = await modelSettingsClient.GetAsync();
Response <TimeSeriesTypeOperationResult[]> getTypeByIdResults = await typesClient
.GetByIdAsync(new string[] { modelSettings.DefaultTypeId });
// The response of calling the API contains a list of type or error objects corresponding by position to the input parameter array in the request.
// If the error object is set to null, this means the operation was a success.
for (int i = 0; i < getTypeByIdResults.Value.Length; i++)
{
if (getTypeByIdResults.Value[i].Error == null)
{
Console.WriteLine($"Retrieved Time Series type with Id: '{getTypeByIdResults.Value[i].TimeSeriesType.Id}'.");
}
else
{
Console.WriteLine($"Failed to retrieve a Time Series type due to '{getTypeByIdResults.Value[i].Error.Message}'.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleGetTypeById
#region Snippet:TimeSeriesInsightsSampleReplaceType
// Update variables with adding a new variable
foreach (TimeSeriesType type in timeSeriesTypes)
{
type.Description = "Description";
}
Response <TimeSeriesTypeOperationResult[]> updateTypesResult = await typesClient
.CreateOrReplaceAsync(timeSeriesTypes);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter array in the request.
// If the error object is set to null, this means the operation was a success.
for (int i = 0; i < updateTypesResult.Value.Length; i++)
{
if (updateTypesResult.Value[i].Error == null)
{
Console.WriteLine($"Updated Time Series type successfully.");
}
else
{
Console.WriteLine($"Failed to update a Time Series Insights type due to: {updateTypesResult.Value[i].Error.Message}.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleReplaceType
#region Snippet:TimeSeriesInsightsSampleGetAllTypes
// Get all Time Series types in the environment
AsyncPageable <TimeSeriesType> getAllTypesResponse = typesClient.GetTypesAsync();
await foreach (TimeSeriesType tsiType in getAllTypesResponse)
{
Console.WriteLine($"Retrieved Time Series Insights type with Id: '{tsiType?.Id}' and Name: '{tsiType?.Name}'");
}
#endregion Snippet:TimeSeriesInsightsSampleGetAllTypes
// Clean up
try
{
#region Snippet:TimeSeriesInsightsSampleDeleteTypeById
// Delete Time Series types with Ids
var typesIdsToDelete = new List <string> {
"Type1Id", " Type2Id"
};
Response <TimeSeriesOperationError[]> deleteTypesResponse = await typesClient
.DeleteByIdAsync(typesIdsToDelete);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter
// array in the request. If the error object is set to null, this means the operation was a success.
foreach (var result in deleteTypesResponse.Value)
{
if (result != null)
{
Console.WriteLine($"Failed to delete a Time Series Insights type: {result.Message}.");
}
else
{
Console.WriteLine($"Deleted a Time Series Insights type successfully.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleDeleteTypeById
}
catch (Exception ex)
{
Console.WriteLine($"Failed to delete Time Series Insights type: {ex.Message}");
}
}
public async Task TimeSeriesInsightsQuery_GetEventsLifecycle()
{
// Arrange
TimeSeriesInsightsClient tsiClient = GetClient();
TimeSeriesInsightsModelSettings timeSeriesModelSettings = tsiClient.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = tsiClient.GetInstancesClient();
TimeSeriesInsightsQueries queriesClient = tsiClient.GetQueriesClient();
DeviceClient deviceClient = await GetDeviceClient().ConfigureAwait(false);
// Figure out what the Time Series Id is composed of
TimeSeriesModelSettings modelSettings = await timeSeriesModelSettings.GetAsync().ConfigureAwait(false);
// Create a Time Series Id where the number of keys that make up the Time Series Id is fetched from Model Settings
TimeSeriesId tsiId = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, modelSettings.TimeSeriesIdProperties.Count)
.ConfigureAwait(false);
try
{
var initialEventsCount = 50;
// Send some events to the IoT hub
await QueryTestsHelper.SendEventsToHubAsync(
deviceClient,
tsiId,
modelSettings.TimeSeriesIdProperties.ToArray(),
initialEventsCount)
.ConfigureAwait(false);
// Act
// Get events from last 10 minute
DateTimeOffset now = Recording.UtcNow;
DateTimeOffset endTime = now.AddMinutes(10);
DateTimeOffset startTime = now.AddMinutes(-10);
// This retry logic was added as the TSI instance are not immediately available after creation
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryEventsPages = queriesClient.CreateEventsQuery(tsiId, startTime, endTime);
var count = 0;
await foreach (TimeSeriesPoint timeSeriesPoint in queryEventsPages.GetResultsAsync())
{
count++;
timeSeriesPoint.Timestamp.Should().BeAfter(startTime).And.BeBefore(endTime);
var temperatureValue = timeSeriesPoint.GetNullableDouble(QueryTestsHelper.Temperature);
temperatureValue.Should().NotBeNull();
var humidityValue = (double?)timeSeriesPoint.GetValue(QueryTestsHelper.Humidity);
humidityValue.Should().NotBeNull();
}
count.Should().Be(initialEventsCount);
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Send 2 events with a special condition that can be used later to query on
IDictionary <string, object> messageBase = QueryTestsHelper.BuildMessageBase(
modelSettings.TimeSeriesIdProperties.ToArray(),
tsiId);
messageBase[QueryTestsHelper.Temperature] = 1.2;
messageBase[QueryTestsHelper.Humidity] = 3.4;
string messageBody = JsonSerializer.Serialize(messageBase);
var message = new Message(Encoding.ASCII.GetBytes(messageBody))
{
ContentType = "application/json",
ContentEncoding = "utf-8",
};
Func <Task> sendEventAct = async() => await deviceClient.SendEventAsync(message).ConfigureAwait(false);
await sendEventAct.Should().NotThrowAsync();
// Send it again
sendEventAct.Should().NotThrow();
// Query for the two events with a filter
// Only project Temperature and one of the Id properties
var queryRequestOptions = new QueryEventsRequestOptions
{
Filter = new TimeSeriesExpression("$event.Temperature.Double = 1.2"),
Store = StoreType.WarmStore,
};
queryRequestOptions.ProjectedProperties.Add(
new TimeSeriesInsightsEventProperty
{
Name = QueryTestsHelper.Temperature,
PropertyValueType = "Double",
});
queryRequestOptions.ProjectedProperties.Add(
new TimeSeriesInsightsEventProperty
{
Name = modelSettings.TimeSeriesIdProperties.First().Name,
PropertyValueType = modelSettings.TimeSeriesIdProperties.First().PropertyType.ToString(),
});
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer queryEventsPages = queriesClient.CreateEventsQuery(tsiId, startTime, endTime, queryRequestOptions);
await foreach (Page <TimeSeriesPoint> page in queryEventsPages.GetResultsAsync().AsPages())
{
page.Values.Should().HaveCount(2);
foreach (TimeSeriesPoint point in page.Values)
{
var value = (double?)point.GetValue(QueryTestsHelper.Temperature);
value.Should().Be(1.2);
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Query for the two events with a filter, but only take 1
queryRequestOptions.MaxNumberOfEvents = 1;
TimeSeriesQueryAnalyzer queryEventsPagesWithFilter = queriesClient.CreateEventsQuery(tsiId, startTime, endTime, queryRequestOptions);
await foreach (Page <TimeSeriesPoint> page in queryEventsPagesWithFilter.GetResultsAsync().AsPages())
{
page.Values.Should().HaveCount(1);
}
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
// Query for all the events using a timespan
TimeSeriesQueryAnalyzer queryEventsPagesWithTimespan = queriesClient
.CreateEventsQuery(tsiId, TimeSpan.FromMinutes(20), endTime);
await foreach (Page <TimeSeriesPoint> page in queryEventsPagesWithTimespan.GetResultsAsync().AsPages())
{
page.Values.Should().HaveCount(52);
foreach (TimeSeriesPoint point in page.Values)
{
point.Timestamp.Should().BeAfter(startTime).And.BeBefore(endTime);
var temperatureValue = (double?)point.GetValue(QueryTestsHelper.Temperature);
temperatureValue.Should().NotBeNull();
var humidityValue = (double?)point.GetValue(QueryTestsHelper.Humidity);
humidityValue.Should().NotBeNull();
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
deviceClient?.Dispose();
}
}
public async Task TimeSeriesInsightsQuery_GetSeriesLifecycle()
{
// Arrange
TimeSeriesInsightsClient tsiClient = GetClient();
TimeSeriesInsightsModelSettings timeSeriesModelSettings = tsiClient.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = tsiClient.GetInstancesClient();
TimeSeriesInsightsQueries queriesClient = tsiClient.GetQueriesClient();
DeviceClient deviceClient = await GetDeviceClient().ConfigureAwait(false);
// Figure out what the Time Series Id is composed of
TimeSeriesModelSettings modelSettings = await timeSeriesModelSettings.GetAsync().ConfigureAwait(false);
// Create a Time Series Id where the number of keys that make up the Time Series Id is fetched from Model Settings
TimeSeriesId tsiId = await GetUniqueTimeSeriesInstanceIdAsync(instancesClient, modelSettings.TimeSeriesIdProperties.Count)
.ConfigureAwait(false);
try
{
// Send some events to the IoT hub
await QueryTestsHelper.SendEventsToHubAsync(
deviceClient,
tsiId,
modelSettings.TimeSeriesIdProperties.ToArray(),
10)
.ConfigureAwait(false);
// Act
// Query for temperature events with two calculations. First with the temperature value as is, and the second
// with the temperature value multiplied by 2.
DateTimeOffset now = Recording.UtcNow;
DateTimeOffset endTime = now.AddMinutes(10);
DateTimeOffset startTime = now.AddMinutes(-10);
var temperatureNumericVariable = new NumericVariable(
new TimeSeriesExpression($"$event.{QueryTestsHelper.Temperature}"),
new TimeSeriesExpression("avg($value)"));
var temperatureNumericVariableTimesTwo = new NumericVariable(
new TimeSeriesExpression($"$event.{QueryTestsHelper.Temperature} * 2"),
new TimeSeriesExpression("avg($value)"));
var temperatureTimesTwoVariableName = $"{QueryTestsHelper.Temperature}TimesTwo";
var querySeriesRequestOptions = new QuerySeriesRequestOptions();
querySeriesRequestOptions.InlineVariables[QueryTestsHelper.Temperature] = temperatureNumericVariable;
querySeriesRequestOptions.InlineVariables[temperatureTimesTwoVariableName] = temperatureNumericVariableTimesTwo;
// This retry logic was added as the TSI instance are not immediately available after creation
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer querySeriesEventsPages = queriesClient.CreateSeriesQuery(
tsiId,
startTime,
endTime,
querySeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> seriesEventsPage in querySeriesEventsPages.GetResultsAsync().AsPages())
{
seriesEventsPage.Values.Should().HaveCount(10);
for (int index = 0; index < seriesEventsPage.Values.Count; index++)
{
TimeSeriesPoint point = seriesEventsPage.Values[index];
point.Timestamp.Should().BeAfter(startTime).And.BeBefore(endTime);
point.GetUniquePropertyNames().Should().HaveCount(3);
point.GetUniquePropertyNames().Should().Contain((property) => property == QueryTestsHelper.Temperature)
.And
.Contain((property) => property == temperatureTimesTwoVariableName);
// Assert that the values for the Temperature property is equal to the values for the other property, multiplied by 2
var temperatureTimesTwoValue = (double?)point.GetValue(temperatureTimesTwoVariableName);
var temperatureValue = (double?)point.GetValue(QueryTestsHelper.Temperature);
temperatureTimesTwoValue.Should().Be(temperatureValue * 2);
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Query for all the series events using a timespan
TimeSeriesQueryAnalyzer querySeriesEventsPagesWithTimespan = queriesClient
.CreateSeriesQuery(tsiId, TimeSpan.FromMinutes(10), null, querySeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> seriesEventsPage in querySeriesEventsPagesWithTimespan.GetResultsAsync().AsPages())
{
seriesEventsPage.Values.Should().HaveCount(10);
foreach (TimeSeriesPoint point in seriesEventsPage.Values)
{
point.GetUniquePropertyNames().Should().HaveCount(3);
}
}
// Query for temperature and humidity
var humidityNumericVariable = new NumericVariable(
new TimeSeriesExpression("$event.Humidity"),
new TimeSeriesExpression("avg($value)"));
querySeriesRequestOptions.InlineVariables[QueryTestsHelper.Humidity] = humidityNumericVariable;
querySeriesRequestOptions.ProjectedVariableNames.Add(QueryTestsHelper.Temperature);
querySeriesRequestOptions.ProjectedVariableNames.Add(QueryTestsHelper.Humidity);
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer querySeriesEventsPages = queriesClient.CreateSeriesQuery(tsiId, startTime, endTime, querySeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> seriesEventsPage in querySeriesEventsPages.GetResultsAsync().AsPages())
{
seriesEventsPage.Values.Should().HaveCount(10);
foreach (TimeSeriesPoint point in seriesEventsPage.Values)
{
point.Timestamp.Should().BeAfter(startTime).And.BeBefore(endTime);
point.GetUniquePropertyNames().Should().HaveCount(2)
.And
.Contain((property) => property == QueryTestsHelper.Temperature)
.And
.Contain((property) => property == QueryTestsHelper.Humidity);
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Send 2 events with a special condition that can be used later to query on
IDictionary <string, object> messageBase = QueryTestsHelper.BuildMessageBase(modelSettings.TimeSeriesIdProperties.ToArray(), tsiId);
messageBase[QueryTestsHelper.Temperature] = 1.2;
messageBase[QueryTestsHelper.Humidity] = 3.4;
string messageBody = JsonSerializer.Serialize(messageBase);
var message = new Message(Encoding.ASCII.GetBytes(messageBody))
{
ContentType = "application/json",
ContentEncoding = "utf-8",
};
Func <Task> sendEventAct = async() => await deviceClient.SendEventAsync(message).ConfigureAwait(false);
sendEventAct.Should().NotThrow();
// Send it again
sendEventAct.Should().NotThrow();
// Query for the two events with a filter
querySeriesRequestOptions.Filter = new TimeSeriesExpression("$event.Temperature.Double = 1.2");
await TestRetryHelper.RetryAsync <AsyncPageable <TimeSeriesPoint> >(async() =>
{
TimeSeriesQueryAnalyzer querySeriesEventsPages = queriesClient.CreateSeriesQuery(tsiId, startTime, endTime, querySeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> seriesEventsPage in querySeriesEventsPages.GetResultsAsync().AsPages())
{
seriesEventsPage.Values.Should().HaveCount(2);
foreach (TimeSeriesPoint point in seriesEventsPage.Values)
{
point.GetUniquePropertyNames().Should().HaveCount(2);
var temperatureValue = (double?)point.GetValue(QueryTestsHelper.Temperature);
temperatureValue.Should().Be(1.2);
}
}
return(null);
}, MaxNumberOfRetries, s_retryDelay);
// Query for the two events with a filter, but only take 1
querySeriesRequestOptions.MaxNumberOfEvents = 1;
TimeSeriesQueryAnalyzer querySeriesEventsPagesWithFilter = queriesClient.CreateSeriesQuery(tsiId, startTime, endTime, querySeriesRequestOptions);
await foreach (Page <TimeSeriesPoint> seriesEventsPage in querySeriesEventsPagesWithFilter.GetResultsAsync().AsPages())
{
seriesEventsPage.Values.Should().HaveCount(1);
}
}
finally
{
deviceClient?.Dispose();
}
}
public async Task TimeSeriesId_CreateInstanceWith3Keys()
{
// Arrange
TimeSeriesInsightsClient client = GetClient();
TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient();
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
Response <TimeSeriesModelSettings> currentSettings = await modelSettingsClient.GetAsync().ConfigureAwait(false);
int numOfIdKeys = currentSettings.Value.TimeSeriesIdProperties.Count;
// Create a Time Series Id with first key being null.
TimeSeriesId idWithNull = numOfIdKeys switch
{
1 => new TimeSeriesId(null),
2 => new TimeSeriesId(null, Recording.GenerateAlphaNumericId(string.Empty, 5)),
3 => new TimeSeriesId(null, Recording.GenerateAlphaNumericId(string.Empty, 5), Recording.GenerateAlphaNumericId(string.Empty, 5)),
_ => throw new Exception($"Invalid number of Time Series Insights Id properties."),
};
var timeSeriesInstances = new List <TimeSeriesInstance>
{
new TimeSeriesInstance(idWithNull, DefaultType),
};
// Act and assert
try
{
// Create TSI instances
Response <TimeSeriesOperationError[]> createInstancesResult = await instancesClient
.CreateOrReplaceAsync(timeSeriesInstances)
.ConfigureAwait(false);
// Assert that the result error array does not contain any object that is set
createInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult == null);
// This retry logic was added as the TSI instance are not immediately available after creation
await TestRetryHelper.RetryAsync <Response <InstancesOperationResult[]> >(async() =>
{
// Get the instance with a null item in its Id
Response <InstancesOperationResult[]> getInstanceWithNullInId = await instancesClient
.GetByIdAsync(new List <TimeSeriesId> {
idWithNull
})
.ConfigureAwait(false);
getInstanceWithNullInId.Value.Length.Should().Be(1);
InstancesOperationResult resultItem = getInstanceWithNullInId.Value.First();
resultItem.Instance.Should().NotBeNull();
resultItem.Instance.TimeSeriesId.ToStringArray().Length.Should().Be(numOfIdKeys);
resultItem.Instance.TimeSeriesId.ToStringArray()[0].Should().BeNull();
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
// clean up
try
{
Response <TimeSeriesOperationError[]> deleteInstancesResponse = await instancesClient
.DeleteByIdAsync(timeSeriesInstances.Select((instance) => instance.TimeSeriesId))
.ConfigureAwait(false);
// Assert that the response array does not have any error object set
deleteInstancesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null);
}
catch (Exception ex)
{
Console.WriteLine($"Test clean up failed: {ex.Message}");
throw;
}
}
}
/// <summary>
/// Creates a Time Series Insights instance
/// Gets all instances for the environment
/// Gets a specific instance by Id
/// Replaces an instance
/// Deletes an instance.
/// </summary>
public async Task RunSamplesAsync(TimeSeriesInsightsClient client)
{
PrintHeader("TIME SERIES INSIGHTS INSTANCES SAMPLE");
// Figure out what keys make up the Time Series Id
TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient();
TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient();
TimeSeriesModelSettings modelSettings = await modelSettingsClient.GetAsync();
TimeSeriesId tsId = TimeSeriesIdHelper.CreateTimeSeriesId(modelSettings);
string defaultTypeId = modelSettings.DefaultTypeId;
#region Snippet:TimeSeriesInsightsSampleCreateInstance
// Create a Time Series Instance object with the default Time Series Insights type Id.
// The default type Id can be obtained programmatically by using the ModelSettings client.
// tsId is created above using `TimeSeriesIdHelper.CreateTimeSeriesId`.
var instance = new TimeSeriesInstance(tsId, defaultTypeId)
{
Name = "instance1",
};
var tsiInstancesToCreate = new List <TimeSeriesInstance>
{
instance,
};
Response <TimeSeriesOperationError[]> createInstanceErrors = await instancesClient
.CreateOrReplaceAsync(tsiInstancesToCreate);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter
// array in the request. If the error object is set to null, this means the operation was a success.
for (int i = 0; i < createInstanceErrors.Value.Length; i++)
{
TimeSeriesId tsiId = tsiInstancesToCreate[i].TimeSeriesId;
if (createInstanceErrors.Value[i] == null)
{
Console.WriteLine($"Created Time Series Insights instance with Id '{tsiId}'.");
}
else
{
Console.WriteLine($"Failed to create a Time Series Insights instance with Id '{tsiId}', " +
$"Error Message: '{createInstanceErrors.Value[i].Message}, " +
$"Error code: '{createInstanceErrors.Value[i].Code}'.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleCreateInstance
#region Snippet:TimeSeriesInsightsGetAllInstances
// Get all instances for the Time Series Insights environment
AsyncPageable <TimeSeriesInstance> tsiInstances = instancesClient.GetAsync();
await foreach (TimeSeriesInstance tsiInstance in tsiInstances)
{
Console.WriteLine($"Retrieved Time Series Insights instance with Id '{tsiInstance.TimeSeriesId}' and name '{tsiInstance.Name}'.");
}
#endregion Snippet:TimeSeriesInsightsGetAllInstances
#region Snippet:TimeSeriesInsightsReplaceInstance
// Get Time Series Insights instances by Id
// tsId is created above using `TimeSeriesIdHelper.CreateTimeSeriesId`.
var instanceIdsToGet = new List <TimeSeriesId>
{
tsId,
};
Response <InstancesOperationResult[]> getInstancesByIdResult = await instancesClient.GetAsync(instanceIdsToGet);
TimeSeriesInstance instanceResult = getInstancesByIdResult.Value[0].Instance;
Console.WriteLine($"Retrieved Time Series Insights instance with Id '{instanceResult.TimeSeriesId}' and name '{instanceResult.Name}'.");
// Now let's replace the instance with an updated name
instanceResult.Name = "newInstanceName";
var instancesToReplace = new List <TimeSeriesInstance>
{
instanceResult,
};
Response <InstancesOperationResult[]> replaceInstancesResult = await instancesClient.ReplaceAsync(instancesToReplace);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter.
// array in the request. If the error object is set to null, this means the operation was a success.
for (int i = 0; i < replaceInstancesResult.Value.Length; i++)
{
TimeSeriesId tsiId = instancesToReplace[i].TimeSeriesId;
TimeSeriesOperationError currentError = replaceInstancesResult.Value[i].Error;
if (currentError != null)
{
Console.WriteLine($"Failed to replace Time Series Insights instance with Id '{tsiId}'," +
$" Error Message: '{currentError.Message}', Error code: '{currentError.Code}'.");
}
else
{
Console.WriteLine($"Replaced Time Series Insights instance with Id '{tsiId}'.");
}
}
#endregion Snippet:TimeSeriesInsightsReplaceInstance
#region Snippet:TimeSeriesInsightsGetnstancesById
// Get Time Series Insights instances by Id
// tsId is created above using `TimeSeriesIdHelper.CreateTimeSeriesId`.
var timeSeriesIds = new List <TimeSeriesId>
{
tsId,
};
Response <InstancesOperationResult[]> getByIdsResult = await instancesClient.GetAsync(timeSeriesIds);
// The response of calling the API contains a list of instance or error objects corresponding by position to the array in the request.
// Instance object is set when operation is successful and error object is set when operation is unsuccessful.
for (int i = 0; i < getByIdsResult.Value.Length; i++)
{
InstancesOperationResult currentOperationResult = getByIdsResult.Value[i];
if (currentOperationResult.Instance != null)
{
Console.WriteLine($"Retrieved Time Series Insights instance with Id '{currentOperationResult.Instance.TimeSeriesId}' and name '{currentOperationResult.Instance.Name}'.");
}
else if (currentOperationResult.Error != null)
{
Console.WriteLine($"Failed to retrieve a Time Series Insights instance with Id '{timeSeriesIds[i]}'. Error message: '{currentOperationResult.Error.Message}'.");
}
}
#endregion Snippet:TimeSeriesInsightsGetnstancesById
// Clean up
try
{
#region Snippet:TimeSeriesInsightsSampleDeleteInstanceById
// tsId is created above using `TimeSeriesIdHelper.CreateTimeSeriesId`.
var instancesToDelete = new List <TimeSeriesId>
{
tsId,
};
Response <TimeSeriesOperationError[]> deleteInstanceErrors = await instancesClient
.DeleteAsync(instancesToDelete);
// The response of calling the API contains a list of error objects corresponding by position to the input parameter
// array in the request. If the error object is set to null, this means the operation was a success.
for (int i = 0; i < deleteInstanceErrors.Value.Length; i++)
{
TimeSeriesId tsiId = instancesToDelete[i];
if (deleteInstanceErrors.Value[i] == null)
{
Console.WriteLine($"Deleted Time Series Insights instance with Id '{tsiId}'.");
}
else
{
Console.WriteLine($"Failed to delete a Time Series Insights instance with Id '{tsiId}'. Error Message: '{deleteInstanceErrors.Value[i].Message}'");
}
}
#endregion Snippet:TimeSeriesInsightsSampleDeleteInstanceById
}
catch (Exception ex)
{
Console.WriteLine($"Failed to delete Time Series Insights instance: {ex.Message}");
}
}
