public IResult CreateQualification(QualificationViewModel qualification)
{
var result = new Result
{
Operation = Operation.Create,
Status = Status.Success
};
try
{
var duplicatequalification = _qualificationRepository.GetFirstOrDefault(x => x.Name == qualification.Name);
if (duplicatequalification != null)
{
result.Status = Status.Fail;
result.Message = QualificationStatusNotification.DuplicateQualification;
result.Body = null;
}
else
{
var qualificationModel = new Qualifications();
qualificationModel.MapFromViewModel(qualification, (ClaimsIdentity)_principal.Identity);
_qualificationRepository.Create(qualificationModel);
_qualificationRepository.SaveChanges();
result.Body = qualificationModel;
}
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Error;
}
return(result);
}
public async Task <IActionResult> Edit(int id, QualificationViewModel qualification)
{
if (id != qualification.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(qualification.GetModel());
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QualificationExists(qualification.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
qualification.loadLists(_context);
return(View(qualification));
}
public IResult DeleteQualification(QualificationViewModel qualification)
{
var result = new Result
{
Operation = Operation.Delete,
Status = Status.Success
};
try
{
var qualificationObj = _qualificationRepository.GetFirstOrDefault(x => x.QualificationId == qualification.QualificationId);
if (qualificationObj != null)
{
qualificationObj.MapDeleteColumns((ClaimsIdentity)_principal.Identity);
_qualificationRepository.Update(qualificationObj);
_qualificationRepository.SaveChanges();
result.Message = QualificationStatusNotification.QualificationDeleted;
}
result.Body = qualificationObj;
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Error;
}
return(result);
}
// GET: Qualifications/Create
public IActionResult Create()
{
QualificationViewModel vm;
vm = new QualificationViewModel(_context);
return(View(vm));
}
private QualificationViewModel GetQualificationViewModel(Vacancy vacancy, IList <string> allQualifications)
{
var cancelRoute = RouteNames.Qualifications_Get;
if (!vacancy.Qualifications?.Any() ?? false)
{
if (_feature.IsFeatureEnabled(FeatureNames.EmployerTaskList))
{
if (_utility.TaskListCompleted(vacancy))
{
cancelRoute = RouteNames.EmployerCheckYourAnswersGet;
}
else
{
cancelRoute = RouteNames.Dashboard_Get;
}
}
else
{
cancelRoute = RouteNames.Vacancy_Preview_Get;
}
}
var vm = new QualificationViewModel
{
Title = vacancy.Title,
QualificationTypes = allQualifications,
CancelRoute = cancelRoute
};
return(vm);
}
public async Task <ActionResult> Edit(QualificationViewModel model)
{
try
{
await PopulateDropdowns(model.QualificationTypeCode);
if (ModelState.IsValid)
{
var updateQuaifications = Mapper.Map <QualificationDto>(model);
updateQuaifications.SubmittedDate = DateTime.Today;
if (User.IsInRole(UserRole.UGStudent.ToString()))
{
updateQuaifications.StudentId = base.LoggedInUserId;
updateQuaifications.FacultyCode = this.LoggedInUserFacultyCode;
}
else if (User.IsInRole(UserRole.FacultyStaff.ToString()))
{
updateQuaifications.FacultyCode = base.LoggedInUserFacultyCode;
}
string[] names = await _qualificationService.GetNamesByCode(model.QualificationTypeCode, model.SubjectCode, model.Result, model.SittingCode);
updateQuaifications.QualificationTitle = names[0];
updateQuaifications.SubjectTitle = names[1];
updateQuaifications.Result = names[2];
updateQuaifications.SittingTitle = names[3];
updateQuaifications.ActionUserName = base.LoggedInUserName;
//duplicate Validation
var isValid = await _studentQualificationService.ValidateQualification(updateQuaifications);
if (isValid)
{
await _studentQualificationService.UpdateQualification(updateQuaifications);
//Add success messge
ViewBag.SuccessMessage = Resources.ModelValidations.Message_Qualification_Edit_Success;
}
else
{
ModelState.AddModelError("", Resources.ModelValidations.Message_Qualification_Already_Exists);
}
}
else
{
ModelState.AddModelError("", Resources.ModelValidations.Message_Edit_All_Fields_Required);
}
return(PartialView("_Edit", model));
}
catch (Exception ex)
{
this.Logger.Error("Edit Qualification", ex);
ModelState.AddModelError("", Resources.ModelValidations.Message_Qualification_Edit_Error);
}
return(PartialView("_Edit", model));
}
private void SetQualificationViewModelFromEditModel(QualificationViewModel vm, QualificationEditModel m)
{
vm.QualificationType = m.QualificationType;
vm.Subject = m.Subject;
vm.Grade = m.Grade;
vm.Weighting = m.Weighting;
}
public static Qualification MapToDomainModel(QualificationViewModel viewModel)
{
return(new Qualification()
{
Description = viewModel.Description,
QualificationType = viewModel.QualificationType,
Name = viewModel.Name,
});
}
private QualificationViewModel GetQualificationViewModel(Vacancy vacancy, IList <string> allQualifications)
{
var vm = new QualificationViewModel
{
Title = vacancy.Title,
QualificationTypes = allQualifications,
CancelRoute = vacancy.Qualifications?.Any() == true ? RouteNames.Qualifications_Get : RouteNames.Vacancy_Preview_Get
};
return(vm);
}
public async Task <IActionResult> Create(QualificationViewModel qualification)
{
if (ModelState.IsValid)
{
_context.Add(qualification.GetModel());
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
qualification.loadLists(_context);
return(View(qualification));
}
public async Task <IActionResult> Create(QualificationViewModel vm)
{
if (ModelState.IsValid)
{
var result = await _qualificationService.CreateQualificationEmployeeAsync(_mapper.Map <QualificationDTO>(vm));
return(result.IsValid
? RedirectToAction("Index", "Employee", new { id = vm.IdEmployee })
: _oops.OutPutError("Employee", "Index", result.ErrorsList));
}
return(View(vm));
}
public async Task <ActionResult> Edit(QualificationViewModel collection)
{
try
{
var stringContent = new StringContent(JsonConvert.SerializeObject(collection).ToString(), Encoding.UTF8, "application/json");
var status = await service.Update(stringContent);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public JsonResult Add(QualificationViewModel model)
{
if (ModelState.IsValid)
{
var EntityMapped = Mapper.Map <Qualification>(model);
EntityMapped.UserId = CurrentUser.Id;
EntityMapped.CreatedDate = DateTime.Now;
_QualificationService.Add(EntityMapped);
return(Json(new { data = model, success = true }, JsonRequestBehavior.AllowGet));
}
var errors = ModelState.GetDistinctModelErrors();
return(Json(new { data = model, success = false, ErrorsList = errors }, JsonRequestBehavior.AllowGet));
}
public JsonResult Edit(QualificationViewModel model)
{
if (ModelState.IsValid)
{
var QualificationEntity = _QualificationService.GetBy(x => x.Id == model.Id && x.UserId == CurrentUser.Id);
QualificationEntity = Mapper.Map(model, QualificationEntity);
QualificationEntity.UpdateDate = DateTime.Now;
_QualificationService.Edit(QualificationEntity);
return(Json(new { data = model, success = true }, JsonRequestBehavior.AllowGet));
}
var errors = ModelState.GetDistinctModelErrors();
return(Json(new { data = model, success = false, ErrorsList = errors }, JsonRequestBehavior.AllowGet));
}
public IResult DeleteQualification([FromBody] QualificationViewModel qualificationView)
{
if (ModelState.IsValid)
{
var deleteQualification = _qualificationService.DeleteQualification(qualificationView);
return(deleteQualification);
}
return(new Result
{
Operation = Operation.Delete,
Status = Status.Fail,
Message = CommonErrorMessages.BadRequest,
Body = null
});
}
public ActionResult Add()
{
ViewBag.Title = Resources.PageTitle.Qualification_Add;
ViewBag.PageBar = GetPageBar(Resources.PageTitle.Qualification_Add);
ViewBag.Description = "";
var model = new QualificationViewModel();
model.AlvailableDegreeList = _cientificDegreeService.List().Select(x =>
new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Name.ToString()
}).ToList();
return(View(model));
}
/// <summary>
/// Create qualification view model from a qualification
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public static QualificationViewModel ToQualificationViewModel(
Qualification qualification,
IList <QualificationStep> steps,
List <User> users,
IEnumerable <Publication> trainingPublications)
{
var model = new QualificationViewModel
{
QualificationId = qualification.QualificationId,
Folder = qualification.Publication.GetFolder(),
FolderPath = qualification.Publication.GetFolderPath(),
ProcessName = $"{qualification.Publication.Process.Label} (v{qualification.Publication.Version})",
Qualifier = qualification.GetQualifier(users),
Trainer = qualification.GetTrainer(users, trainingPublications),
Operator = qualification.User.FullName,
TrainingStartDate = qualification.GetTrainingStartDate(trainingPublications),
TrainingEndDate = qualification.GetTrainingEndDate(trainingPublications),
PublicationName = qualification.Publication.Label,
Result = qualification.IsQualified ?? false,
QualificationDate = qualification.EndDate.Value,
Notes = qualification.Comment,
Teams = qualification.User.Teams.Select(t => t.Name).Distinct().ToList(),
PercentageResult = qualification.Result.Value,
Steps = steps.Select(s => new QualificationStepViewModel
{
QualificationStepId = s.QualificationStepId,
// If qualification step id, it means we are addin a parent task so we do not have any date
Date = s.QualificationStepId != 0 ? s.Date.ToShortDateString() : "",
Comment = s.IsParent != true ? s.Comment : "",
Wbs = s.PublishedAction.WBS,
QualificationId = s.QualificationId,
PublishedActionId = s.PublishedActionId,
QualifierId = s.QualifierId,
ActionLabel = s.PublishedAction.Label,
IsQualified = s.IsQualified,
QualifierName = s.User != null ? s.User.FullName : "",
Level = s.Level,
IsParent = s.IsParent,
colorCondition = s.IsQualified == true && s.IsParent != true ? "readCell" : s.IsQualified == false && s.IsParent != true ? "notReadCell" : "",
}).ToList()
};
return(model);
}
public async Task <JsonResult> Reject(long id, long studentId, string remark)
{
QualificationViewModel model = new QualificationViewModel();
try
{
byte[] remarkBytes = Encoding.ASCII.GetBytes(remark);
if (string.IsNullOrWhiteSpace(remark) || remark.Length > MaxRemarkSize || remarkBytes.Length > MaxRemarkSize)
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Reject_Remark_Len }, JsonRequestBehavior.AllowGet));
}
else
{
//update remark
var qualification = new QualificationDto {
StudentQualificationId = id, StudentId = studentId, Remark = remark, ActionUserName = this.LoggedInUserName
};
if (User.IsInRole(UserRole.FacultyStaff.ToString()))
{
qualification.FacultyCode = base.LoggedInUserFacultyCode;
}
var result = await this._studentQualificationService.RejectQualification(qualification);
if (result > 0)
{
return(Json(new { Status = true, Message = Resources.ModelValidations.Message_Qualification_Reject_Success }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Reject_Fail }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
this.Logger.Error("Reject Qualification", ex);
return(Json(new { Status = false, Message = string.Format("{0}</br>{1}", Resources.ModelValidations.Message_Qualification_Reject_Fail, ex.Message) }, JsonRequestBehavior.AllowGet));
}
}
public IResult GetQualificationById(int id)
{
var result = new Result
{
Operation = Operation.Read,
Status = Status.Success
};
try
{
var qualification = new QualificationViewModel();
var getQualification = _qualificationRepository.GetByID(id);
result.Body = qualification.MapFromModel(getQualification);
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Error;
}
return(result);
}
// GET: Qualifications/Edit/5
public async Task <IActionResult> Edit(int?id)
{
QualificationViewModel vm;
if (id == 0)
{
vm = new QualificationViewModel(_context);
}
else
{
var qualification = await _context.Qualification.FindAsync(id);
if (qualification == null)
{
return(NotFound());
}
vm = new QualificationViewModel(_context, qualification);
}
return(View(vm));
}
public virtual ActionResult EditQualifications(string username, bool editingMyRecord, QualificationViewModel qualifications)
{
this.Validate(qualifications, string.Empty);
var person = userRepository.GetUser(username).Person;
if (!ModelState.IsValid)
return View(MVC.PersonnelRecords.Views.EditRecord, GeneratePersonnelRecordViewModel(person, editingMyRecord));
if (editingMyRecord)
return RedirectToAction(MVC.PersonnelRecords.EditMyRecord());
else
return RedirectToAction(MVC.PersonnelRecords.EditRecord(username));
}
public EditQualificationView(QualificationViewModel editQualification, QualificationService qualificationService) : this()
{
_editQualification = new EditQualificationViewModel(editQualification, qualificationService);
DataContext = _editQualification;
}
public async Task <OneOf <NotFound, TLevelDetailViewModel> > Handle(Query request, CancellationToken cancellationToken)
{
var tLevel = await _sqlQueryDispatcher.ExecuteQuery(new GetTLevel()
{
TLevelId = request.TLevelId
});
if (tLevel == null)
{
return(new NotFound());
}
var getProvider = _cosmosDbQueryDispatcher.ExecuteQuery(
new Core.DataStore.CosmosDb.Queries.GetProviderById()
{
ProviderId = tLevel.ProviderId
});
var getSqlProvider = _sqlQueryDispatcher.ExecuteQuery(
new Core.DataStore.Sql.Queries.GetProviderById {
ProviderId = tLevel.ProviderId
});
var getVenues = _sqlQueryDispatcher.ExecuteQuery(
new GetVenuesByIds()
{
VenueIds = tLevel.Locations.Select(l => l.VenueId)
});
await Task.WhenAll(getProvider, getSqlProvider, getVenues);
var provider = await getProvider;
var sqlProvider = await getSqlProvider;
var venues = await getVenues;
var feChoice = await _cosmosDbQueryDispatcher.ExecuteQuery(
new GetFeChoiceForProvider()
{
ProviderUkprn = provider.Ukprn
});
var providerContact = provider.ProviderContact
.SingleOrDefault(c => c.ContactType == "P");
return(new TLevelDetailViewModel()
{
TLevelId = tLevel.TLevelId,
TLevelDefinitionId = tLevel.TLevelDefinition.TLevelDefinitionId,
Qualification = new QualificationViewModel()
{
FrameworkCode = tLevel.TLevelDefinition.FrameworkCode,
ProgType = tLevel.TLevelDefinition.ProgType,
QualificationLevel = tLevel.TLevelDefinition.QualificationLevel.ToString(),
TLevelName = HtmlEncode(tLevel.TLevelDefinition.Name)
},
Provider = new ProviderViewModel()
{
ProviderName = sqlProvider.DisplayName,
Ukprn = provider.UnitedKingdomProviderReferenceNumber,
AddressLine1 = HtmlEncode(
ViewModelFormatting.ConcatAddressLines(
providerContact?.ContactAddress?.SAON?.Description,
providerContact?.ContactAddress?.PAON?.Description,
providerContact?.ContactAddress?.StreetDescription)),
AddressLine2 = HtmlEncode(providerContact?.ContactAddress?.Locality),
Town = HtmlEncode(providerContact?.ContactAddress?.PostTown ?? providerContact?.ContactAddress?.Items?.ElementAtOrDefault(0)),
Postcode = providerContact?.ContactAddress?.PostCode,
County = HtmlEncode(providerContact?.ContactAddress?.County ?? providerContact?.ContactAddress?.Items?.ElementAtOrDefault(1)),
Email = providerContact?.ContactEmail,
Telephone = providerContact?.ContactTelephone1,
Fax = providerContact?.ContactFax,
Website = ViewModelFormatting.EnsureHttpPrefixed(providerContact?.ContactWebsiteAddress),
LearnerSatisfaction = feChoice?.LearnerSatisfaction,
EmployerSatisfaction = feChoice?.EmployerSatisfaction
},
WhoFor = HtmlEncode(tLevel.WhoFor),
EntryRequirements = HtmlEncode(tLevel.EntryRequirements),
WhatYoullLearn = HtmlEncode(tLevel.WhatYoullLearn),
HowYoullLearn = HtmlEncode(tLevel.HowYoullLearn),
HowYoullBeAssessed = HtmlEncode(tLevel.HowYoullBeAssessed),
WhatYouCanDoNext = HtmlEncode(tLevel.WhatYouCanDoNext),
Website = ViewModelFormatting.EnsureHttpPrefixed(tLevel.Website),
StartDate = tLevel.StartDate,
Locations = tLevel.Locations
.Select(l => (Venue: venues[l.VenueId], Location: l))
.Select(t => new TLevelLocationViewModel()
{
TLevelLocationId = t.Location.TLevelLocationId,
VenueName = HtmlEncode(t.Venue.VenueName),
AddressLine1 = HtmlEncode(t.Venue.AddressLine1),
AddressLine2 = HtmlEncode(t.Venue.AddressLine2),
Town = HtmlEncode(t.Venue.Town),
County = HtmlEncode(t.Venue.County),
Postcode = HtmlEncode(t.Venue.Postcode),
Telephone = t.Venue.Telephone,
Email = t.Venue.Email,
Website = ViewModelFormatting.EnsureHttpPrefixed(t.Venue.Website),
Latitude = Convert.ToDecimal(t.Venue.Latitude),
Longitude = Convert.ToDecimal(t.Venue.Longitude)
})
.ToArray()
});
public virtual ActionResult EditQualifications(string username, bool editingMyRecord, QualificationViewModel qualifications)
{
this.Validate(qualifications, string.Empty);
var person = userRepository.GetUser(username).Person;
if (!ModelState.IsValid)
{
return(View(MVC.PersonnelRecords.Views.EditRecord, GeneratePersonnelRecordViewModel(person, editingMyRecord)));
}
if (editingMyRecord)
{
return(RedirectToAction(MVC.PersonnelRecords.EditMyRecord()));
}
else
{
return(RedirectToAction(MVC.PersonnelRecords.EditRecord(username)));
}
}
public async Task <JsonResult> Add(QualificationViewModel addQualification, HttpPostedFileBase certificate)
{
try
{
//Add Certificate
if (this.ModelState.IsValid)
{
var newQuaifications = Mapper.Map <QualificationDto>(addQualification);
newQuaifications.StudentId = this.LoggedInUserId;
newQuaifications.StudentName = User.Identity.Name;
newQuaifications.FacultyCode = this.LoggedInUserFacultyCode;
newQuaifications.Status = QualificationStatus.Pending;
string[] names = await _qualificationService.GetNamesByCode(addQualification.QualificationTypeCode, addQualification.SubjectCode, addQualification.Result, addQualification.SittingCode);
newQuaifications.QualificationTitle = names[0];
newQuaifications.SubjectTitle = names[1];
newQuaifications.Result = names[2];
newQuaifications.SittingTitle = names[3];
newQuaifications.ActionUserName = base.LoggedInUserName;
//duplicate Validation
var isValid = await _studentQualificationService.ValidateQualification(newQuaifications);
if (!isValid)
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Already_Exists }, JsonRequestBehavior.AllowGet));
}
else
{
//clear certificate Id if posted
newQuaifications.CertificateId = null;
//now check file
if (certificate != null)
{
//set certificate Id
var newCertificateId = await UploadCertificate(certificate);
if (newCertificateId == null)
{
return(Json(new { Status = false, Message = ViewData["errorMessage"] }));
}
else
{ //update certificate Id
newQuaifications.CertificateId = newCertificateId;
}
}
//now Add Qualification
var result = await _studentQualificationService.AddQualification(newQuaifications);
if (result > 0)
{
return(Json(new { Status = true, Message = Resources.ModelValidations.Message_Qualification_Add_Success }, JsonRequestBehavior.AllowGet));
}
}
}
}
catch (Exception ex)
{
this.Logger.Error("Add Qualification", ex);
}
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Add_Error }, JsonRequestBehavior.AllowGet));
}
