private async Task <IActionResult> LoadViewModel(string view)
{
var username = GetUsernameFromClaim();
Logger.LogInformation($"Load View Model for CertificateCheckViewModel for {username}");
var viewModel = new CertificateCheckViewModel();
CheckAndSetRedirectToCheck(viewModel);
if (!TryGetCertificateSession("CertificateCheckViewModel", username, out var certSession))
{
return(RedirectToAction("Index", "Search"));
}
var certificate = await CertificateApiClient.GetCertificate(certSession.CertificateId);
Logger.LogInformation($"Got Certificate for CertificateCheckViewModel requested by {username} with Id {certificate.Id}");
viewModel.FromCertificate(certificate);
viewModel.SetStandardHasVersionsAndOptions(certSession);
Logger.LogInformation($"Got View Model of type CertificateCheckViewModel requested by {username}");
return(View(view, viewModel));
}
public ProgramCsv(LearnerApiClient learnerApiClient, EpaApiClient epaApiClient, CertificateApiClient certificateApiClient, StandardsApiClient standardsApiClient)
{
_LearnerApiClient = learnerApiClient;
_EpaApiClient = epaApiClient;
_CertificateApiClient = certificateApiClient;
_StandardsApiClient = standardsApiClient;
}
private async Task <IActionResult> LoadViewModel(string view)
{
var username = GetUsernameFromClaim();
Logger.LogDebug($"Load View Model for CertificateOptionViewModel for {username}");
var viewModel = new CertificateOptionViewModel();
CheckAndSetRedirectToCheck(viewModel);
if (!TryGetCertificateSession("CertificateOptionViewModel", username, out CertificateSession certSession))
{
return(RedirectToAction("Index", "Search"));
}
var certificate = await CertificateApiClient.GetCertificate(certSession.CertificateId);
if (certSession.Options == null || !certSession.Options.Any())
{
return(RedirectToAction("Index", "Search"));
}
if (certSession.Options.Count == 1)
{
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
Logger.LogDebug($"Got Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id}");
viewModel.FromCertificate(certificate, certSession.Options);
Logger.LogDebug($"Got View Model of type CertificateOptionViewModel requested by {username}");
return(View(view, viewModel));
}
public static void Main()
{
const string subscriptionKey = ""; // insert your key here
const string apiBaseAddress = ""; // insert the API address here
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
httpClient.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
httpClient.BaseAddress = new Uri(apiBaseAddress);
LearnerApiClient learnerApiClient = new LearnerApiClient(httpClient);
EpaApiClient epaApiClient = new EpaApiClient(httpClient);
CertificateApiClient certificateApiClient = new CertificateApiClient(httpClient);
StandardsApiClient standardsApiClient = new StandardsApiClient(httpClient);
ProgramCsv p = new ProgramCsv(learnerApiClient, epaApiClient, certificateApiClient, standardsApiClient);
p.GetLearnerExample().GetAwaiter().GetResult();
p.CreateEpaRecordsExample().GetAwaiter().GetResult();
p.UpdateEpaRecordsExample().GetAwaiter().GetResult();
p.DeleteEpaRecordExample().GetAwaiter().GetResult();
p.CreateCertificatesExample().GetAwaiter().GetResult();
p.UpdateCertificatesExample().GetAwaiter().GetResult();
p.SubmitCertificatesExample().GetAwaiter().GetResult();
p.DeleteCertificateExample().GetAwaiter().GetResult();
p.GetCertificateExample().GetAwaiter().GetResult();
p.GetGradesExample().GetAwaiter().GetResult();
p.GetOptionsForAllStandardsExample().GetAwaiter().GetResult();
p.GetOptionsForStandardExample().GetAwaiter().GetResult();
}
private async Task <IActionResult> LoadViewModel(string view, bool?isFromStandard)
{
var username = ContextAccessor.HttpContext.User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value;
Logger.LogInformation($"Load View Model for CertificateOptionViewModel for {username}");
var viewModel = new CertificateOptionViewModel {
IsFromStandard = isFromStandard ?? false
};
var query = ContextAccessor.HttpContext.Request.Query;
if (query.ContainsKey("redirecttocheck") && bool.Parse(query["redirecttocheck"]))
{
Logger.LogInformation($"RedirectToCheck for CertificateOptionViewModel is true");
SessionService.Set("redirecttocheck", "true");
viewModel.BackToCheckPage = true;
}
else
{
SessionService.Remove("redirecttocheck");
}
var sessionString = SessionService.Get("CertificateSession");
if (sessionString == null)
{
Logger.LogInformation($"Session for CertificateOptionViewModel requested by {username} has been lost. Redirecting to Search Index");
return(RedirectToAction("Index", "Search"));
}
var certSession = JsonConvert.DeserializeObject <CertificateSession>(sessionString);
var certificate = await CertificateApiClient.GetCertificate(certSession.CertificateId);
if (!certSession.Options.Any())
{
if (ContextAccessor.HttpContext.Request.Query.ContainsKey("fromback"))
{
if (certificate.IsPrivatelyFunded)
{
return(RedirectToAction("StandardCode", "CertificatePrivateStandardCode"));
}
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
return(RedirectToAction("Grade", "CertificateGrade"));
}
Logger.LogInformation($"Got Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id}");
viewModel.FromCertificate(certificate, certSession.Options);
Logger.LogInformation($"Got View Model of type CertificateOptionViewModel requested by {username}");
return(View(view, viewModel));
}
private async Task <IActionResult> LoadViewModel(string view)
{
var username = GetUsernameFromClaim();
Logger.LogDebug($"Load View Model for CertificateVersionViewModel for {username}");
var viewModel = new CertificateVersionViewModel();
CheckAndSetRedirectToCheck(viewModel);
if (!TryGetCertificateSession("CertificateVersionViewModel", username, out CertificateSession certSession))
{
return(RedirectToAction("Index", "Search"));
}
var certificate = await CertificateApiClient.GetCertificate(certSession.CertificateId, includeLogs : true);
if (certSession.Versions == null || certSession.Versions.Count == 0)
{
return(RedirectToAction("Index", "Search"));
}
if (certSession.Versions.Count == 1)
{
// Only 1 version no need for a selection
var singularStandard = certSession.Versions.First();
var options = await _standardVersionClient.GetStandardOptions(singularStandard.StandardUId);
if (options != null & options.HasOptions())
{
certSession.StandardUId = singularStandard.StandardUId;
certSession.Options = options.CourseOption.ToList();
SessionService.Set(nameof(CertificateSession), certSession);
return(RedirectToAction("Option", "CertificateOption"));
}
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
Logger.LogDebug($"Got Certificate for CertificateVersionViewModel requested by {username} with Id {certificate.Id}");
viewModel.FromCertificate(certificate, certSession.Versions);
var attemptedStandardVersion = SessionService.Get("AttemptedStandardVersion");
if (attemptedStandardVersion != null)
{
viewModel.StandardUId = attemptedStandardVersion;
SessionService.Remove("AttemptedStandardVersion");
}
Logger.LogDebug($"Got View Model of type CertificateVersionViewModel requested by {username}");
return(View(view, viewModel));
}
public CertificateDeleteQueryBase()
{
MockedLogger = new Mock <ILogger <CertificateDeleteController> >();
var mockedCertificateApiClientLogger = new Mock <ILogger <CertificateApiClient> >();
var mockedApiClientLogger = new Mock <ILogger <ApiClient> >();
MockHttpContextAccessor = SetupMockedHttpContextAccessor();
CertificateApiClient = SetupCertificateApiClient(mockedCertificateApiClientLogger);
ApiClient = SetupApiClient(mockedApiClientLogger);
CertificateData = JsonConvert.DeserializeObject <CertificateData>(Certificate.CertificateData);
}
public void Setup()
{
_MockHttp = new MockHttpMessageHandler();
HttpClient httpClient = _MockHttp.ToHttpClient();
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
httpClient.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
httpClient.BaseAddress = new Uri(apiBaseAddress);
_ApiClient = new CertificateApiClient(httpClient);
}
private async Task <IActionResult> SaveViewModel(CertificateOptionViewModel vm, string returnToIfModelNotValid, RedirectToActionResult nextAction, string action)
{
var username = GetUsernameFromClaim();
Logger.LogDebug($"Save View Model for CertificateOptionViewModel for {username} with values: {GetModelValues(vm)}");
var certificate = await CertificateApiClient.GetCertificate(vm.Id);
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
SessionService.RemoveRedirectedFromVersion();
var sessionString = SessionService.Get(nameof(CertificateSession));
if (sessionString == null)
{
Logger.LogDebug($"Session for CertificateOptionViewModel requested by {username} has been lost. Redirecting to Search Index");
return(RedirectToAction("Index", "Search"));
}
var certSession = JsonConvert.DeserializeObject <CertificateSession>(sessionString);
if (!ModelState.IsValid)
{
vm.Options = certSession.Options;
Logger.LogDebug($"Model State not valid for CertificateOptionViewModel requested by {username} with Id {certificate.Id}. Errors: {ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)}");
return(View(returnToIfModelNotValid, vm));
}
var updatedCertificate = vm.GetCertificateFromViewModel(certificate, certData);
try
{
await CertificateApiClient.UpdateCertificate(new UpdateCertificateRequest(updatedCertificate) { Username = username, Action = action });
}
catch
{
Logger.LogError($"Unable to update certificate with Id {certificate.Id}.");
return(RedirectToAction("Error", "Home"));
}
Logger.LogDebug($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} updated.");
if (SessionService.GetRedirectToCheck())
{
Logger.LogDebug($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} redirecting back to Certificate Check.");
return(new RedirectToActionResult("Check", "CertificateCheck", null));
}
Logger.LogDebug($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} redirecting to {nextAction.ControllerName} {nextAction.ActionName}");
return(nextAction);
}
public async Task <IActionResult> Grade(CertificateGradeViewModel vm)
{
var certificate = await CertificateApiClient.GetCertificate(vm.Id);
if (certificate.IsPrivatelyFunded)
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Grade.cshtml",
nextAction : RedirectToAction("LearnerStartDate", "CertificatePrivateLearnerStartDate"),
action : CertificateActions.Grade));
}
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Grade.cshtml",
nextAction : RedirectToAction("Date", "CertificateDate"), action : CertificateActions.Grade));
}
public static CertificateApiClient Setup(Certificate certificate, Mock <ILogger <CertificateApiClient> > apiClientLoggerMock)
{
var webConfigMock = new Mock <IWebConfiguration>();
var hostMock = new Mock <IHostingEnvironment>();
hostMock
.Setup(m => m.EnvironmentName)
.Returns(EnvironmentName.Development);
var tokenServiceMock = new TokenService(webConfigMock.Object, hostMock.Object, false);
var options = Builder <Option> .CreateListOfSize(10)
.Build();
var mockHttp = new MockHttpMessageHandler();
var client = mockHttp.ToHttpClient();
client.BaseAddress = new Uri("http://localhost:59022/");
mockHttp.When($"http://localhost:59022/api/v1/certificates/{certificate.Id}")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
mockHttp.When($"http://localhost:59022/api/v1/organisations/{certificate.OrganisationId}")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
mockHttp.When($"http://localhost:59022/api/v1/certificates/options/?stdCode={93}")
.Respond("application/json", JsonConvert.SerializeObject(options));
var certificateFirstNameViewModel = new CertificateFirstNameViewModel
{
Id = new Guid("1f120837-72d5-40eb-a785-b3936210d47a"),
FullName = "James Corley",
FirstName = "James",
FamilyName = "Corley",
GivenNames = "James",
Level = 2,
Standard = "91",
IsPrivatelyFunded = true
};
mockHttp
.When(System.Net.Http.HttpMethod.Put, "http://localhost:59022/api/v1/certificates/update")
.Respond(System.Net.HttpStatusCode.OK, "application/json", "{'status' : 'OK'}");
var apiClient = new CertificateApiClient(client, tokenServiceMock, apiClientLoggerMock.Object);
return(apiClient);
}
private CertificateApiClient SetupCertificateApiClient(Mock <ILogger <CertificateApiClient> > apiClientLoggerMock)
{
Certificate = SetupCertificate();
var tokenServiceMock = new Mock <ITokenService>();
var mockHttp = new MockHttpMessageHandler();
var client = mockHttp.ToHttpClient();
client.BaseAddress = new Uri("http://localhost:59022/");
var apiClient = new CertificateApiClient(client.BaseAddress.ToString(), tokenServiceMock.Object, apiClientLoggerMock.Object);
return(apiClient);
}
private async Task <IActionResult> SaveViewModel(CertificateOptionViewModel vm, string returnToIfModelNotValid, RedirectToActionResult nextAction, string action)
{
var username = ContextAccessor.HttpContext.User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value;
Logger.LogInformation($"Save View Model for CertificateOptionViewModel for {username} with values: {GetModelValues(vm)}");
var certificate = await CertificateApiClient.GetCertificate(vm.Id);
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
var sessionString = SessionService.Get("CertificateSession");
if (sessionString == null)
{
Logger.LogInformation($"Session for CertificateOptionViewModel requested by {username} has been lost. Redirecting to Search Index");
return(RedirectToAction("Index", "Search"));
}
var certSession = JsonConvert.DeserializeObject <CertificateSession>(sessionString);
if (!ModelState.IsValid)
{
vm.FamilyName = certData.LearnerFamilyName;
vm.GivenNames = certData.LearnerGivenNames;
vm.Options = certSession.Options;
Logger.LogInformation($"Model State not valid for CertificateOptionViewModel requested by {username} with Id {certificate.Id}. Errors: {ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)}");
return(View(returnToIfModelNotValid, vm));
}
var updatedCertificate = vm.GetCertificateFromViewModel(certificate, certData);
await CertificateApiClient.UpdateCertificate(new UpdateCertificateRequest(updatedCertificate) { Username = username, Action = action });
Logger.LogInformation($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} updated.");
if (SessionService.Exists("redirecttocheck") && bool.Parse(SessionService.Get("redirecttocheck")))
{
Logger.LogInformation($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} redirecting back to Certificate Check.");
return(new RedirectToActionResult("Check", "CertificateCheck", null));
}
Logger.LogInformation($"Certificate for CertificateOptionViewModel requested by {username} with Id {certificate.Id} redirecting to {nextAction.ControllerName} {nextAction.ActionName}");
return(nextAction);
}
public static CertificateApiClient Setup(Certificate certificate, Mock <ILogger <CertificateApiClient> > apiClientLoggerMock)
{
var webConfigMock = new Mock <IWebConfiguration>();
var hostMock = new Mock <IHostingEnvironment>();
hostMock
.Setup(m => m.EnvironmentName)
.Returns(EnvironmentName.Development);
var tokenServiceMock = new TokenService(webConfigMock.Object, hostMock.Object, false);
var options = Builder <Option> .CreateListOfSize(10)
.Build();
var mockHttp = new MockHttpMessageHandler();
var client = mockHttp.ToHttpClient();
client.BaseAddress = new Uri("http://localhost:59022/");
mockHttp.When($"http://localhost:59022/api/v1/certificates/{certificate.Id}?includeLogs={false}")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
mockHttp.When($"http://localhost:59022/api/v1/organisations/{certificate.OrganisationId}")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
mockHttp.When($"http://localhost:59022/api/v1/certificates/options/?stdCode={93}")
.Respond("application/json", JsonConvert.SerializeObject(options));
mockHttp.When($"http://localhost:59022/api/v1/certificates/options/?stdCode={1}")
.Respond("application/json", JsonConvert.SerializeObject(options));
mockHttp.When($"http://localhost:59022/api/v1/certificates/start")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
mockHttp
.When(System.Net.Http.HttpMethod.Put, "http://localhost:59022/api/v1/certificates/update")
.Respond(System.Net.HttpStatusCode.OK, "application/json", "{'status' : 'OK'}");
var apiClient = new CertificateApiClient(client, tokenServiceMock, apiClientLoggerMock.Object);
return(apiClient);
}
public async Task <IActionResult> Check(CertificateCheckViewModel vm)
{
// This is the final step in the process so get the latest version of the certificate!
if (vm is null)
{
vm = new CertificateCheckViewModel();
}
vm.FromCertificate(await CertificateApiClient.GetCertificate(vm.Id));
var result = _validator.Validate(vm);
if (!result.IsValid)
{
return(await Check());
}
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Check.cshtml",
nextAction : RedirectToAction("Confirm", "CertificateConfirmation"), action : CertificateActions.Submit));
}
private async Task GetGrades()
{
string subscriptionKey = Settings.Default["SubscriptionKey"].ToString();
string apiBaseAddress = Settings.Default["ApiBaseAddress"].ToString();
using (HttpClient httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(apiBaseAddress);
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
httpClient.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
CertificateApiClient certificateApiClient = new CertificateApiClient(httpClient);
var grades = new List <string>();
try
{
BusyIndicator.IsBusy = true;
var response = await certificateApiClient.GetGrades();
if (response != null)
{
grades.AddRange(response);
}
}
finally
{
BusyIndicator.IsBusy = false;
}
if (grades.Any())
{
SaveGrades(grades);
}
}
}
private async Task <IActionResult> SaveViewModel(CertificateVersionViewModel vm, RedirectToActionResult nextAction, string action)
{
var username = GetUsernameFromClaim();
var epaoid = GetEpaOrgIdFromClaim();
var redirectToCheck = SessionService.GetRedirectToCheck();
Logger.LogDebug($"Save View Model for CertificateVersionViewModel for {username} with values: {GetModelValues(vm)}");
var certificate = await CertificateApiClient.GetCertificate(vm.Id);
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
if (!TryGetCertificateSession("CertificateVersionViewModel", username, out var certSession))
{
return(RedirectToAction("Index", "Search"));
}
if (!ModelState.IsValid)
{
Logger.LogDebug($"Model State not valid for CertificateVersionViewModel requested by {username} with Id {certificate.Id}. Errors: {ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)}");
return(View("~/Views/Certificate/Version.cshtml", vm));
}
var standardVersion = await _standardVersionClient.GetStandardVersionById(vm.StandardUId);
var approvedStandardVersions = await _standardVersionClient.GetEpaoRegisteredStandardVersions(epaoid, certSession.StandardCode);
var options = await _standardVersionClient.GetStandardOptions(vm.StandardUId);
if (!approvedStandardVersions.Any(v => v.StandardUId == vm.StandardUId))
{
SessionService.Set("AttemptedStandardVersion", vm.StandardUId);
return(RedirectToAction("NotApprovedToAssess", "CertificateVersionNotApproved", redirectToCheck ? new { redirectToCheck } : null));
}
var versionChanged = certificate.StandardUId != vm.StandardUId;
// Edge case to cater to back buttons where user can change version without setting an option
var optionNotSet = string.IsNullOrEmpty(certData.CourseOption) && options != null && options.HasOptions();
if (!versionChanged && !optionNotSet && redirectToCheck)
{
// if version hasn't changed, and option set if required, don't need to update options.
return(new RedirectToActionResult("Check", "CertificateCheck", null));
}
certSession.StandardUId = vm.StandardUId;
// To pass in to inherited method.
vm.SelectedStandardVersion = standardVersion;
vm.SelectedStandardOptions = options;
var updatedCertificate = vm.GetCertificateFromViewModel(certificate, certData);
try
{
await CertificateApiClient.UpdateCertificate(new UpdateCertificateRequest(updatedCertificate) { Username = username, Action = action });
}
catch
{
Logger.LogError($"Unable to update certificate with Id {certificate.Id}.");
return(RedirectToAction("Error", "Home"));
}
Logger.LogDebug($"Certificate for CertificateVersionViewModel requested by {username} with Id {certificate.Id} updated.");
if (options != null && options.HasOptions())
{
certSession.Options = options.CourseOption.ToList();
SessionService.Set(nameof(CertificateSession), certSession);
if (options.OnlyOneOption())
{
if (redirectToCheck)
{
return(new RedirectToActionResult("Check", "CertificateCheck", null));
}
return(new RedirectToActionResult("Declare", "CertificateDeclaration", null));
}
object routeValues = null;
if (redirectToCheck)
{
routeValues = new { redirecttocheck = true };
}
SessionService.SetRedirectedFromVersion(true);
return(new RedirectToActionResult("Option", "CertificateOption", routeValues));
}
else
{
certSession.Options = null;
SessionService.Set(nameof(CertificateSession), certSession);
}
if (redirectToCheck)
{
Logger.LogDebug($"Certificate for CertificateVersionViewModel requested by {username} with Id {certificate.Id} redirecting back to Certificate Check.");
return(new RedirectToActionResult("Check", "CertificateCheck", null));
}
Logger.LogDebug($"Certificate for CertificateVersionViewModel requested by {username} with Id {certificate.Id} redirecting to {nextAction.ControllerName} {nextAction.ActionName}");
return(nextAction);
}
