public async ValueTask <ResponseWithHeaders <AddHeaders> > AddAsync(CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions, CancellationToken cancellationToken = default)
{
if (certificate == null)
{
throw new ArgumentNullException(nameof(certificate));
}
using var scope = clientDiagnostics.CreateScope("CertificateClient.Add");
scope.Start();
try
{
using var message = CreateAddRequest(certificate, certificateAddOptions);
await pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
var headers = new AddHeaders(message.Response);
switch (message.Response.Status)
{
case 201:
return(ResponseWithHeaders.FromValue(headers, message.Response));
default:
throw await clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
internal HttpMessage CreateAddRequest(CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions)
{
var message = pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Post;
var uri = new RawRequestUriBuilder();
uri.AppendRaw(batchUrl, false);
uri.AppendPath("/certificates", false);
if (certificateAddOptions?.Timeout != null)
{
uri.AppendQuery("timeout", certificateAddOptions.Timeout.Value, true);
}
uri.AppendQuery("api-version", apiVersion, true);
request.Uri = uri;
if (certificateAddOptions?.ClientRequestId != null)
{
request.Headers.Add("client-request-id", certificateAddOptions.ClientRequestId.Value);
}
if (certificateAddOptions?.ReturnClientRequestId != null)
{
request.Headers.Add("return-client-request-id", certificateAddOptions.ReturnClientRequestId.Value);
}
if (certificateAddOptions?.OcpDate != null)
{
request.Headers.Add("ocp-date", certificateAddOptions.OcpDate.Value, "R");
}
request.Headers.Add("Content-Type", "application/json; odata=minimalmetadata");
using var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(certificate);
request.Content = content;
return(message);
}
/// <summary>
/// Adds a Certificate to the specified Account.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='certificate'>
/// The Certificate to be added.
/// </param>
/// <param name='certificateAddOptions'>
/// Additional parameters for the operation
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <CertificateAddHeaders> AddAsync(this ICertificateOperations operations, CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions = default(CertificateAddOptions), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.AddWithHttpMessagesAsync(certificate, certificateAddOptions, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Headers);
}
}
/// <summary>
/// Adds a Certificate to the specified Account.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='certificate'>
/// The Certificate to be added.
/// </param>
/// <param name='certificateAddOptions'>
/// Additional parameters for the operation
/// </param>
public static CertificateAddHeaders Add(this ICertificateOperations operations, CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions = default(CertificateAddOptions))
{
return(operations.AddAsync(certificate, certificateAddOptions).GetAwaiter().GetResult());
}
public void NewBatchCertificateRequestBodyTest()
{
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
X509Certificate2 cert = new X509Certificate2(BatchTestHelpers.TestCertificateFileName);
string certDataBase64String = Convert.ToBase64String(cert.RawData);
CertificateAddParameter requestParameters = null;
// Don't go to the service on an Add Certificate call
RequestInterceptor interceptor = new RequestInterceptor((baseRequest) =>
{
CertificateAddBatchRequest request = (CertificateAddBatchRequest)baseRequest;
request.ServiceRequestFunc = (cancellationToken) =>
{
requestParameters = request.Parameters;
var response = new AzureOperationHeaderResponse <CertificateAddHeaders>();
Task <AzureOperationHeaderResponse <CertificateAddHeaders> > task = Task.FromResult(response);
return(task);
};
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
// Verify that when just the raw data is specified, the request body matches expectations
cmdlet.RawData = cert.RawData;
cmdlet.ExecuteCmdlet();
Assert.Equal(CertificateFormat.Cer, requestParameters.CertificateFormat);
Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm);
Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant());
Assert.True(string.IsNullOrEmpty(requestParameters.Password));
Assert.Equal(certDataBase64String, requestParameters.Data);
// Verify that when the raw data is specified with a password, the request body matches expectations
cmdlet.RawData = cert.RawData;
cmdlet.Password = BatchTestHelpers.TestCertificatePassword;
cmdlet.ExecuteCmdlet();
Assert.Equal(CertificateFormat.Pfx, requestParameters.CertificateFormat);
Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm);
Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant());
Assert.Equal(BatchTestHelpers.TestCertificatePassword, requestParameters.Password);
Assert.Equal(certDataBase64String, requestParameters.Data);
// Verify that when just a file path is specified, the request body matches expectations
cmdlet.RawData = null;
cmdlet.Password = null;
cmdlet.FilePath = BatchTestHelpers.TestCertificateFileName;
cmdlet.ExecuteCmdlet();
Assert.Equal(CertificateFormat.Cer, requestParameters.CertificateFormat);
Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm);
Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant());
Assert.True(string.IsNullOrEmpty(requestParameters.Password));
Assert.Equal(certDataBase64String, requestParameters.Data);
// Verify that when a file path is specified with a password, the request body matches expectations
cmdlet.Password = BatchTestHelpers.TestCertificatePassword;
cmdlet.ExecuteCmdlet();
Assert.Equal(CertificateFormat.Pfx, requestParameters.CertificateFormat);
Assert.Equal(BatchTestHelpers.TestCertificateAlgorithm, requestParameters.ThumbprintAlgorithm);
Assert.Equal(cert.Thumbprint.ToLowerInvariant(), requestParameters.Thumbprint.ToLowerInvariant());
Assert.Equal(BatchTestHelpers.TestCertificatePassword, requestParameters.Password);
Assert.Equal(certDataBase64String, requestParameters.Data);
}
/// <summary>
/// Adds a certificate to the specified account.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='certificate'>
/// The certificate to be added.
/// </param>
/// <param name='certificateAddOptions'>
/// Additional parameters for the operation
/// </param>
public static CertificateAddHeaders Add(this ICertificateOperations operations, CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions = default(CertificateAddOptions))
{
return(System.Threading.Tasks.Task.Factory.StartNew(s => ((ICertificateOperations)s).AddAsync(certificate, certificateAddOptions), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public virtual Response Add(CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions, CancellationToken cancellationToken = default)
{
return(RestClient.Add(certificate, certificateAddOptions, cancellationToken).GetRawResponse());
}
public virtual async Task <Response> AddAsync(CertificateAddParameter certificate, CertificateAddOptions certificateAddOptions, CancellationToken cancellationToken = default)
{
return((await RestClient.AddAsync(certificate, certificateAddOptions, cancellationToken).ConfigureAwait(false)).GetRawResponse());
}
