protected async Task <TimeSeriesId> GetUniqueTimeSeriesInstanceIdAsync(TimeSeriesInsightsInstances instancesClient, int numOfIdKeys)
{
numOfIdKeys.Should().BeInRange(1, 3);
for (int tryNumber = 0; tryNumber < MaxTries; ++tryNumber)
{
var id = new List <string>();
for (int i = 0; i < numOfIdKeys; i++)
{
id.Add(Recording.GenerateAlphaNumericId(string.Empty));
}
TimeSeriesId tsId = numOfIdKeys switch
{
1 => new TimeSeriesId(id[0]),
2 => new TimeSeriesId(id[0], id[1]),
3 => new TimeSeriesId(id[0], id[1], id[2]),
_ => throw new Exception($"Invalid number of Time Series Insights Id properties."),
};
Response <InstancesOperationResult[]> getInstancesResult = await instancesClient
.GetAsync(new List <TimeSeriesId> {
tsId
})
.ConfigureAwait(false);
if (getInstancesResult.Value?.First()?.Error != null)
{
return(tsId);
}
}
throw new Exception($"Unique Id could not be found");
}
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;
}
}
}
private async Task RunQuerySeriesSampleWithPreDefinedVariables(TimeSeriesInsightsClient client, TimeSeriesId tsId)
{
// Setup
TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient();
TimeSeriesInsightsTypes typesClient = client.GetTypesClient();
TimeSeriesInsightsQueries queriesClient = client.GetQueriesClient();
// First create the Time Series type along with the numeric variables
var timeSeriesTypes = new List <TimeSeriesType>();
var celsiusVariable = new NumericVariable(
new TimeSeriesExpression("$event.Temperature"),
new TimeSeriesExpression("avg($value)"));
var fahrenheitVariable = new NumericVariable(
new TimeSeriesExpression("$event.Temperature * 1.8 + 32"),
new TimeSeriesExpression("avg($value)"));
var celsiusVariableName = "TemperatureInCelsius";
var fahrenheitVariableName = "TemperatureInFahrenheit";
var variables = new Dictionary <string, TimeSeriesVariable>
{
{ celsiusVariableName, celsiusVariable },
{ fahrenheitVariableName, fahrenheitVariable }
};
timeSeriesTypes.Add(new TimeSeriesType("TemperatureSensor", variables)
{
Id = "TemperatureSensorTypeId"
});
Response <TimeSeriesTypeOperationResult[]> createTypesResult = await typesClient
.CreateOrReplaceAsync(timeSeriesTypes)
.ConfigureAwait(false);
if (createTypesResult.Value.First().Error != null)
{
Console.WriteLine($"\n\nFailed to create a Time Series Insights type. " +
$"Error Message: '{createTypesResult.Value.First().Error.Message}.' " +
$"Code: '{createTypesResult.Value.First().Error.Code}'.");
}
// Get the Time Series instance and replace its type with the one we just created
Response <InstancesOperationResult[]> getInstanceResult = await instancesClient
.GetAsync(new List <TimeSeriesId> {
tsId
});
if (getInstanceResult.Value.First().Error != null)
{
Console.WriteLine($"\n\nFailed to retrieve Time Series instance with Id '{tsId}'. " +
$"Error Message: '{getInstanceResult.Value.First().Error.Message}.' " +
$"Code: '{getInstanceResult.Value.First().Error.Code}'.");
}
TimeSeriesInstance instanceToReplace = getInstanceResult.Value.First().Instance;
instanceToReplace.TypeId = createTypesResult.Value.First().TimeSeriesType.Id;
Response <InstancesOperationResult[]> replaceInstanceResult = await instancesClient
.ReplaceAsync(new List <TimeSeriesInstance> {
instanceToReplace
});
if (replaceInstanceResult.Value.First().Error != null)
{
Console.WriteLine($"\n\nFailed to retrieve Time Series instance with Id '{tsId}'. " +
$"Error Message: '{replaceInstanceResult.Value.First().Error.Message}.' " +
$"Code: '{replaceInstanceResult.Value.First().Error.Code}'.");
}
// Now that we set up the instance with the property type, query for the data
#region Snippet:TimeSeriesInsightsSampleQuerySeries
Console.WriteLine($"\n\nQuery for temperature series in Celsius and Fahrenheit over the past 10 minutes. " +
$"The Time Series instance belongs to a type that has predefined numeric variable that represents the temperature " +
$"in Celsuis, and a predefined numeric variable that represents the temperature in Fahrenheit.\n");
DateTimeOffset endTime = DateTime.UtcNow;
DateTimeOffset startTime = endTime.AddMinutes(-10);
QueryAnalyzer seriesQuery = queriesClient.CreateSeriesQuery(
tsId,
startTime,
endTime);
await foreach (TimeSeriesPoint point in seriesQuery.GetResultsAsync())
{
double?tempInCelsius = point.GetNullableDouble(celsiusVariableName);
double?tempInFahrenheit = point.GetNullableDouble(fahrenheitVariableName);
Console.WriteLine($"{point.Timestamp} - Average temperature in Celsius: {tempInCelsius}. " +
$"Average temperature in Fahrenheit: {tempInFahrenheit}.");
}
#endregion Snippet:TimeSeriesInsightsSampleQuerySeries
}
public async Task TimeSeriesId_CreateInstanceWith3Keys()
{
// Arrange
TimeSeriesInsightsClient client = GetClient();
TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient();
// Create a Time Series Id with 3 keys. Middle key is a null
var idWithNull = new TimeSeriesId(
Recording.GenerateAlphaNumericId(string.Empty, 5),
null,
Recording.GenerateAlphaNumericId(string.Empty, 5));
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
.GetAsync(new List <TimeSeriesId> {
idWithNull
})
.ConfigureAwait(false);
getInstanceWithNullInId.Value.Length.Should().Be(1);
InstancesOperationResult resultItem = getInstanceWithNullInId.Value.First();
resultItem.Instance.Should().NotBeNull();
resultItem.Instance.TimeSeriesId.ToArray().Length.Should().Be(3);
resultItem.Instance.TimeSeriesId.ToArray()[1].Should().BeNull();
return(null);
}, MaxNumberOfRetries, s_retryDelay);
}
finally
{
// clean up
try
{
Response <TimeSeriesOperationError[]> deleteInstancesResponse = await instancesClient
.DeleteAsync(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}");
}
}