public int SaveNewCertificate(CertificateViewModel vmCert, string loggedInUser)
{
SSDF_Certificate sDF_Certificate = new SSDF_Certificate();
sDF_Certificate.CertificateDate = vmCert.CertificateDate;
//sDF_Certificate.CertificateID = vmCert.CertificateID;
sDF_Certificate.CertificateLevel = vmCert.Certifikat;
sDF_Certificate.CertificateNumber = vmCert.CertifikatNummer;
sDF_Certificate.FirstName = vmCert.Förnamn;
sDF_Certificate.LastName = vmCert.Efternamn;
sDF_Certificate.PersonNo = vmCert.Personnummer;
sDF_Certificate.Instructor = vmCert.Instruktör;
//TODO Fixa
sDF_Certificate.CreatedBy = loggedInUser;
sDF_Certificate.CreatedDate = DateTime.Now;
sDF_Certificate.LastEditBy = loggedInUser;
sDF_Certificate.LastEditDate = DateTime.Now;
try
{
db.SSDF_Certificate.Add(sDF_Certificate);
db.SaveChanges();
}
catch (Exception ex)
{
return(99);
}
return(0);
}
public async Task <IActionResult> Create([Bind("PkCertificationId,CertificationName,FkCertificationUserId")] CertificateViewModel tblUserCertification)
{
tblUserCertification.FkCertificationUserId = _usermanager.GetUserId(User);
string uniqucertename = null;
if (tblUserCertification.CertificationName != null)
{
string filefolder = Path.Combine(_environment.WebRootPath, "Files");
uniqucertename = Guid.NewGuid().ToString() + "_" + tblUserCertification.CertificationName.FileName;
string filepath = Path.Combine(filefolder, uniqucertename);
tblUserCertification.CertificationName.CopyTo(new FileStream(filepath, FileMode.Create));
}
TblUserCertification newCert = new TblUserCertification()
{
CertificationName = uniqucertename,
FkCertificationUserId = _usermanager.GetUserId(User)
};
_context.Add(newCert);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
//}
//ViewData["FkCertificationUserId"] = new SelectList(_context.Users, "Id", "Id", tblUserCertification.FkCertificationUserId);
return(View(tblUserCertification));
}
// GET: Certificates/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var certificate = await _context.Certificate
.Include(x => x.Applications)
.Include(x => x.Servers)
.Include(x => x.Groups)
.FirstOrDefaultAsync(x => x.Id == id);
if (certificate == null)
{
return(NotFound());
}
CertificateViewModel viewModel = _mapper.Map <CertificateViewModel>(certificate);
LoadFieldsViewModel(viewModel);
if (certificate.Applications != null)
{
viewModel.ApplicationIds = certificate.Applications.Select(x => x.ApplicationId.ToString());
}
if (certificate.Servers != null)
{
viewModel.ServerIds = certificate.Servers.Select(x => x.ServerId.ToString());
}
if (certificate.Groups != null)
{
viewModel.GroupIds = certificate.Groups.Select(x => x.GroupId.ToString());
}
return(View(viewModel));
}
public IHttpActionResult AddEditCertificateMaster(CertificateViewModel model)
{
try
{
if (!_IMaster_Repository.IsCertificateExist(model.CertificateName, model.CertificateCode))
{
bool status = _IMaster_Repository.InsertCertificateMaster(model);
if (status)
{
return(Ok(model.CertificateCode != 0 ? "Successfully updated" : "Successfully added"));
}
else
{
return(BadRequest("Opps! Something problem in your data"));
}
}
else
{
return(BadRequest(model.CertificateName + " certificate is already exist"));
}
}
catch (Exception ex)
{
return(BadRequest("Opps! Something went wrong"));
}
}
public ActionResult templatePreview(CertificateViewModel _CertificateViewMode, HttpPostedFileBase Photo)
{
try
{
try
{
HttpPostedFileBase photo = Request.Files["Photo"];
if (photo != null && photo.ContentLength > 0)
{
//var fileName = Path.GetFileName(photo.FileName);
//photo.SaveAs(Path.Combine(directory, fileName));
}
}
catch (Exception) { }
var result = ReturnImage(_CertificateViewMode, null);
return(Json(new
{
msg = result.FilePath
}));
}
catch (Exception ex)
{
return(Json(new
{
msg = ex.Message
}));
}
}
// GET: Certificates/Create
public IActionResult Create()
{
var viewModel = new CertificateViewModel();
LoadFieldsViewModel(viewModel);
return(View(viewModel));
}
public async Task <ActionResult <CertificateViewModel> > RemoveCertificateAsync(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
Certificate oldCertificate = (await certificateService.GetCertificateAsync(id)).Data;
if (oldCertificate == null)
{
return(NotFound("Certificate not found"));
}
TaskResult <Certificate>
result = await certificateService.RemoveCertificateAsync(oldCertificate);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(CertificateViewModel.CreateVm(result.Data)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(RemoveCertificateTypeAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <CertificateViewModel> > GetCertificateAsync(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
TaskResult <Certificate> result = await certificateService.GetCertificateAsync(id);
if (!result.Succeeded)
{
if (result.Data == null)
{
return(NotFound());
}
}
CertificateViewModel certificateTypeViewModel = CertificateViewModel.CreateVm(result.Data);
return(Ok(certificateTypeViewModel));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetCertificateAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public int SaveEditCertificate(CertificateViewModel vmCert, string loggedInUser)
{
SSDF_Certificate sDF_Certificate = db.SSDF_Certificate.Find(vmCert.CertificateID);
sDF_Certificate.CertificateDate = vmCert.CertificateDate;
sDF_Certificate.CertificateID = vmCert.CertificateID;
sDF_Certificate.CertificateLevel = vmCert.Certifikat;
sDF_Certificate.CertificateNumber = vmCert.CertifikatNummer;
sDF_Certificate.FirstName = vmCert.Förnamn;
sDF_Certificate.LastName = vmCert.Efternamn;
sDF_Certificate.PersonNo = vmCert.Personnummer;
sDF_Certificate.Instructor = vmCert.Instruktör;
//TODO Fixa
sDF_Certificate.LastEditBy = loggedInUser;
sDF_Certificate.LastEditDate = DateTime.Now;
try
{
db.Entry(sDF_Certificate).State = EntityState.Modified;
db.SaveChanges();
}
catch (Exception ex)
{
return(99);
}
return(0);
}
private void SetCertificate(Konsultant newConsultant, CertificateViewModel certif)
{
Certificate current = string.IsNullOrEmpty(certif.Id) ?
new Certificate
{
Name = certif.Name
} :
_certifService.GetById(Guid.Parse(certif.Id));
if (certif.IsDeleted)
{
_certifService.Delete(current);
}
else
{
newConsultant.Certificates.Add(
new OwnedCertificate
{
Certificate = current,
CertificateId = current.Id,
KonsultantId = newConsultant.Id,
Obtension = certif.Obtension,
EndOfValidity = certif.EndOfValidity,
IsRelevant = certif.IsRelevant
//Obtension = DateTime.ParseExact(certif.Obtension, "dd/MM/yyyy", CultureInfo.InvariantCulture),
//EndOfValidity = DateTime.ParseExact(certif.EndOfValidity, "dd/MM/yyyy", CultureInfo.InvariantCulture),
});
}
}
public IActionResult UpdateCertificate(CertificateViewModel model)
{
var convertedModel = _mapper.Map <CertificateDTO>(model);
_certificateService.UpdateCertificate(convertedModel);
return(RedirectToAction("MiscellaneousInfo", "Admin"));
}
public IActionResult Create()
{
CertificateViewModel _model = new CertificateViewModel();
_model.Companies = GetCompanies();
return(View(_model));
}
public async Task <IActionResult> PutCertificate(long id, CertificateViewModel certificateViewModel)
{
if (!ModelState.IsValid)
{
var errorMessages = ModelState.Values.SelectMany(modelStateEntry => modelStateEntry.Errors.Select(b => b.ErrorMessage)).ToList();
return(BadRequest(errorMessages));
}
if (id != certificateViewModel.Id)
{
var errorMessages = new List <string>()
{
"Certificate ID mismatch"
};
return(BadRequest(errorMessages));
}
if (!await certificateRepository.Exists(id))
{
var errorMessages = new List <string>()
{
$"Certificate with ID = {id} not found"
};
return(NotFound(errorMessages));
}
var citizenUser = citizenUserRepository.GetUserByLogin(certificateViewModel.OwnerLogin);
if (citizenUser == null)
{
var errorMessages = new List <string>()
{
$"CitizenUser with Login = {certificateViewModel.OwnerLogin} not found"
};
return(NotFound(errorMessages));
}
var validCertificate = citizenUser.Certificates.SingleOrDefault(c =>
string.Equals(c.Name, certificateViewModel.Name, StringComparison.OrdinalIgnoreCase) &&
c.Status == CertificateStatus.Valid) ?? new Certificate();
// Check if the valid certificate is not the input certificate.
if (validCertificate.Id != 0 && validCertificate.Id != certificateViewModel.Id)
{
var errorMessages = new List <string>()
{
$"The citizen {certificateViewModel.OwnerLogin} already has a valid certificate."
};
return(BadRequest(errorMessages));
}
mapper.Map(certificateViewModel, validCertificate);
validCertificate.Owner = citizenUser;
await certificateRepository.SaveAsync(validCertificate);
return(NoContent());
}
public async Task <IActionResult> Verify(CertificateViewModel model = null)
{
if (_user.IsAuthenticated)
{
ViewBag.User = _user.User; ViewBag.Roles = _user.Roles;
}
ViewData["Title"] = "Verify";
return(View(model ?? new CertificateViewModel()));
}
public ActionResult Edit(CertificateViewModel certificate)
{
if (ModelState.IsValid)
{
var entity = Mapper.Map <Certificate>(certificate);
certificateService.Update(entity);
return(RedirectToAction("Index"));
}
return(View(certificate));
}
public ActionResult CertificateDetail(int?id)
{
CertificateViewModel model = new CertificateViewModel();
if (id.HasValue)
{
model = new CertificateRepository().GetByID((int)id);
}
return(PartialView("_Certificate", model));
}
// GET: Certificate
public ActionResult Certificates()
{
CertificateViewModel model = new CertificateViewModel();
using (lear_DailiesCertificationRequirementEntities db = new lear_DailiesCertificationRequirementEntities())
{
model.Certifications = db.Certifications.ToList <Certification>();
}
return(View(model));
}
public IActionResult CreateCertificate(CertificateViewModel model)
{
ViewBag.ShowNavbar = false;
var convertedModel = _mapper.Map <CertificateDTO>(model);
_certificateService.CreateCertificate(convertedModel);
return(RedirectToAction("MiscellaneousInfo", "Admin"));
}
/// <summary>
/// Create Certificate View
/// </summary>
/// <param name="ProcessingMessage"></param>
/// <param name="userId"></param>
/// <returns></returns>
public ICertificateViewModel createECertListView(string ProcessingMessage, int userId)
{
var view = new CertificateViewModel
{
ProcessingMessage = ProcessingMessage,
UserId = userId
};
return(view);
}
public ActionResult DeleteCertificate(CertificateViewModel certificateViewModel)
{
if (certificateViewModel == null)
{
throw new ArgumentNullException(nameof(certificateViewModel));
}
var viewModel = certificateService.DeleteCerrtificate(certificateViewModel);
return(RedirectToAction("CertificationList"));
}
public PublicViewModel GetPublicViewModel(int page, string year, string find, Stage?stage,
ApplicationUser user)
{
page = page <= 0 ? 1 : page;
var list = _cacheService.GetList(user.Id);
list = _filterService.FilterOut(list, year, find, stage).ToList();
var count = list.Count;
var items = _pageService.GetDataToPage(list, count, ref page);
var certificates = items.Select(i =>
{
var certificateViewModel = new CertificateViewModel
{
Id = i.Id,
Title = i.Title,
Description = i.Description,
Date = i.Date,
Path = i.Path,
UserId = i.UserId
};
return(certificateViewModel);
});
var years = EnumerableHelper.GetYears(_localizer["All"]);
var stages = _stageService.GetStages(includeAllValue: true);
PublicViewModel pvm = new()
{
Certificates = certificates,
Find = find,
Stage = null,
Year = year,
Stages = new SelectList(stages, "EnumName", "Name"),
Years = new SelectList(years),
Name = user.Name,
Surname = user.Surname,
UniqueUrl = user.UniqueUrl,
MiddleName = user.MiddleName,
ImageData = user.Photo,
Controller = "Public",
Parameters = new Dictionary <string, string>
{
["uniqueUrl"] = user.UniqueUrl
},
PageViewModel = new PageViewModel(count, page, Common.PageSize)
};
return(pvm);
}
public ActionResult Create([Bind(Include = "CertificateID, CertificateDate, Certifikat, Förnamn, Efternamn, Personnummer, OriginalPersNo, CertifikatNummer, Instruktör")] CertificateViewModel vmCert)
{
if (ModelState.IsValid)
{
var ok = certResp.SaveNewCertificate(vmCert, User.Identity.GetUserName());
return(RedirectToAction("Index"));
}
ViewBag.Certifikat = new SelectList(db.SSDF_CertCodes, "CertCode", "Description", vmCert.Certifikat);
return(View(vmCert));
}
public ActionResult Create(Guid id)
{
var viewmodel = new CertificateViewModel
{
CertificateTypes = _listItemService.GetAllByCategory(ListItemCategoryType.Certificate).ToSelectList(),
CertificateCategories = _listItemService.GetAllByCategory(ListItemCategoryType.JobItemCategory).ToSelectList(),
JobItemId = id
};
return(PartialView("_Create", viewmodel));
}
public List <CertificateViewModel> CreateCertificateViewModel()
{
var sSDF_Certificate = db.SSDF_Certificate.Include(s => s.SSDF_CertCodes);
foreach (var cert in sSDF_Certificate)
{
var tmpVMCert = new CertificateViewModel(cert);
vmCertifikats.Add(tmpVMCert);
}
return(vmCertifikats);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Location,Purpose,GroupIds,ServerIds,ApplicationIds,Environment,InstallationLink,OtherInfo,Active")] CertificateViewModel certificateViewModel)
{
if (id != certificateViewModel.Id)
{
return(NotFound());
}
var certificateSaved = await _context.Certificate.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id);
certificateViewModel.From = certificateSaved.From;
certificateViewModel.To = certificateSaved.To;
certificateViewModel.SerialNumber = certificateSaved.SerialNumber;
certificateViewModel.SubjectName = certificateSaved.SubjectName;
certificateViewModel.Issuer = certificateSaved.Issuer;
certificateViewModel.Guid = certificateSaved.Guid;
certificateViewModel.Extension = certificateSaved.Extension;
ModelState.Remove("File");
if (ModelState.IsValid)
{
try
{
Certificate certificate = _mapper.Map <Certificate>(certificateViewModel);
PopulateModelWithSelectedValues(certificateViewModel.ApplicationIds, certificateViewModel.ServerIds, certificateViewModel.GroupIds, certificate);
//remove old certificateapplication dependency
_context.CertificateApplication.RemoveRange(_context.CertificateApplication.Where(x => x.CertificateId == id));
//remove old certificateserver dependency
_context.CertificateServer.RemoveRange(_context.CertificateServer.Where(x => x.CertificateId == id));
//remove old certificategroup dependency
_context.CertificateGroup.RemoveRange(_context.CertificateGroup.Where(x => x.CertificateId == id));
await _context.SaveChangesAsync();
_context.Update(certificate);
await _context.SaveChangesAsync();
TempData["Msg"] = certificateViewModel.Name + " sucessfully updated";
}
catch (DbUpdateConcurrencyException)
{
if (!CertificateExists(certificateViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
LoadFieldsViewModel(certificateViewModel);
return(View(certificateViewModel));
}
/// <summary>
/// </summary>
/// <param name="certificationModel"></param>
/// <returns></returns>
public ICertificateViewModel CreateEditCertificateView(ICertificationModel certificationModel)
{
var viewModel = new CertificateViewModel
{
CertificationId = certificationModel.CertificationId,
CertificationName = certificationModel.CertificationName,
Description = certificationModel.Description,
UserId = certificationModel.UserId,
ProcessingMessage = string.Empty
};
return(viewModel);
}
public ActionResult cards(CertificateViewModel _CertificateViewModel, HttpPostedFileBase Photo)
{
var result = ReturnImage(_CertificateViewModel, Photo);
if (result.File != null)
{
return(result.File);
}
else
{
return(RedirectToAction("IDCards"));
}
}
public ActionResult Edit([Bind(Include = "CertificateID,CertificateDate,Certifikat,Förnamn,Efternamn,Personnummer,OriginalPersNo,CertifikatNummer,Instruktör")] CertificateViewModel vmCert)
{
if (ModelState.IsValid)
{
//TODO fixa felhantering
var ok = certResp.SaveEditCertificate(vmCert, User.Identity.GetUserName());
//db.Entry(sSDF_Certificate).State = EntityState.Modified;
//db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vmCert));
}
public async Task <IActionResult> Edit(CertificateViewModel cvm, CancellationToken cancellationToken)
{
var _user = await _userManager.GetUserAsync(User);
if (ModelState.IsValid)
{
if (cvm.File != null)
{
if (cvm.File.CheckFileExtension(_fileSettings.Expansion))
{
ModelState.AddModelError("File", _localizer["FileExtensionError"]);
return(View(cvm));
}
using (var binaryReader = new BinaryReader(cvm.File.OpenReadStream()))
{
if (cvm.File.CheckFileSize(_fileSettings.MinSize, _fileSettings.SizeLimit))
{
ModelState.AddModelError("File", _localizer["FileSizeError"]);
return(View(cvm));
}
var path = $"/private/{Sha512Helper.GetRandomValue()}.jpg";
using (var stream = System.IO.File.Create(_appEnvironment.WebRootPath + path))
{
await cvm.File.CopyToAsync(stream, cancellationToken);
}
cvm.Path = path;
}
}
try
{
await _certificateService.UpdateCertificateAsync(cvm, _user.Id, cancellationToken);
}
catch (DbUpdateConcurrencyException ex)
{
_logger.LogError("An error occurred while updating the certificate: " + ex.Message);
return(RedirectToAction(nameof(Index)));
}
_logger.LogInformation($"Certificate {cvm.Id} changed by User {_user.Id}");
return(RedirectToAction(nameof(Details), new { id = cvm.Id }));
}
return(View(cvm));
}
// GET: Certificates/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CertificateViewModel certificate = Mapper.Map <CertificateViewModel>(certificateService.Get(id.Value));
if (certificate == null)
{
return(HttpNotFound());
}
return(View(certificate));
}
