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