public async Task <IHttpActionResult> SignUp(EmployerViewModel employerVM) { if (!ModelState.IsValid) { return(Ok(new { Error = "Invalid data submitted!" })); } var user = new ApplicationUser { UserName = employerVM.Email, Email = employerVM.Email, IsEmployer = true }; try { var result = await UserManager.CreateAsync(user, employerVM.Password); employerVM.AuthID = user.Id; await employerService.CreateEmployerAsync(employerVM); } catch (Exception) { return(Ok(new { Error = "Someting went wrong while creating user profile!" })); } return(Ok(new { Success = "User account created successfully!" })); }
//Edit Profile public async Task <IActionResult> EditProfile(int?id) { if (id == null) { return(NotFound()); } var model = await _context.Employer.FindAsync(id); if (model == null) { return(NotFound()); } EmployerViewModel vm = new EmployerViewModel { Id = model.Id, Name = model.Name, Description = model.Description, CEOName = model.CEOName, Location = model.Location, PhoneNumber = model.PhoneNumber, Mail = model.Mail, Password = model.Password, }; return(View(vm)); }
public async Task <ActionResult> Register(EmployerViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(RedirectToAction("Index", "Home")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> CreateEmployer(EmployerViewModel viewModel) { if (!this.ModelState.IsValid) { return(this.View(viewModel)); } var user = new ApplicationUser { UserName = viewModel.Email, Email = viewModel.Email, Employer = new Employer { Eik = viewModel.Eik, Name = viewModel.EmployerName, City = viewModel.City, Country = viewModel.Country, ImageUrl = GlobalConstants.DefaultEmployerImage, }, FirstName = viewModel.FirstName, LastName = viewModel.LastName, PhoneNumber = viewModel.PhoneNumber, }; IdentityResult result = await this.userManager.CreateAsync(user, viewModel.Password); if (result.Succeeded) { await this.userManager.AddToRoleAsync(user, GlobalConstants.EmployerRoleName); this.TempData["InfoMessage"] = "Employer created successfully!"; } return(this.Redirect("/Administration/Dashboard/Users/")); }
public ActionResult RegisterEmployer() { var model = new EmployerViewModel(); model.Role = "Employer"; return(View(model)); }
public EmployerViewModel SaveEmployer(EmployerViewModel viewModel) { var employer = Mapper.Map <EmployerViewModel, Employer>(viewModel); employer = _employerService.SaveEmployer(employer); return(Mapper.Map <Employer, EmployerViewModel>(employer)); }
public MainWindow(EmployerContext context) { InitializeComponent(); this.db = context; StartData.Initialize(db); DataContext = new EmployerViewModel(db); }
public async Task <Employer> CreateEmployerFromViewModel(EmployerViewModel employerModel) { return(await _employerRepository.AddAsync(new Employer() { Address = employerModel.Address, PhoneNumber = employerModel.PhoneNumber, Name = employerModel.Name })); }
private void SetFilteredOrganisationsForPage(int page, EmployerViewModel vm, List <OrganisationViewModel> filteredLegalEntities) { var skip = (page - 1) * MaxLegalEntitiesPerPage; vm.Organisations = filteredLegalEntities .Skip(skip) .Take(MaxLegalEntitiesPerPage) .ToList(); }
private static void Main(string[] args) { // do this with Ninject var employerViewModel = new EmployerViewModel(new EventAggregator(), new MyRepository()); // this selection should actually be user input employerViewModel.SelectedEmployer = employerViewModel.Employers.First(); // select another one employerViewModel.SelectedEmployer = employerViewModel.Employers.Last(); }
public static EmployerViewModel MapDbModelToViewModel(Database.Employer dbModel) { var viewModel = new EmployerViewModel(); viewModel.Id = dbModel.Id; viewModel.Name = dbModel.Name; viewModel.UserId = dbModel.UserId; return(viewModel); }
public async Task UpdateEmployerFromViewModel(EmployerViewModel employerModel) { await _employerRepository.UpdateAsync(new Employer() { Id = employerModel.Id, Address = employerModel.Address, PhoneNumber = employerModel.PhoneNumber, Name = employerModel.Name }); }
public ActionResult Create(int bureauId) { var userId = User.Identity.GetUserId(); var bureau = _payrollBureauBusinessService.RetrieveBureau(bureauId); var model = new EmployerViewModel { BureauId = bureau.BureauId, BureauName = bureau.Name }; return(View(model)); }
public async Task <ActionResult> EditEmployer(EmployerViewModel model, string Id) { if (ModelState.IsValid) { var user = await employerManager.GetBaseUserByGuid(Id); var employer = await employerManager.Get(user.UserId); user.Email = model.EmailAdress; employer.Adress = model.Adress; employer.City = model.City; employer.CompanyName = model.CompanyName; employer.FirstName = model.FirstName; employer.LastName = model.LastName; employer.PostalCode = model.PostalCode; employer.Prefix = model.Prefix; employer.TelephoneNumber = model.TelephoneNumber; model.EmployerId = employer.EmployerId; await employerManager.Update(employer); model.Employees = employer.Employees; var modUser = await adminManager.GetBaseUserByName(User.Identity.Name); var alert = new Alert(); { alert.AlertId = Guid.NewGuid(); alert.EmployerId = employer.EmployerId; alert.AlertType = AlertType.Employer_Update; alert.AlertIsDeleted = false; alert.AlertCreateTS = DateTime.Now; alert.AlertUpdateTS = DateTime.Now; alert.UserId = modUser.UserId; }; await alertManager.CreateAsync(alert); var messageInfo = new AdminEditEmployerMessageBuilder( user.UserName, employer.CompanyName, employer.FirstName, employer.Prefix, employer.LastName, employer.TelephoneNumber, employer.PostalCode, employer.Adress, employer.City); await mailingService.SendMailAsync(messageInfo.Body, messageInfo.Subject, user.Email); return(View("EmployerProfile", model)); } return(View(model)); }
public static Database.Employer MapInsertModelToDbModel(EmployerViewModel model, Database.Employer newDomainModel = null) { if (newDomainModel == null) { newDomainModel = new Database.Employer(); newDomainModel.Id = Guid.NewGuid(); } newDomainModel.Name = model.Name; newDomainModel.UserId = model.UserId; return(newDomainModel); }
public ActionResult Create(EmployerViewModel viewModel) { try { var validationResult = _PayrollBureauBusinessService.EmployerAlreadyExists(viewModel.Employer.Name, viewModel.Email, null); if (!validationResult.Succeeded) { foreach (var error in validationResult.Errors) { ModelState.AddModelError("", error); } return(View(viewModel)); } //create employeruser and role var user = new ApplicationUser { UserName = viewModel.Email, Email = viewModel.Email, }; var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == "Employer").Id; user.Roles.Add(new IdentityUserRole { UserId = user.Id, RoleId = roleId }); var result = UserManager.Create(user, "Inland12!"); if (!validationResult.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError("", error); } } //create employer var userId = User.Identity.GetUserId(); viewModel.Employer.BureauId = viewModel.BureauId; viewModel.Employer.AspnetUserId = user.Id; viewModel.Employer.CreatedDateUtc = DateTime.UtcNow; viewModel.Employer.CreatedBy = userId; var employer = _payrollBureauBusinessService.CreateEmployer(viewModel.Employer); if (employer.Succeeded) { return(RedirectToAction("Index", "Employer")); } } catch (Exception ex) { ModelState.AddModelError("", ex); } return(RedirectToAction("Index", "Employer")); }
public ActionResult Edit(EmployerViewModel model) { var result = _payrollBureauBusinessService.UpdateEmployer(model.Employer); if (result.Succeeded) { return(RedirectToAction("Index", "Employer")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error); } }
public static EmployerViewModel Convert(this Employer employer) { var viewModel = new EmployerViewModel { EmployerId = employer.EmployerId, EdsUrn = employer.EdsUrn, FullName = employer.FullName, TradingName = employer.TradingName, Address = employer.Address.Convert(), Status = employer.EmployerStatus }; return(viewModel); }
/// <summary> /// /// </summary> /// <param name="employerVM"></param> /// <returns></returns> public async Task <EmployerViewModel> UpdateEmployer(EmployerViewModel employerVM) { var id = new ObjectId(employerVM._id); var filter = Builders <Employers> .Filter.Eq("_id", id); var update = Builders <Employers> .Update .Set("CompanyName", employerVM.CompanyName) .Set("Email", employerVM.Email) .Set("Location", employerVM.Location) .Set("MobileNo", employerVM.MobileNo); var result = await _db.Employers.UpdateOneAsync(filter, update); return(GetEmployerByID(employerVM._id.ToString())); }
public async Task <IActionResult> MyAccount(EmployerViewModel employer) { var user = await _userManager.GetUserAsync(HttpContext.User); Employer newEmployer = _employerService.GetAll().Where(e => e.UserId == user.Id).First(); newEmployer.JobConditions = employer.JobConditions; _employerService.UpdateItem(newEmployer); user.Email = employer.Email; user.UserName = employer.Nickname; user.Description = employer.Description; await _userManager.UpdateAsync(user); return(RedirectToAction("Index", "Home")); }
// GET: Employer/Create public ActionResult Create() { //var person = new Person(); //person.StateList = new SelectList(Helper.State); //return View(person); var viewModel = new EmployerViewModel() { Employer = new Employer(), Person = new Person(), Register = new RegisterViewModel() }; return(View(viewModel)); }
public MediatorResponse <EmployerViewModel> SaveEmployer(EmployerViewModel viewModel) { try { viewModel = _employerProvider.SaveEmployer(viewModel); return(GetMediatorResponse(AdminMediatorCodes.SaveEmployer.Ok, viewModel, EmployerViewModelMessages.EmployerSavedSuccessfully, UserMessageLevel.Info)); } catch (Exception ex) { _logService.Error($"Failed to save employer with id={viewModel.EmployerId}", ex); viewModel = _employerProvider.GetEmployer(viewModel.EmployerId); return(GetMediatorResponse(AdminMediatorCodes.SaveEmployer.Error, viewModel, EmployerViewModelMessages.EmployerSaveError, UserMessageLevel.Error)); } }
private void SetPager(string searchTerm, int page, EmployerViewModel vm, int filteredLegalEntitiesTotal) { var pager = new PagerViewModel( filteredLegalEntitiesTotal, MaxLegalEntitiesPerPage, page, "Showing {0} to {1} of {2} organisations", RouteNames.Employer_Get, new Dictionary <string, string> { { nameof(searchTerm), searchTerm } }); vm.Pager = pager; }
public string UploadedFileProfile(EmployerViewModel model) { string uniqueFileName = null; if (model.ProfileImage != null) { string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images"); uniqueFileName = Guid.NewGuid().ToString() + "_" + Path.GetFileName(model.ProfileImage.FileName); string filePath = Path.Combine(uploadsFolder, uniqueFileName); using (var fileStream = new FileStream(filePath, FileMode.Create)) { model.ProfileImage.CopyTo(fileStream); } } return(uniqueFileName); }
public async Task <IActionResult> MyAccount() { var user = await _userManager.GetUserAsync(HttpContext.User); Employer employer = _employerService.GetAll().Where(e => e.UserId == user.Id).First(); EmployerViewModel model = new EmployerViewModel() { Nickname = user.UserName, Description = user.Description, Email = user.Email, JobConditions = employer.JobConditions, Id = user.Id }; return(View(model)); }
public ActionResult Edit(int id) { var employer = _payrollBureauBusinessService.RetrieveEmployer(id); if (employer == null) { return(RedirectToAction("NotFound", "Error")); } var bureau = _payrollBureauBusinessService.RetrieveBureau(employer.BureauId); var model = new EmployerViewModel { BureauId = bureau.BureauId, BureauName = bureau.Name, Employer = employer }; return(View(model)); }
public async Task <IActionResult> EditProfile(int id, EmployerViewModel model) { if (id != model.Id) { return(NotFound()); } if (ModelState.IsValid) { try { string uniqueFileName = UploadedFileProfile(model); Employer employer = new Employer { Id = model.Id, Name = model.Name, ProfilePicture = uniqueFileName, Description = model.Description, CEOName = model.CEOName, Location = model.Location, PhoneNumber = model.PhoneNumber, Mail = model.Mail, Password = model.Password, }; _context.Update(employer); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EmployerExists(model.Id)) { return(NotFound()); } else { throw; } } } AppUser user = await userManager.GetUserAsync(User); if (model.Id != user.EmployerId) { return(RedirectToAction("AccessDenied", "Account", null)); } return(RedirectToPage("")); }
public ActionResult Create(EmployerViewModel viewModel) { try { //create Bureau var userId = User.Identity.GetUserId(); viewModel.Employer.BureauId = viewModel.BureauId; viewModel.Employer.CreatedBy = userId; var employer = _payrollBureauBusinessService.CreateEmployer(viewModel.Employer); if (!employer.Succeeded) { foreach (var error in employer.Errors) { ModelState.AddModelError("", error); } return(View(viewModel)); } //create employeruser and role var user = new ApplicationUser { UserName = viewModel.Email, Email = viewModel.Email, }; var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == "Employer").Id; user.Roles.Add(new IdentityUserRole { UserId = user.Id, RoleId = roleId }); var result = UserManager.Create(user, "Inland12!"); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError("", error); } } //create AspNetUser Employer _payrollBureauBusinessService.CreateAspNetUserEmployer(employer.Entity.EmployerId, user.Id); } catch (Exception ex) { ModelState.AddModelError("", ex); } return(RedirectToAction("Index", "Employer", new { bureauId = viewModel.BureauId })); }
public async Task <IHttpActionResult> CreateEmployerAsync(EmployerViewModel employerVM) { if (ModelState.IsValid) { try { var employer = await employerService.CreateEmployerAsync(employerVM); return(Ok(new { Success = employer })); } catch (Exception ex) { return(Ok(new { Error = "" + ex.Message })); } } return(Ok(new { Error = "Could Not Saved Data!" })); }
public async Task <IHttpActionResult> UpdateEmployer(EmployerViewModel employerVM) { if (!ModelState.IsValid) { return(Ok(new { Error = "ModelState Invalid!" })); } try { var employer = await employerService.UpdateEmployer(employerVM); return(Ok(new { Success = employer })); } catch (Exception ex) { return(Ok(new { Error = ex.Message })); } }