public async Task <IActionResult> ReviewStandardVersions(string iFateReferenceNumber)
{
var contact = await GetUserContact();
var organisation = await _orgApiClient.GetOrganisationByUserId(contact.Id);
var applications = await GetWithdrawalApplications(contact.Id, iFateReferenceNumber);
var versions = await _standardVersionApiClient.GetEpaoRegisteredStandardVersions(organisation.EndPointAssessorOrganisationId, iFateReferenceNumber);
var standard = versions.First();
return(View(new ReviewStandardVersionsViewModel()
{
IFateReferenceNumber = iFateReferenceNumber,
Level = standard.Level,
StandardName = standard.Title,
Versions = versions.Select(x => new ReviewStandardVersion()
{
Version = x.Version,
AbleToWithdraw = !applications.Any(a => a.ApplyData.Apply.Versions != null &&
a.ApplyData.Apply.Versions.Contains(x.Version))
})
.OrderByDescending(x => x.Version)
.ToList()
}));
}
public async Task <IActionResult> TypeOfWithdrawal(TypeOfWithdrawalViewModel viewModel)
{
if (string.IsNullOrEmpty(viewModel.TypeOfWithdrawal))
{
ModelState.AddModelError(nameof(viewModel.TypeOfWithdrawal), "Select if you’re withdrawing from a standard or the register");
}
if (ModelState.IsValid)
{
if (viewModel.TypeOfWithdrawal == ApplicationTypes.OrganisationWithdrawal)
{
var contact = await GetUserContact();
var organisation = await _orgApiClient.GetOrganisationByUserId(contact.Id);
var createApplicationRequest = await _applicationService.BuildOrganisationWithdrawalRequest(
contact,
organisation,
_config.ReferenceFormat);
var id = await _applicationApiClient.CreateApplication(createApplicationRequest);
return(RedirectToAction(
nameof(ApplicationController.Sequence),
nameof(ApplicationController).RemoveController(),
new { Id = id, sequenceNo = ApplyConst.ORGANISATION_WITHDRAWAL_SEQUENCE_NO }));
}
else if (viewModel.TypeOfWithdrawal == ApplicationTypes.StandardWithdrawal)
{
return(RedirectToAction(nameof(ChooseStandardForWithdrawal), nameof(ApplyForWithdrawalController).RemoveController()));
}
}
return(RedirectToAction(nameof(TypeOfWithdrawal), nameof(ApplyForWithdrawalController).RemoveController()));
}
public async Task <IActionResult> AccessDenied()
{
if (TempData.Keys.Contains(nameof(PrivilegeAuthorizationDeniedContext)))
{
var deniedContext = JsonConvert
.DeserializeObject <PrivilegeAuthorizationDeniedContext>(TempData[nameof(PrivilegeAuthorizationDeniedContext)]
.ToString());
var userId = Guid.Parse(User.FindFirst("UserId").Value);
var user = await _contactsApiClient.GetById(userId);
OrganisationResponse organisation = null;
try
{
organisation = await _organisationsApiClient.GetOrganisationByUserId(userId);
}
catch (Exception ex)
{
_logger.LogWarning(ex.Message, ex);
if (user.OrganisationId == null && user.Status == ContactStatus.Live)
{
return(RedirectToAction("Index", "OrganisationSearch"));
}
}
if (user.OrganisationId != null && user.Status == ContactStatus.InvitePending)
{
return(RedirectToAction("InvitePending", "Home"));
}
if (organisation != null && organisation.Status == OrganisationStatus.Applying ||
organisation.Status == OrganisationStatus.New)
{
return(RedirectToAction("Index", "Dashboard"));
}
var privilege = (await _contactsApiClient.GetPrivileges()).Single(p => p.Id == deniedContext.PrivilegeId);
var usersPrivileges = await _contactsApiClient.GetContactPrivileges(userId);
return(View("~/Views/Account/AccessDeniedForPrivilege.cshtml", new AccessDeniedViewModel
{
Title = privilege.UserPrivilege,
Rights = privilege.PrivilegeData.Rights,
PrivilegeId = deniedContext.PrivilegeId,
ContactId = userId,
UserHasUserManagement = usersPrivileges.Any(up => up.Privilege.Key == Privileges.ManageUsers),
ReturnController = deniedContext.Controller,
ReturnAction = deniedContext.Action,
IsUsersOrganisationLive = organisation?.Status == OrganisationStatus.Live
}));
}
else if (TempData.Keys.Contains("UnavailableFeatureContext"))
{
return(View("~/Views/Account/UnavailableFeature.cshtml"));
}
return(View());
}
public async Task <IActionResult> Index()
{
var userId = _contextAccessor.HttpContext.User.FindFirst("UserId")?.Value;
var organisation = await _organisationsApiClient.GetOrganisationByUserId(Guid.Parse(userId));
var response = await _contactsApiClient.GetAllContactsForOrganisationIncludePrivileges(organisation.EndPointAssessorOrganisationId);
return(View(response));
}
public async Task <IActionResult> Invited(Guid contactId)
{
var contact = await _contactsApiClient.GetById(contactId);
var organisation = await _organisationsApiClient.GetOrganisationByUserId(contactId);
return(View("~/Views/ManageUsers/InviteUser/Invited.cshtml", new InvitedViewModel {
Email = contact.Email, Organisation = organisation.EndPointAssessorName
}));
}
public async Task <IActionResult> ViewStandard(string standardReference)
{
var contact = await GetUserContact();
var org = await _orgApiClient.GetOrganisationByUserId(contact.Id);
var existingApplications = (await _applicationApiClient.GetStandardApplications(contact.Id))?
.Where(p => p.ApplicationStatus != ApplicationStatus.Declined);
var existingEmptyApplication = existingApplications.FirstOrDefault(x => x.StandardCode == null);
if (existingEmptyApplication != null)
{
return(RedirectToAction("ConfirmStandard", new { Id = existingEmptyApplication.Id, StandardReference = standardReference }));
}
else
{
var createApplicationRequest = await _applicationService.BuildInitialRequest(contact, org, _config.ReferenceFormat);
var id = await _applicationApiClient.CreateApplication(createApplicationRequest);
return(RedirectToAction("ConfirmStandard", new { Id = id, StandardReference = standardReference }));
}
}
