public async Task TimeSeriesInsightsTypeWithCategoricalVariable_ExpectsError()
{
// Arrange
TimeSeriesInsightsClient client = GetClient();
var timeSeriesTypes = new List <TimeSeriesType>();
var tsiTypeNamePrefix = "type";
var timeSeriesTypesName = Recording.GenerateAlphaNumericId(tsiTypeNamePrefix);
string timeSeriesTypeId = Recording.GenerateId();
// Build Numeric variable
// Below is an invalid expression
var categoricalValue = new TimeSeriesExpression("$event");
var category = new TimeSeriesDefaultCategory("label");
var categoricalVariable = new CategoricalVariable(categoricalValue, category);
var variables = new Dictionary <string, TimeSeriesVariable>();
var variableNamePrefix = "categoricalVariableName";
variables.Add(Recording.GenerateAlphaNumericId(variableNamePrefix), categoricalVariable);
var type = new TimeSeriesType(timeSeriesTypesName, variables);
type.Id = timeSeriesTypeId;
timeSeriesTypes.Add(type);
// Act and Assert
await TestTimeSeriesTypeWhereErrorIsExpected(client, timeSeriesTypes, timeSeriesTypesName).ConfigureAwait(false);
}
private static async Task <TimeSeriesInsightsClient> GetTimeSeriesInsightsClientAsync(string EnvironmentFqdn)
{
const string ResourceUri = "https://api.timeseries.azure.com/";
const string PowerShellAadClientId = "<clientid>";
const string PowerShellAadClientSecret = "<clientsecret>";
const string AzureActiveDirectoryLoginUrl = "https://login.microsoftonline.com/common";
const string MicrosoftTenantId = "<tenanatid>";
//string hostName = Dns.GetHostName();
//string myIP = Dns.GetHostEntry(hostName).AddressList[0].ToString();
System.Web.HttpContext context1 = System.Web.HttpContext.Current;
string ipAddress = context1.Request.ServerVariables["REMOTE_ADDR"];
ClientCredential ClientCredential = new ClientCredential(PowerShellAadClientId, PowerShellAadClientSecret);
AuthenticationContext context = new AuthenticationContext($"{AzureActiveDirectoryLoginUrl}/{MicrosoftTenantId}", TokenCache.DefaultShared);
AuthenticationResult authenticationResult = await context.AcquireTokenAsync(ResourceUri, ClientCredential);
TokenCloudCredentials tokenCloudCredentials = new TokenCloudCredentials(authenticationResult.AccessToken);
//TokenCloudCredentials tokenCloudCredentials = new TokenCloudCredentials(AccessToken);
var tokenvalue = tokenCloudCredentials.Token;
ServiceClientCredentials serviceClientCredentials = new TokenCredentials(tokenCloudCredentials.Token);
TimeSeriesInsightsClient timeSeriesInsightsClient = new TimeSeriesInsightsClient(credentials: serviceClientCredentials)
{
EnvironmentFqdn = EnvironmentFqdn
};
return(timeSeriesInsightsClient);
}
public async Task TimeSeriesInsightsClient_Construct()
{
TimeSeriesInsightsClient client = GetClient();
Response <Models.ModelSettingsResponse> response = await client.GetAsync().ConfigureAwait(false);
response.GetRawResponse().Status.Should().Be(200);
}
protected async Task <TimeSeriesId> GetUniqueTimeSeriesInstanceIdAsync(TimeSeriesInsightsClient tsiClient, 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 tsiClient
.GetInstancesAsync(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 TimeSeriesInsightsTypeWithNumericVariable_ExpectsError()
{
// Arrange
TimeSeriesInsightsClient client = GetClient();
var timeSeriesTypes = new List <TimeSeriesType>();
var tsiTypeNamePrefix = "type";
var timeSeriesTypesName = Recording.GenerateAlphaNumericId(tsiTypeNamePrefix);
string timeSeriesTypeId = Recording.GenerateId();
// Build Numeric variable
// Below is an invalid expression
var numExpression = new TimeSeriesExpression("$event");
var aggregation = new TimeSeriesExpression("avg($value)");
var numericVariable = new NumericVariable(numExpression, aggregation);
var variables = new Dictionary <string, TimeSeriesVariable>();
var variableNamePrefix = "numericVariableName";
variables.Add(Recording.GenerateAlphaNumericId(variableNamePrefix), numericVariable);
var type = new TimeSeriesType(timeSeriesTypesName, variables)
{
Id = timeSeriesTypeId
};
timeSeriesTypes.Add(type);
// Act and Assert
await TestTimeSeriesTypeWhereErrorIsExpected(client, timeSeriesTypes, timeSeriesTypesName).ConfigureAwait(false);
}
/// <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 client
TimeSeriesInsightsClient tsiClient = GetTimeSeriesInsightsClient(
options.TenantId,
options.ClientId,
options.ClientSecret,
options.TsiEnvironmentFqdn);
// Run the samples
var tsiLifecycleSamples = new TimeSeriesInsightsLifecycleSamples(tsiClient, options.TsiEnvironmentFqdn);
await tsiLifecycleSamples.RunSamplesAsync();
var tsiInstancesSamples = new InstancesSamples();
await tsiInstancesSamples.RunSamplesAsync(tsiClient);
}
private static async Task TestTimeSeriesTypeWhereErrorIsExpected(TimeSeriesInsightsClient client, List <TimeSeriesType> timeSeriesTypes, string timeSeriesTypesName)
{
// create numeric type and expect failure due to invalid input expression
Response <TimeSeriesOperationError[]> createTypesResult = await client
.CreateOrReplaceTimeSeriesTypesAsync(timeSeriesTypes)
.ConfigureAwait(false);
// Assert that the result error array does not contain an error
createTypesResult.Value.Should().OnlyContain((errorResult) => errorResult != null);
// Get the type by name and expect error
var getTypesByNamesResult = await client
.GetTimeSeriesTypesByNamesAsync(new string[] { timeSeriesTypesName })
.ConfigureAwait(false);
getTypesByNamesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error != null);
// Delete the type by name and expect error
Response <TimeSeriesOperationError[]> deleteTypesResponse = await client
.DeleteTimeSeriesTypesByNamesAsync(new string[] { timeSeriesTypesName })
.ConfigureAwait(false);
// Response is null even when type does not exist.
deleteTypesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null);
}
public async Task <QueryResultPage> GetSeries(string EnvironmentFqdn, string TimeSeriesId)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
string continuationToken;
do
{
DateTimeRange SearchSpan = new DateTimeRange(new DateTime(2019, 12, 26).ToUniversalTime(), new DateTime(2019, 12, 27).ToUniversalTime());
//object[] TimeSeriesIdValue = new object[] { "AND-ARU-XI82121_F" };
QueryResultPage queryResponse = await tsi.ExecuteQueryPagedAsync(
new QueryRequest(
getSeries : new GetSeries(
timeSeriesId : new object[] { TimeSeriesId },
searchSpan : SearchSpan,
filter : null,
projectedVariables : new[] { "Float" },
inlineVariables : new Dictionary <string, NumericVariable>()
{
["Float"] = new NumericVariable(
value : new Tsx("$event.series_value"),
aggregation : new Tsx("avg($value)"))
})));
return(queryResponse);
//continuationToken = queryResponse.ContinuationToken;
}while (continuationToken != null);
}
/// <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 <TypesBatchResponse> CreateNewType(string EnvironmentFqdn, IList <TimeSeriesType> value)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result; //all correct
TypesBatchResponse types = await tsi.ExecuteTypesBatchOperationAsync(new TypesBatchRequest(put : value));
return(types);
}
private async Task RunQueryAggregateSeriesSample(TimeSeriesInsightsClient client, TimeSeriesId tsId)
{
#region Snippet:TimeSeriesInsightsSampleQueryAggregateSeriesWithNumericVariable
Console.WriteLine("\n\nQuery for the average temperature over the past 30 seconds, in 2-second time slots.\n");
var numericVariable = new NumericVariable(
new TimeSeriesExpression("$event.Temperature"),
new TimeSeriesExpression("avg($value)"));
var requestOptions = new QueryAggregateSeriesRequestOptions();
requestOptions.InlineVariables["Temperature"] = numericVariable;
requestOptions.ProjectedVariables.Add("Temperature");
QueryAnalyzer queryAggregateSeriesAnalyzer = client.Queries.CreateAggregateSeriesQueryAnalyzer(
tsId,
TimeSpan.FromSeconds(2),
TimeSpan.FromSeconds(30),
null,
requestOptions);
await foreach (TimeSeriesPoint point in queryAggregateSeriesAnalyzer.GetResultsAsync())
{
double?averageTemperature = (double?)point.GetValue("Temperature");
if (averageTemperature != null)
{
Console.WriteLine($"{point.Timestamp} - Average temperature: {averageTemperature}.");
}
}
#endregion Snippet:TimeSeriesInsightsSampleQueryAggregateSeriesWithNumericVariable
#region Snippet:TimeSeriesInsightsSampleQueryAggregateSeriesWithAggregateVariable
Console.WriteLine("\n\nCount the number of temperature events over the past 3 minutes, in 1-minute time slots.\n");
// Get the count of events in 60-second time slots over the past 3 minutes
DateTimeOffset endTime = DateTime.UtcNow;
DateTimeOffset startTime = endTime.AddMinutes(-3);
var aggregateVariable = new AggregateVariable(
new TimeSeriesExpression("count()"));
var countVariableName = "Count";
var aggregateSeriesRequestOptions = new QueryAggregateSeriesRequestOptions();
aggregateSeriesRequestOptions.InlineVariables[countVariableName] = aggregateVariable;
aggregateSeriesRequestOptions.ProjectedVariables.Add(countVariableName);
QueryAnalyzer aggregateSeriesQueryAnalyzer = client.Queries.CreateAggregateSeriesQueryAnalyzer(
tsId,
startTime,
endTime,
TimeSpan.FromSeconds(60),
aggregateSeriesRequestOptions);
await foreach (TimeSeriesPoint point in aggregateSeriesQueryAnalyzer.GetResultsAsync())
{
long?temperatureCount = (long?)point.GetValue(countVariableName);
Console.WriteLine($"{point.Timestamp} - Temperature count: {temperatureCount}");
}
#endregion Snippet:TimeSeriesInsightsSampleQueryAggregateSeriesWithAggregateVariable
}
private async Task RunQuerySeriesSampleWithInlineVariables(TimeSeriesInsightsClient client, TimeSeriesId tsId)
{
// Query for two series, one with the temperature values in Celsius and another in Fahrenheit
#region Snippet:TimeSeriesInsightsSampleQuerySeriesWithInlineVariables
Console.WriteLine("\n\nQuery for temperature series in Celsius and Fahrenheit over the past 10 minutes.\n");
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 querySeriesRequestOptions = new QuerySeriesRequestOptions();
querySeriesRequestOptions.InlineVariables["TemperatureInCelsius"] = celsiusVariable;
querySeriesRequestOptions.InlineVariables["TemperatureInFahrenheit"] = fahrenheitVariable;
QueryAnalyzer seriesQueryAnalyzer = client.Queries.CreateSeriesQueryAnalyzer(
tsId,
TimeSpan.FromMinutes(10),
null,
querySeriesRequestOptions);
await foreach (TimeSeriesPoint point in seriesQueryAnalyzer.GetResultsAsync())
{
double?tempInCelsius = (double?)point.GetValue("TemperatureInCelsius");
double?tempInFahrenheit = (double?)point.GetValue("TemperatureInFahrenheit");
Console.WriteLine($"{point.Timestamp} - Average temperature in Celsius: {tempInCelsius}. Average temperature in Fahrenheit: {tempInFahrenheit}.");
}
#endregion Snippet:TimeSeriesInsightsSampleQuerySeriesWithInlineVariables
}
private async Task <string> createTimeSeriesTypeAsync(TimeSeriesInsightsClient client)
{
var timeSeriesTypes = new List <TimeSeriesType>();
var tsiTypeNamePrefix = "type";
var timeSeriesTypesName = Recording.GenerateAlphaNumericId(tsiTypeNamePrefix);
string timeSeriesTypeId = Recording.GenerateId();
// Build aggregate variable
var countExpression = new TimeSeriesExpression("count()");
var aggregateVariable = new AggregateVariable(countExpression);
var variables = new Dictionary <string, TimeSeriesVariable>();
var variableNamePrefix = "aggregateVariable";
variables.Add(Recording.GenerateAlphaNumericId(variableNamePrefix), aggregateVariable);
var type = new TimeSeriesType(timeSeriesTypesName, variables);
type.Id = timeSeriesTypeId;
timeSeriesTypes.Add(type);
Response <TimeSeriesOperationError[]> createTypesResult = await client
.CreateOrReplaceTimeSeriesTypesAsync(timeSeriesTypes)
.ConfigureAwait(false);
createTypesResult.Value.Should().OnlyContain((errorResult) => errorResult == null);
return(timeSeriesTypeId);
}
public async Task <InstancesBatchResponse> CreateNewInstance(string EnvironmentFqdn, IList <TimeSeriesInstance> Instance)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
InstancesBatchResponse instances = await tsi.ExecuteInstancesBatchOperationAsync(
new InstancesBatchRequest(put : Instance));
return(instances);
}
static void Main(string[] args)
{
_client = GetTimeSeriesInsightsClientAsync().Result;
while (true)
{
RunOperationsLoopAsync().Wait();
}
}
private Program(ILogger <Program> log,
string timeSeriesTypesFile, string timeSeriesHierarchiesFile,
TimeSeriesInsightsClient timeSeriesInsightsClient)
{
_log = log;
_timeSeriesTypesFile = timeSeriesTypesFile;
_timeSeriesHierarchiesFile = timeSeriesHierarchiesFile;
_timeSeriesInsightsClient = timeSeriesInsightsClient;
}
public async Task <HierarchiesBatchResponse> CreateNewHierarchy(string EnvironmentFqdn, IList <TimeSeriesHierarchy> value)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
HierarchiesBatchResponse hierarchies =
await tsi.ExecuteHierarchiesBatchOperationAsync(new HierarchiesBatchRequest(put : value));
return(hierarchies);
}
public async Task <InstancesBatchResponse> DeleteInstance(string EnvironmentFqdn, object[] id)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
InstancesBatchResponse instances = await tsi.ExecuteInstancesBatchOperationAsync(
new InstancesBatchRequest(delete : new IList <object>[] { id }));
return(instances);
}
public async Task <InstancesBatchResponse> GetInstance(string EnvironmentFqdn, string TimeSeriesId)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
object[] TimeSeriesIdValue = new object[] { TimeSeriesId };
InstancesBatchResponse instances = await tsi.ExecuteInstancesBatchOperationAsync(
new InstancesBatchRequest(get : new IList <object>[] { TimeSeriesIdValue }));
return(instances);
}
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;
}
}
}
static void Main(string[] args)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
_client = GetTimeSeriesInsightsClientAsync().Result;
while (true)
{
RunOperationsLoopAsync().Wait();
}
}
public async Task <HierarchiesBatchResponse> DeleteHierarchy(string EnvironmentFqdn, string id)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
HierarchiesBatchResponse hierarchies =
await tsi.ExecuteHierarchiesBatchOperationAsync(new HierarchiesBatchRequest(delete : new HierarchiesRequestBatchGetDelete(hierarchyIds : new List <Guid?>()
{
Guid.Parse(id)
})));
return(hierarchies);
}
public async Task <TypesBatchResponse> GetType(string EnvironmentFqdn, string id)
{
TimeSeriesInsightsClient tsi = GetTimeSeriesInsightsClientAsync(EnvironmentFqdn).Result;
TypesBatchResponse types = await tsi.ExecuteTypesBatchOperationAsync(
new TypesBatchRequest(
get : new TypesRequestBatchGetOrDelete(typeIds : new List <Guid?>()
{
Guid.Parse(id)
})));
return(types);
}
public void UpdateModelSettingsWithInvalidType_ThrowsBadRequestException()
{
// arrange
TimeSeriesInsightsClient client = GetClient();
// act
Func <Task> act = async() => await client.UpdateModelSettingsDefaultTypeIdAsync("testId").ConfigureAwait(false);
// assert
act.Should().Throw <RequestFailedException>()
.And.Status.Should().Be((int)HttpStatusCode.BadRequest);
}
/// <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, TimeSeriesId tsId)
{
PrintHeader("TIME SERIES INSIGHTS QUERY SAMPLE");
TimeSeriesInsightsQueries queriesClient = client.GetQueriesClient();
await RunQueryEventsSample(queriesClient, tsId);
await RunQueryAggregateSeriesSample(queriesClient, tsId);
await RunQuerySeriesSampleWithInlineVariables(queriesClient, tsId);
await RunQuerySeriesSampleWithPreDefinedVariables(client, tsId);
}
/// <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);
}
private static async Task <TimeSeriesInsightsClient> GetTimeSeriesInsightsClientAsync(
TokenCredential credential, string timeSeriesEnvironmentFqdn)
{
var token = await credential.GetTokenAsync(
new TokenRequestContext(new[] { TimeSeriesInsightsApplicationId }), default);
ServiceClientCredentials clientCredentials = new TokenCredentials(token.Token);
TimeSeriesInsightsClient timeSeriesInsightsClient = new TimeSeriesInsightsClient(clientCredentials)
{
EnvironmentFqdn = timeSeriesEnvironmentFqdn
};
return(timeSeriesInsightsClient);
}
private static async Task <TimeSeriesInsightsClient> GetTimeSeriesInsightsClientAsync()
{
AuthenticationContext context = new AuthenticationContext($"{AzureActiveDirectoryLoginUrl}/{MicrosoftTenantId}", TokenCache.DefaultShared);
AuthenticationResult authenticationResult = await context.AcquireTokenAsync(ResourceUri, PowerShellAadClientId, RedirectUri, new PlatformParameters(PromptBehavior.Auto));
TokenCloudCredentials tokenCloudCredentials = new TokenCloudCredentials(authenticationResult.AccessToken);
ServiceClientCredentials serviceClientCredentials = new TokenCredentials(tokenCloudCredentials.Token);
TimeSeriesInsightsClient timeSeriesInsightsClient = new TimeSeriesInsightsClient(credentials: serviceClientCredentials)
{
EnvironmentFqdn = EnvironmentFqdn
};
return(timeSeriesInsightsClient);
}
private static async Task <TimeSeriesInsightsClient> GetTimeSeriesInsightsClientAsync()
{
AuthenticationContext context = new AuthenticationContext($"{AzureActiveDirectoryLoginUrl}/{TenantId}", TokenCache.DefaultShared);
ClientCredential clientCredential = new ClientCredential(ClientId, SecretKey);
AuthenticationResult authenticationResult = await context.AcquireTokenAsync(ResourceUri, clientCredential);
TokenCloudCredentials tokenCloudCredentials = new TokenCloudCredentials(authenticationResult.AccessToken);
ServiceClientCredentials serviceClientCredentials = new TokenCredentials(tokenCloudCredentials.Token);
TimeSeriesInsightsClient timeSeriesInsightsClient = new TimeSeriesInsightsClient(credentials: serviceClientCredentials)
{
EnvironmentFqdn = EnvironmentFqdn
};
return(timeSeriesInsightsClient);
}
public async Task TimeSeriesInsightsClient_ModelSettingsTest()
{
TimeSeriesInsightsClient client = GetClient();
// GET model settings
Response <TimeSeriesModelSettings> currentSettings = await client.GetModelSettingsAsync().ConfigureAwait(false);
currentSettings.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK);
string testName = "testModel";
// UPDATE model settings
Response <TimeSeriesModelSettings> updatedSettingsName = await client.UpdateModelSettingsNameAsync(testName).ConfigureAwait(false);
updatedSettingsName.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK);
updatedSettingsName.Value.Name.Should().Be(testName);
// TODO 9430977: Add a test for updating default Type Id. Need existing Model type to update with associated type Id.
}
