public async Task CheckNameAvailability() { await foreach (var tenant in Client.GetTenants().GetAllAsync()) { SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync(); string cdnEndpointName = Recording.GenerateAssetName("endpoint-"); CheckNameAvailabilityInput checkNameAvailabilityInput = new CheckNameAvailabilityInput(cdnEndpointName, ResourceType.MicrosoftCdnProfilesEndpoints); CheckNameAvailabilityOutput checkNameAvailabilityOutput = await tenant.CheckCdnNameAvailabilityAsync(checkNameAvailabilityInput); Assert.True(checkNameAvailabilityOutput.NameAvailable); ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-"); string cdnProfileName = Recording.GenerateAssetName("profile-"); ProfileResource cdnProfile = await CreateCdnProfile(rg, cdnProfileName, CdnSkuName.StandardMicrosoft); cdnEndpointName = Recording.GenerateAssetName("endpoint-"); CdnEndpointResource cdnEndpoint = await CreateCdnEndpoint(cdnProfile, cdnEndpointName); CheckNameAvailabilityInput checkNameAvailabilityInput2 = new CheckNameAvailabilityInput(cdnEndpoint.Data.Name, ResourceType.MicrosoftCdnProfilesEndpoints); checkNameAvailabilityOutput = await tenant.CheckCdnNameAvailabilityAsync(checkNameAvailabilityInput2); Assert.False(checkNameAvailabilityOutput.NameAvailable); } }
private static bool CheckNameAvailability(string supportTicketName, CheckNameAvailabilityInput inputPayload) { try { if (inputPayload.Type == Type.MicrosoftSupportSupportTickets) { var rsp = supportClient.SupportTickets.CheckNameAvailability(inputPayload); return(rsp.NameAvailable ?? false); } else if (inputPayload.Type == Type.MicrosoftSupportCommunications) { var rsp = supportClient.Communications.CheckNameAvailability(supportTicketName, inputPayload); return(rsp.NameAvailable ?? false); } else { return(false); } } catch (Exception ex) { Console.WriteLine(ERRORMSG); Console.WriteLine(JsonConvert.SerializeObject(ex, Formatting.Indented)); return(false); } }
public override void ExecuteCmdlet() { try { if (this.IsParameterBound(c => c.SupportTicketObject)) { this.SupportTicketName = this.SupportTicketObject.Name; } var checkNameAvailabilityInput = new CheckNameAvailabilityInput { Name = this.Name, Type = Management.Support.Models.Type.MicrosoftSupportCommunications }; var checkNameResult = this.SupportClient.Communications.CheckNameAvailability(this.SupportTicketName, checkNameAvailabilityInput); if (checkNameResult.NameAvailable.HasValue && !checkNameResult.NameAvailable.Value) { throw new PSArgumentException(string.Format("A Communication with name '{0}' for SupportTicket '{1}' already exists.", this.Name, this.SupportTicketName)); } var communicationDetails = new CommunicationDetails { Subject = this.Subject, Body = this.Body, Sender = this.Sender }; if (this.ShouldProcess(this.Name, string.Format("Creating a new Communication for SupportTicket '{0}' with name '{1}'.", this.SupportTicketName, this.Name))) { var result = this.SupportClient.Communications.Create(this.SupportTicketName, this.Name, communicationDetails); this.WriteObject(result.ToPSSupportTicketCommunication()); } } catch (ExceptionResponseException ex) { throw new PSArgumentException(string.Format("Error response received. Error Message: '{0}'", ex.Response.Content)); } }
internal HttpMessage CreateCheckNameAvailabilityRequest(CheckNameAvailabilityInput checkNameAvailabilityInput) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = RequestMethod.Post; var uri = new RawRequestUriBuilder(); uri.Reset(endpoint); uri.AppendPath("/providers/Microsoft.Cdn/checkNameAvailability", false); uri.AppendQuery("api-version", apiVersion, true); request.Uri = uri; request.Headers.Add("Accept", "application/json"); request.Headers.Add("Content-Type", "application/json"); var content = new Utf8JsonRequestContent(); content.JsonWriter.WriteObjectValue(checkNameAvailabilityInput); request.Content = content; message.SetProperty("UserAgentOverride", _userAgent); return(message); }
public async Task CheckNameAvailabilityWithSub() { Subscription subscription = await Client.GetDefaultSubscriptionAsync(); string cdnEndpointName = Recording.GenerateAssetName("endpoint-"); CheckNameAvailabilityInput checkNameAvailabilityInput = new CheckNameAvailabilityInput(cdnEndpointName); CheckNameAvailabilityOutput checkNameAvailabilityOutput = await subscription.CheckCdnNameAvailabilityWithSubscriptionAsync(checkNameAvailabilityInput); Assert.True(checkNameAvailabilityOutput.NameAvailable); ResourceGroup rg = await CreateResourceGroup(subscription, "testRg-"); string cdnProfileName = Recording.GenerateAssetName("profile-"); Profile cdnProfile = await CreateCdnProfile(rg, cdnProfileName, SkuName.StandardMicrosoft); cdnEndpointName = Recording.GenerateAssetName("endpoint-"); CdnEndpoint cdnEndpoint = await CreateCdnEndpoint(cdnProfile, cdnEndpointName); CheckNameAvailabilityInput checkNameAvailabilityInput2 = new CheckNameAvailabilityInput(cdnEndpoint.Data.Name); checkNameAvailabilityOutput = await subscription.CheckCdnNameAvailabilityWithSubscriptionAsync(checkNameAvailabilityInput2); Assert.False(checkNameAvailabilityOutput.NameAvailable); }
public static Response <CheckNameAvailabilityOutput> CheckCdnNameAvailability(this TenantResource tenantResource, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { Argument.AssertNotNull(checkNameAvailabilityInput, nameof(checkNameAvailabilityInput)); return(GetExtensionClient(tenantResource).CheckCdnNameAvailability(checkNameAvailabilityInput, cancellationToken)); }
/// <summary> /// Check the availability of a resource name. This API should to be used to /// check the uniqueness of the name for adding a new communication to the /// support ticket. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='supportTicketName'> /// Support ticket name /// </param> /// <param name='checkNameAvailabilityInput'> /// Input to check /// </param> public static CheckNameAvailabilityOutput CheckNameAvailability(this ICommunicationsOperations operations, string supportTicketName, CheckNameAvailabilityInput checkNameAvailabilityInput) { return(operations.CheckNameAvailabilityAsync(supportTicketName, checkNameAvailabilityInput).GetAwaiter().GetResult()); }
/// <summary> /// Check the availability of a resource name. This API should to be used to /// check the uniqueness of the name for adding a new communication to the /// support ticket. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='supportTicketName'> /// Support ticket name /// </param> /// <param name='checkNameAvailabilityInput'> /// Input to check /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityOutput> CheckNameAvailabilityAsync(this ICommunicationsOperations operations, string supportTicketName, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(supportTicketName, checkNameAvailabilityInput, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public static async Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityAsync(this TenantResource tenantResource, CheckNameAvailabilityInput input, CancellationToken cancellationToken = default) { Argument.AssertNotNull(input, nameof(input)); return(await GetExtensionClient(tenantResource).CheckCdnNameAvailabilityAsync(input, cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Check the availability of a resource name. This API should to be used to /// check the uniqueness of the name for support ticket creation for the /// selected subscription. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkNameAvailabilityInput'> /// Input to check. /// </param> public static CheckNameAvailabilityOutput CheckNameAvailability(this ISupportTicketsOperations operations, CheckNameAvailabilityInput checkNameAvailabilityInput) { return(operations.CheckNameAvailabilityAsync(checkNameAvailabilityInput).GetAwaiter().GetResult()); }
/// <summary> /// Check whether the Media Service resource name is available. The name must /// be globally unique. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkNameAvailabilityInput'> /// Properties needed to check the availability of a name. /// </param> public static CheckNameAvailabilityOutput CheckNameAvailabilty(this IMediaServiceOperations operations, CheckNameAvailabilityInput checkNameAvailabilityInput) { return(Task.Factory.StartNew(s => ((IMediaServiceOperations)s).CheckNameAvailabiltyAsync(checkNameAvailabilityInput), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <summary> /// Check the availability of a resource name. This is needed for resources /// where name is globally unique, such as a CDN endpoint. /// </summary> /// <param name='name'> /// The resource name to validate. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorResponseException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <AzureOperationResponse <CheckNameAvailabilityOutput> > CheckNameAvailabilityWithSubscriptionWithHttpMessagesAsync(string name, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.SubscriptionId"); } if (ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.ApiVersion"); } if (name == null) { throw new ValidationException(ValidationRules.CannotBeNull, "name"); } CheckNameAvailabilityInput checkNameAvailabilityInput = new CheckNameAvailabilityInput(); if (name != null) { checkNameAvailabilityInput.Name = name; } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("checkNameAvailabilityInput", checkNameAvailabilityInput); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "CheckNameAvailabilityWithSubscription", tracingParameters); } // Construct URL var _baseUrl = BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/providers/Microsoft.Cdn/checkNameAvailability").ToString(); _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(SubscriptionId)); List <string> _queryParameters = new List <string>(); if (ApiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(ApiVersion))); } if (_queryParameters.Count > 0) { _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (GenerateClientRequestId != null && GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString()); } if (AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", AcceptLanguage); } if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (checkNameAvailabilityInput != null) { _requestContent = SafeJsonConvert.SerializeObject(checkNameAvailabilityInput, SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse _errorBody = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <CheckNameAvailabilityOutput>(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_httpResponse.Headers.Contains("x-ms-request-id")) { _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <CheckNameAvailabilityOutput>(_responseContent, DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
/// <summary> /// Check the availability of a Front Door subdomain. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkFrontDoorNameAvailabilityInput'> /// Input to check. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityOutput> CheckAsync(this IFrontDoorNameAvailabilityWithSubscriptionOperations operations, CheckNameAvailabilityInput checkFrontDoorNameAvailabilityInput, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckWithHttpMessagesAsync(checkFrontDoorNameAvailabilityInput, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public static Response <CheckNameAvailabilityOutput> CheckCdnNameAvailability(this Tenant tenant, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { return(GetExtensionClient(tenant).CheckCdnNameAvailability(checkNameAvailabilityInput, cancellationToken)); }
public async virtual Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityAsync(CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } using var scope = DefaultClientDiagnostics.CreateScope("TenantExtensionClient.CheckCdnNameAvailability"); scope.Start(); try { var response = await DefaultRestClient.CheckNameAvailabilityAsync(checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false); return(response); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Check the availability of a Front Door resource name. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkFrontDoorNameAvailabilityInput'> /// Input to check. /// </param> public static CheckNameAvailabilityOutput CheckFrontDoorNameAvailability(this IFrontDoorManagementClient operations, CheckNameAvailabilityInput checkFrontDoorNameAvailabilityInput) { return(operations.CheckFrontDoorNameAvailabilityAsync(checkFrontDoorNameAvailabilityInput).GetAwaiter().GetResult()); }
public static async Task <Response <CheckNameAvailabilityOutput> > CheckNameAvailabilityAsync(this Tenant tenant, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } return(await tenant.UseClientContext(async (baseUri, credential, options, pipeline) => { var clientDiagnostics = new ClientDiagnostics(options); using var scope = clientDiagnostics.CreateScope("TenantExtensions.CheckNameAvailability"); scope.Start(); try { var restOperations = GetCdnManagementRestOperations(clientDiagnostics, credential, options, pipeline, baseUri); var response = await restOperations.CheckNameAvailabilityAsync(checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false); return response; } catch (Exception e) { scope.Failed(e); throw; } } ).ConfigureAwait(false)); }
public static Response <CheckNameAvailabilityOutput> CheckCdnNameAvailability(this Tenant tenant, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } return(GetExtensionClient(tenant).CheckCdnNameAvailability(checkNameAvailabilityInput, cancellationToken)); }
public async static Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityAsync(this Tenant tenant, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } return(await GetExtensionClient(tenant).CheckCdnNameAvailabilityAsync(checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Check the availability of a Front Door subdomain. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkFrontDoorNameAvailabilityInput'> /// Input to check. /// </param> public static CheckNameAvailabilityOutput Check(this IFrontDoorNameAvailabilityWithSubscriptionOperations operations, CheckNameAvailabilityInput checkFrontDoorNameAvailabilityInput) { return(operations.CheckAsync(checkFrontDoorNameAvailabilityInput).GetAwaiter().GetResult()); }
public static async Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityWithSubscriptionAsync(this Subscription subscription, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { Argument.AssertNotNull(checkNameAvailabilityInput, nameof(checkNameAvailabilityInput)); return(await GetExtensionClient(subscription).CheckCdnNameAvailabilityWithSubscriptionAsync(checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false)); }
public static async Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityAsync(this Tenant tenant, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { return(await GetExtensionClient(tenant).CheckCdnNameAvailabilityAsync(checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false)); }
public static Response <CheckNameAvailabilityOutput> CheckCdnNameAvailabilityWithSubscription(this Subscription subscription, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { Argument.AssertNotNull(checkNameAvailabilityInput, nameof(checkNameAvailabilityInput)); return(GetExtensionClient(subscription).CheckCdnNameAvailabilityWithSubscription(checkNameAvailabilityInput, cancellationToken)); }
public static Response <CheckNameAvailabilityOutput> CheckCdnNameAvailabilityWithSubscription(this Subscription subscription, CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } return(subscription.UseClientContext((baseUri, credential, options, pipeline) => { var clientDiagnostics = new ClientDiagnostics(options); using var scope = clientDiagnostics.CreateScope("SubscriptionExtensions.CheckCdnNameAvailabilityWithSubscription"); scope.Start(); try { CdnManagementRestOperations restOperations = GetCdnManagementRestOperations(clientDiagnostics, pipeline, options, baseUri); var response = restOperations.CheckNameAvailabilityWithSubscription(subscription.Id.SubscriptionId, checkNameAvailabilityInput, cancellationToken); return response; } catch (Exception e) { scope.Failed(e); throw; } } )); }
public override void ExecuteCmdlet() { try { if (this.IsParameterBound(c => this.ProblemStartTime)) { if (this.ProblemStartTime == DateTime.MinValue || this.ProblemStartTime > DateTime.Now) { throw new PSArgumentException(string.Format("ProblemStartTime {0} is not valid.", this.ProblemStartTime)); } } var problemClassificationResourceId = ResourceIdentifierHelper.BuildResourceIdentifier(this.ProblemClassificationId, ResourceType.ProblemClassifications); var checkNameAvailabilityInput = new CheckNameAvailabilityInput { Type = Management.Support.Models.Type.MicrosoftSupportSupportTickets, Name = this.Name }; var checkNameAvailabilityResult = this.SupportClient.SupportTickets.CheckNameAvailability(checkNameAvailabilityInput); if (checkNameAvailabilityResult.NameAvailable.HasValue && !checkNameAvailabilityResult.NameAvailable.Value) { throw new PSArgumentException(string.Format("A SupportTicket with name '{0}' cannot be created for the reason {1}.", this.Name, checkNameAvailabilityResult.Reason)); } if (this.IsParameterBound(c => c.TechnicalTicketResourceId)) { var technicalResourceId = new ResourceIdentifier(this.TechnicalTicketResourceId); if (!technicalResourceId.Subscription.Equals(this.SupportClient.SubscriptionId, StringComparison.OrdinalIgnoreCase)) { throw new PSArgumentException(string.Format("TechnicalResourceId {0} does not belong in subscription {1}.", this.TechnicalTicketResourceId, this.SupportClient.SubscriptionId)); } var resourceClient = AzureSession.Instance.ClientFactory.CreateArmClient <ResourceManagementClient>( DefaultProfile.DefaultContext, AzureEnvironment.Endpoint.ResourceManager); var oDataQuery = new ODataQuery <GenericResourceFilter>($"resourceGroup eq '{technicalResourceId.ResourceGroupName}' and resourceType eq '{technicalResourceId.ResourceType}' and name eq '{technicalResourceId.ResourceName}'"); var result = resourceClient.Resources.List(oDataQuery); if (result.Count() != 1) { throw new Exception(string.Format("TechnicalResourceId {0} was not found in subscription {1}.", this.TechnicalTicketResourceId, this.SupportClient.SubscriptionId)); } } var customHeaders = new Dictionary <string, List <string> >(); if (!string.IsNullOrEmpty(this.CSPHomeTenantId)) { if (!Guid.TryParse(this.CSPHomeTenantId, out var result)) { throw new PSArgumentException(string.Format("CSPHomeTenantId {0} is not a valid Guid.", this.CSPHomeTenantId)); } var auxToken = AzureSession.Instance.AuthenticationFactory.Authenticate(this.DefaultContext.Account, this.DefaultContext.Environment, this.CSPHomeTenantId, null, "Never", null); customHeaders.Add(AUX_HEADER_NAME, new List <string> { $"{AUX_TOKEN_PREFIX} {auxToken.AccessToken}" }); } PSContactProfile contactObject = null; if (this.ParameterSetName.Equals(CreateSupportTicketWithContactObjectParameterSet) || this.ParameterSetName.Equals(CreateQuotaSupportTicketWithContactObjectParameterSet) || this.ParameterSetName.Equals(CreateTechnicalSupportTicketWithContactObjectParameterSet)) { contactObject = this.CustomerContactDetail; } else { contactObject = new PSContactProfile { FirstName = this.CustomerFirstName, LastName = this.CustomerLastName, PrimaryEmailAddress = this.CustomerPrimaryEmailAddress, PreferredTimeZone = this.CustomerPreferredTimeZone, PreferredSupportLanguage = this.CustomerPreferredSupportLanguage, PhoneNumber = this.CustomerPhoneNumber, AdditionalEmailAddresses = this.AdditionalEmailAddress, Country = this.CustomerCountry, PreferredContactMethod = this.PreferredContactMethod.ToString() }; } var supportTicket = new PSSupportTicket { Title = this.Title, Description = this.Description, ServiceId = $"/providers/Microsoft.Support/services/{problemClassificationResourceId.ParentResource}", ProblemClassificationId = this.ProblemClassificationId, Severity = this.Severity.ToString(), Require24X7Response = this.Require24X7Response.IsPresent ? true : (bool?)null, ProblemStartTime = this.IsParameterBound(c => this.ProblemStartTime) ? this.ProblemStartTime.ToUniversalTime() : (DateTime?)null, ContactDetail = contactObject, TechnicalTicketResourceId = this.TechnicalTicketResourceId, QuotaTicketDetail = this.QuotaTicketDetail, }; if (this.ShouldProcess(this.Name, string.Format("Creating a new SupportTicket with name '{0}'.", this.Name))) { var sdkSupportTicket = supportTicket.ToSdkSupportTicket(); var result = this.SupportClient.CreateSupportTicketForSubscription(this.Name, sdkSupportTicket, customHeaders); this.WriteObject(result.ToPSSupportTicket()); } } catch (ExceptionResponseException ex) { throw new PSArgumentException(string.Format("Error response received. Error Message: '{0}'", ex.Response.Content)); } }
public async Task <Response <CheckNameAvailabilityOutput> > CheckNameAvailabilityAsync(CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } using var message = CreateCheckNameAvailabilityRequest(checkNameAvailabilityInput); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: { CheckNameAvailabilityOutput value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); value = CheckNameAvailabilityOutput.DeserializeCheckNameAvailabilityOutput(document.RootElement); return(Response.FromValue(value, message.Response)); }
public virtual async Task <Response <CheckNameAvailabilityOutput> > CheckCdnNameAvailabilityWithSubscriptionAsync(CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { using var scope = DefaultClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckCdnNameAvailabilityWithSubscription"); scope.Start(); try { var response = await DefaultRestClient.CheckNameAvailabilityWithSubscriptionAsync(Id.SubscriptionId, checkNameAvailabilityInput, cancellationToken).ConfigureAwait(false); return(response); } catch (Exception e) { scope.Failed(e); throw; } }
public virtual Response <CheckNameAvailabilityOutput> CheckCdnNameAvailability(CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { using var scope = DefaultClientDiagnostics.CreateScope("TenantExtensionClient.CheckCdnNameAvailability"); scope.Start(); try { var response = DefaultRestClient.CheckNameAvailability(checkNameAvailabilityInput, cancellationToken); return(response); } catch (Exception e) { scope.Failed(e); throw; } }
public virtual Response <CheckNameAvailabilityOutput> CheckCdnNameAvailabilityWithSubscription(CheckNameAvailabilityInput checkNameAvailabilityInput, CancellationToken cancellationToken = default) { if (checkNameAvailabilityInput == null) { throw new ArgumentNullException(nameof(checkNameAvailabilityInput)); } using var scope = DefaultClientDiagnostics.CreateScope("SubscriptionExtensionClient.CheckCdnNameAvailabilityWithSubscription"); scope.Start(); try { var response = DefaultRestClient.CheckNameAvailabilityWithSubscription(Id.SubscriptionId, checkNameAvailabilityInput, cancellationToken); return(response); } catch (Exception e) { scope.Failed(e); throw; } }