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. }