/// <summary>
/// Get the full details of each of the stages of the application provided.
/// If no application ID is provided, it is assumed that the we want details of the current
/// application in progress.
/// </summary>
/// <param name="applicationId"></param>
/// <param name="_ctx"></param>
/// <returns></returns>
public async Task <ApplicationDetailsViewModel> GetApplicationDetails(StudentPortalContext _ctx, int?applicationId = null)
{
Application application = await GetCurrentApplication(_ctx, applicationId);
ApplicationDetailsViewModel model = new ApplicationDetailsViewModel
{
Application = application,
PersonalDetails = await GetPersonalDetails(_ctx, applicationId),
Address = await GetAddress(_ctx, applicationId),
CourseSelection = await GetCourses(_ctx, applicationId),
Qualifications = await GetQualifications(_ctx, applicationId),
Education = await GetEducationHistory(_ctx, applicationId),
LearningSupport = await GetLearningSupport(_ctx, applicationId),
UserDisabilities = await _disabilityService.GetDisabilities(application, _ctx),
DisabilityString = await _disabilityService.ConvertDisabilitiesToString(application, _ctx),
Progress = await _ctx.ApplicationProgress.ToListAsync(),
Titles = await _ctx.Titles.ToListAsync(),
Genders = await _ctx.Genders.ToListAsync(),
Countries = await _ctx.Countries.ToListAsync(),
Ethnicities = await _ctx.Ethnicity.ToListAsync(),
Courses = await _ctx.Courses.ToListAsync(),
Schools = await _ctx.Schools.ToListAsync(),
Disabilities = await _ctx.Disabilities.ToListAsync(),
};
return(model);
}
public async Task <ActionResult> Update(int applicationId, int progressId)
{
Application application = await _applicationService.GetCurrentApplication(_ctx, applicationId);
application.Progress = progressId;
await _ctx.SaveChangesAsync();
// Gather application details to be included in the email
ApplicationDetailsViewModel model = await _applicationService.GetApplicationDetails(_ctx, application.Id);
Dictionary <string, string> parameters = new Dictionary <string, string> {
{ "Name", model.PersonalDetails.Forename },
{ "Institution", ViewBag.Institution }
};
// Send an email to the user to alert them of the change
await _mailService.SendEmailAsync(
emailAddress : model.PersonalDetails.EmailAddress,
subject : "Update on your application",
message : null,
emailTemplate : "ApplicationUpdate",
parameters : parameters
);
return(RedirectToAction("Details", routeValues: new { id = applicationId }));
}
public async Task <IActionResult> Details(Guid id, [FromServices] ICryptoServices crypto)
{
var model = await ApplicationDetailsViewModel.LoadAsync(_ctx, crypto, id);
if (model != null)
{
return(View(model));
}
return(NotFound());
}
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ApplicationDetailsViewModel model = await _applicationService.GetApplicationDetails(_ctx, id);
return(View(model));
}
public IActionResult Details(int id)
{
JobApplication job = applicationUoW.Repository.GetItem(id);
ApplicationDetailsViewModel model = new ApplicationDetailsViewModel
{
JobApplication = job,
Position = positionUoW.Repository.GetItem(job.PositionId)
};
return(View(model));
}
public async Task <IActionResult> ApplicationDetails(long did, long sid)
{
ViewBag.id = did;
Student stu = await _applicationDbContext.Students.Where(s => s.ID == sid).FirstOrDefaultAsync();
ApplicationDetailsViewModel applicationDetailsViewModel = new ApplicationDetailsViewModel
{
Stu = stu,
Did = did,
Sid = sid
};
return(View(applicationDetailsViewModel));
}
public async Task <ActionResult> Continue(int id)
{
await _applicationService.OwnsApplication(id, User.Identity.Name, _ctx, forceRedirect : true);
Session["ApplicationId"] = id;
ApplicationDetailsViewModel model = await _applicationService.GetApplicationDetails(_ctx, id);
// Don't allow you to continue an application that has already been submitted.
if (model.Application.Submitted)
{
Session["ApplicationId"] = null;
return(Redirect("~/"));
}
return(RedirectToAction("Manage"));
}
public async Task <ApplicationDetailsViewModel> GetViewModelForApplicationDetails(string applicationId, string userId)
{
_logger.LogInformation($"Executing GetViewModelForApplicationDetails with applicationId={applicationId}. (UserID: {userId})");
var application = _context.Applications
.Include(x => x.JobPosition)
.Include(x => x.User)
.FirstOrDefault(x => x.Id == applicationId);
if (application == null)
{
_logger.LogError($"Application with ID:{applicationId} not found. (UserID: {userId})");
throw new NotFoundException(_stringLocalizer["Application with ID:{0} not found.", applicationId]);
}
await _applicationsViewHistoriesService.AddApplicationsViewHistory(applicationId, userId);
var applicationStages = _context.ApplicationStages
.Include(x => x.ResponsibleUser)
.Include(x => x.AcceptedBy)
.Where(x => x.ApplicationId == application.Id).OrderBy(x => x.Level);
var viewHistories = await _context.ApplicationsViewHistories
.Where(x => x.ApplicationId == application.Id)
.OrderByDescending(x => x.ViewTime)
.Take(10)
.ToListAsync();
foreach (var viewHistory in viewHistories)
{
viewHistory.ViewTime = viewHistory.ViewTime.ToLocalTime();
}
var vm = new ApplicationDetailsViewModel()
{
Id = application.Id,
User = _mapper.Map <ApplicationUser, UserDetailsViewModel>(application.User),
JobPosition = _mapper.Map <JobPosition, JobPositionViewModel>(application.JobPosition),
CvFileUrl = _cvStorageService.UriFor(application.CvFileName),
CreatedAt = application.CreatedAt.ToLocalTime(),
ApplicationsViewHistories = viewHistories,
ApplicationStages = applicationStages.ToList()
};
return(vm);
}
public async Task <ActionResult> Manage()
{
Application application = await _applicationService.GetCurrentApplication(_ctx);
await _applicationService.OwnsApplication(application.Id, User.Identity.Name, _ctx, forceRedirect : true);
ApplicationDetailsViewModel model = await _applicationService.GetApplicationDetails(_ctx, application.Id);
// Mark the application as complete if all sections have been filled out.
if (!application.Complete && model.Complete)
{
application.Complete = true;
await _ctx.SaveChangesAsync();
}
return(View(model));
}
public ApplicationDetailsViewModel GetApplicationDetailsViewModel(Guid id)
{
var creditApplication = unitOfWork.GetRepository <CreditApplication>().GetById(id);
ApplicationDetailsViewModel applicationDetailsModel = new ApplicationDetailsViewModel();
if (creditApplication.Client.ClientGroup == ClientGroup.PrivatePerson)
{
LegalPerson client = unitOfWork.GetRepository <LegalPerson>().GetById(creditApplication.ClientId);
applicationDetailsModel.ClientName = client.FirstName + " " + client.LastName;
}
else
{
applicationDetailsModel.ClientName = unitOfWork.GetRepository <JuridicalPerson>().GetById(creditApplication.ClientId).Name;
}
AutoMapper.Mapper.Map(creditApplication, applicationDetailsModel);
return(applicationDetailsModel);
}
public IActionResult Details(int id, bool isEditing)
{
var baseModel = DatabaseReader.GetApplications(context, User.GetExternalId(), User.GetRole(), true)
.FirstOrDefault(application => application.Id == id);
if (!User.HasAccessToApplication(baseModel, context))
{
return(RedirectToAction("Index", "Application"));
}
var model = new ApplicationDetailsViewModel
{
ApplicationModel = baseModel,
IsEditing = isEditing && !User.IsInRole(UserRole.HR.ToString())
};
return(View(model));
}
public async Task <ActionResult> Submit()
{
Application application = await _applicationService.GetCurrentApplication(_ctx);
// Ensure user owns the application - not trying to submit someone elses
await _applicationService.OwnsApplication(application.Id, User.Identity.Name, _ctx, forceRedirect : true);
// Ensure the application has been completed
if (application.Complete)
{
// Mark the application and completed
await _applicationService.CompleteApplication(application, _ctx);
// Gather application details to be included in the confirmation email
ApplicationDetailsViewModel model = await _applicationService.GetApplicationDetails(_ctx, application.Id);
Dictionary <string, string> parameters = new Dictionary <string, string> {
{ "Name", model.PersonalDetails.Forename },
{ "ContactEmail", ViewBag.ContactEmail },
{ "ContactPhone", ViewBag.ContactPhone },
{ "Institution", ViewBag.Institution }
};
// Send a confirmation email to the user
await _mailService.SendEmailAsync(
emailAddress : model.PersonalDetails.EmailAddress,
subject : "Thank you for your application",
message : null,
emailTemplate : "ApplicationComplete",
parameters : parameters
);
Session["ApplicationId"] = null;
return(RedirectToAction("Thanks", "Home"));
}
return(Redirect("~/"));
}
private ApplicationDetailsViewModel GetApplicationDetails(CreditApplication creditApplication)
{
ApplicationDetailsViewModel applicationDetailsModel = new ApplicationDetailsViewModel();
if (creditApplication.Client.ClientGroup == ClientGroup.PrivatePerson)
{
LegalPerson client = unitOfWork.GetRepository <LegalPerson>().GetById(creditApplication.ClientId);
applicationDetailsModel.ClientName = client.FirstName + " " + client.LastName;
}
else
{
applicationDetailsModel.ClientName = unitOfWork.GetRepository <JuridicalPerson>().GetById(creditApplication.ClientId).Name;
}
AutoMapper.Mapper.Map(creditApplication, applicationDetailsModel);
var contract = applicationDetailsModel.Attachments.FirstOrDefault(x => x.IsContract);
if (contract != null)
{
applicationDetailsModel.Attachments.Remove(contract);
applicationDetailsModel.Contract = contract;
}
return(applicationDetailsModel);
}
public async Task <ActionResult> Save(int id, ApplicationDetailsViewModel viewModel)
{
// Find application to update in DB
var toUpdate = context.Application.Include(x => x.User).FirstOrDefault(x => x.IdApplication == id);
if (toUpdate == null || !User.HasAccessToApplication(toUpdate))
{
return(RedirectToAction("Index", "Application"));
}
if (toUpdate.Status != ApplicationStatus.Draft)
{
// If application was already submitted, withdraw it
toUpdate.Status = ApplicationStatus.Withdrawn;
await context.SaveChangesAsync();
// And create new application with data copied from previous one
var newModel = new HR_Project_Database.Models.Application
{
JobOfferId = toUpdate.JobOfferId,
UserId = toUpdate.UserId,
CvId = toUpdate.CvId,
AttachmentGroupId = toUpdate.AttachmentGroupId,
ApplicationMessageId = toUpdate.ApplicationMessageId,
Status = ApplicationStatus.Draft
};
context.Application.Add(newModel);
await context.SaveChangesAsync();
id = newModel.IdApplication;
toUpdate = newModel;
}
// If file with CV is selected, replace file in storage
if (viewModel.ApplicationModel.CV != null && viewModel.ApplicationModel.CV?.Length != 0)
{
// If no file in storage, generate new id for CV
if (toUpdate.CvId == null)
{
toUpdate.CvId = Guid.NewGuid();
await context.SaveChangesAsync();
}
StorageContext.ReplaceCVFile(toUpdate.CvId.Value, viewModel.ApplicationModel.CV);
}
// If new attachments are selected, add them to DB (creating new AttachmentGroup) and storage
if (viewModel.ApplicationModel.OtherAttachments != null && viewModel.ApplicationModel.OtherAttachments.Count != 0)
{
var attachmentGroup = new AttachmentGroup();
context.AttachmentGroup.Add(attachmentGroup);
await context.SaveChangesAsync();
var groupId = toUpdate.AttachmentGroupId = attachmentGroup.IdAttachmentGroup;
List <Attachment> attachments = new List <Attachment>();
foreach (var attachmentFile in viewModel.ApplicationModel.OtherAttachments)
{
attachments.Add(new Attachment {
AttachmentGroupId = groupId, Extension = Path.GetExtension(attachmentFile.FileName)
});
}
await context.AddRangeAsync(attachments);
await context.SaveChangesAsync();
StorageContext.UploadAttachmentGroup(attachments, viewModel.ApplicationModel.OtherAttachments);
}
// Replace message if necessary
ApplicationMessage message;
if ((message = context.ApplicationMessage.Find(toUpdate.ApplicationMessageId)) == null)
{
if (viewModel.ApplicationModel.Message == null)
{
return(RedirectToAction("Details", new { id = id, isEditing = true }));
}
message = new ApplicationMessage {
MessageContent = viewModel.ApplicationModel.Message
};
context.ApplicationMessage.Add(message);
await context.SaveChangesAsync();
toUpdate.ApplicationMessageId = message.IdApplicationMessage;
}
else
{
message.MessageContent = viewModel.ApplicationModel.Message;
}
await context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = id, isEditing = true }));
}