public async Task When_UpdatingCertificateRecord_CallsInternalApi_Then_ReturnCertificateWithResponseCode200(
UpdateCertificateRequest request,
IEnumerable <UpdateCertificateResponse> response)
{
//Arrange
UpdateBatchCertificateRequest transformedRequest = null;
var requests = new List <UpdateCertificateRequest> {
request
};
_mockApiClient.Setup(s => s.UpdateCertificates(It.IsAny <IEnumerable <UpdateBatchCertificateRequest> >()))
.Callback <IEnumerable <UpdateBatchCertificateRequest> >((input) => transformedRequest = input.First())
.ReturnsAsync(response);
//Act
var result = await _controller.UpdateCertificates(requests) as ObjectResult;
//Assert
result.StatusCode.Value.Should().Be((int)HttpStatusCode.OK);
transformedRequest.Should().NotBeNull();
transformedRequest.Should().BeEquivalentTo(new
{
UkPrn = _headerInfo.Object.Ukprn,
request.RequestId,
CertificateData = new
{
request.Standard,
request.Learner,
request.LearningDetails,
request.PostalContact
}
});
result.Value.Should().Be(response);
}
public async Task <Certificate> UpdateCertificate(UpdateCertificateRequest certificateRequest)
{
using (var httpRequest = new HttpRequestMessage(HttpMethod.Put, "api/v1/certificates/update"))
{
return(await PostPutRequestWithResponse <UpdateCertificateRequest, Certificate>(httpRequest, certificateRequest));
}
}
/// <summary>
/// Updates a certificate with the given identifier
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/apigateway/UpdateCertificate.cs.html">here</a> to see an example of how to use UpdateCertificate API.</example>
public async Task <UpdateCertificateResponse> UpdateCertificate(UpdateCertificateRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called updateCertificate");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/certificates/{certificateId}".Trim('/')));
HttpMethod method = new HttpMethod("PUT");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <UpdateCertificateResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"UpdateCertificate failed with error: {e.Message}");
throw;
}
}
/// <summary>
/// 更新证书
/// </summary>
public UpdateCertificateResponse UpdateCertificate(UpdateCertificateRequest updateCertificateRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("certificate_id", updateCertificateRequest.CertificateId.ToString());
string urlPath = HttpUtils.AddUrlPath("/v3/{project_id}/elb/certificates/{certificate_id}", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", updateCertificateRequest);
HttpResponseMessage response = DoHttpRequestSync("PUT", request);
return(JsonUtils.DeSerialize <UpdateCertificateResponse>(response));
}
public async Task UpdateCertificatesExample()
{
// NOTE: You will need to know what the certificate currently looks like
Certificate currentCertificate = new Certificate
{
Status = new Status {
CurrentStatus = "Draft"
},
Created = new Created {
CreatedAt = DateTime.UtcNow, CreatedBy = "Example"
},
CertificateData = new CertificateData
{
CertificateReference = "00012001",
Learner = new Learner {
Uln = 1234567890, GivenNames = "Fred", FamilyName = "Bloggs"
},
Standard = new Standard {
StandardCode = 1, StandardReference = "ST0127", Level = 1, StandardName = "Example Standard",
},
LearningDetails = new LearningDetails
{
LearningStartDate = DateTime.UtcNow.AddYears(-1),
ProviderName = "Test Provider",
ProviderUkPrn = 123456,
OverallGrade = "Pass",
AchievementDate = DateTime.UtcNow
},
PostalContact = new PostalContact {
ContactName = "Shreya Smith", Organisation = "Contoso Ltd", AddressLine1 = "123 Test Road", City = "Townsville", PostCode = "ZY99ZZ"
}
}
};
// Let's pretend the apprentice got a better grade
UpdateCertificateRequest updatedCertificate = new UpdateCertificateRequest
{
CertificateReference = currentCertificate.CertificateData.CertificateReference,
Learner = currentCertificate.CertificateData.Learner,
Standard = currentCertificate.CertificateData.Standard,
LearningDetails = currentCertificate.CertificateData.LearningDetails,
PostalContact = currentCertificate.CertificateData.PostalContact,
};
updatedCertificate.LearningDetails.OverallGrade = "Merit";
if (updatedCertificate.IsValid(out _))
{
// NOTE: The External API performs validation, however it is a good idea to check beforehand
await _CertificateApiClient.UpdateCertificates(new List <UpdateCertificateRequest> {
updatedCertificate
});
}
}
public async Task UpdateCertificate()
{
// arrange
var certificateData = Builder <CertificateData> .CreateNew().With(cd => cd.CertificateReference = "DRAFT CERTIFICATE")
.With(cd => cd.Standard = Builder <Standard> .CreateNew().Build())
.With(cd => cd.Learner = Builder <Learner> .CreateNew().Build())
.With(cd => cd.LearningDetails = Builder <LearningDetails> .CreateNew().Build())
.With(cd => cd.PostalContact = Builder <PostalContact> .CreateNew().Build())
.Build();
var status = new Status {
CurrentStatus = "Draft"
};
var created = new Created {
CreatedAt = DateTime.UtcNow.AddHours(-1), CreatedBy = "Test"
};
var certificate = new Certificate {
CertificateData = certificateData, Status = status, Created = created
};
var certificateRequest = new UpdateCertificateRequest
{
CertificateReference = certificate.CertificateData.CertificateReference,
Learner = certificate.CertificateData.Learner,
Standard = certificate.CertificateData.Standard,
LearningDetails = certificate.CertificateData.LearningDetails,
PostalContact = certificate.CertificateData.PostalContact
};
var expectedResponse = new List <UpdateCertificateResponse>
{
new UpdateCertificateResponse {
Certificate = certificate
}
};
_MockHttp.When(HttpMethod.Put, $"{apiBaseAddress}/api/v1/certificate")
.Respond(HttpStatusCode.OK, "application/json", JsonConvert.SerializeObject(expectedResponse));
// act
var actual = await _ApiClient.UpdateCertificates(new List <UpdateCertificateRequest> {
certificateRequest
});
// assert
Assert.That(actual, Has.Count.EqualTo(1));
Assert.That(actual.First().ValidationErrors, Has.Count.EqualTo(0));
Assert.That(actual.First().Certificate, Is.EqualTo(expectedResponse.First().Certificate));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UpdateCertificateRequest request;
try
{
request = new UpdateCertificateRequest
{
CertificateId = CertificateId,
OpcRequestId = OpcRequestId,
IfMatch = IfMatch,
UpdateCertificateDetails = UpdateCertificateDetails
};
response = client.UpdateCertificate(request).GetAwaiter().GetResult();
WriteOutput(response, response.Certificate);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task <IActionResult> Update([FromBody] UpdateCertificateRequest certificate)
{
return(Ok(await _mediator.Send(certificate)));
}
public async Task <Certificate> UpdateCertificate(UpdateCertificateRequest certificateRequest)
{
return(await Put <UpdateCertificateRequest, Certificate>("api/v1/certificates/update", certificateRequest));
}
