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)); }