public void init() { repository = new RepositoryMock(); dataService = new DataService(repository); navigationService = new NavigationServiceMock(); registerEmployeeViewModel = new RegisterEmployeeViewModel(dataService, navigationService); }
public async Task <IActionResult> RegisterEmployeeCompany(RegisterEmployeeViewModel model) { model.Password = generatePasswordService.CreatePassword(); model.PasswordConfirm = model.Password; if (ModelState.IsValid) { User user = new User { Email = model.Email, UserName = userService.CreateLogin(model), IsPasswordChanged = false, IsTwoFactorOn = true }; var result = await employeeService.CreateEmployee(user, model); if (result.Succeeded) { employeeService.CreateEmployeeInfo(user, model); StringBuilder message = new StringBuilder("ваш логин: " + user.UserName + " ", 120);; message.AppendLine(" ваш пароль:" + model.Password); await SendMessage("Регистрация в интернет банкинге", message.ToString(), user); return(RedirectToAction("CompanyInfo", "Company", new { id = model.CompanyId })); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(View(model)); }
public async Task CreateAsync(RegisterEmployeeViewModel viewModel) { var employee = new EmployeeModel { EmployeeId = viewModel.EmployeeId, GlobalId = viewModel.GlobalId, CardId = viewModel.CardId, EmployeeType = viewModel.EmployeeType, Title = viewModel.Title, TitleThai = viewModel.TitleThai, FirstName = viewModel.FirstName, LastName = viewModel.LastName, FirstNameThai = viewModel.FirstNameThai, LastNameThai = viewModel.LastNameThai, Gender = viewModel.Gender, Height = viewModel.Height, Hand = viewModel.Hand, BirthDate = viewModel.BirthDate, HireType = viewModel.HireType, HireDate = viewModel.HireDate, AvailableFlag = true, ChangedDate = DateTime.Now, }; await _employeeService.AddAsync(employee); }
public IActionResult AddEmployee() { RegisterEmployeeViewModel r = new RegisterEmployeeViewModel(); foreach (var role in Rolemanager.Roles) { if (User.IsInRole("Super Admin") || User.IsInRole("Admin") && role.Name != "Admin" && role.Name != "Super Admin") { UserRoles user = new UserRoles() { RoleId = role.Id, RoleName = role.Name, isSelected = false }; r.Roles.Add(user); } } foreach (Claim claim in ClaimStore.claimstore) { UserClaim userClaim = new UserClaim() { ClaimType = claim.Type, ClaimValue = claim.Value, isSelected = false, }; r.Claims.Add(userClaim); } ViewBag.cities = util.getCities(); ViewBag.Stores = util.GetAllStores(); return(View(r)); }
public string CreateLogin(RegisterEmployeeViewModel model) { model.SecondName = Transliteration.Front(model.SecondName); model.FirstName = Transliteration.Front(model.FirstName); bool isUnique = false; rnd = new Random(); string fName = ""; string sName = model.SecondName; string login = ""; int i = 0; while (!isUnique) { if (i >= model.FirstName.Length) { while (!isUnique) { string rand = rnd.Next(0, 999).ToString(); login = fName + sName + rand; isUnique = IsUniqueAsync(login).Result; return(login); } } fName += model.FirstName[i]; i++; fName = fName.ToLower(); login = fName + sName; isUnique = IsUniqueAsync(login).Result; } return(login); }
public async Task <IActionResult> RegisterEmployee(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { var user = new IdentityUser { UserName = model.User.Email, Email = model.User.Email }; var result = await _userManager.CreateAsync(user, model.User.Password); if (result.Succeeded) { foreach (var role in model.RoleNames) { if (model.User.RoleName == role) { await _userManager.AddToRoleAsync(user, role); _companyHandler.AddEmployee(user.Id, _companyHandler.GetById(model.CompanyId)); return(RedirectToAction("IndexEmployer", "Employer")); } } } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } return(View(model)); }
public IActionResult RegisterEmployeeCompany(int companyId) { RegisterEmployeeViewModel employee = new RegisterEmployeeViewModel { CompanyId = companyId }; return(View(employee)); }
public IActionResult RegisterEmployee(string id) { RegisterEmployeeViewModel model = new RegisterEmployeeViewModel { CompanyId = id }; return(View(model)); }
public static Employee ToEmployeeDb(RegisterEmployeeViewModel employee, ApplicationUser applicationUser) { return(new Employee { Id = applicationUser.Id, FirstName = employee.FirstName, LastName = employee.LastName, CenterId = employee.CenterId }); }
public async Task <ActionResult> RegisterEmployeeUser(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { // Check to see if this user is in the existing database LogicLayer.UserManager usrMgr = new LogicLayer.UserManager(); try { if (usrMgr.FindUser(model.Email)) { // If this user already exists, we need to use the regular Register method return(RedirectToAction("Register", "Account")); } // Not an existing user, create a DataObjects.User without roles else { var employee = new DataObjects.User() { // These fields are need by sp_insert_user Email = model.Email, FirstName = model.GivenName, LastName = model.FamilyName, PhoneNumber = model.PhoneNumber, }; // Add the DataObjects.User to Employe table if (usrMgr.AddUser(employee)) { var employeeID = usrMgr.RetrieveUserIDFromEmail(model.Email); var user = new ApplicationUser() { EmployeeID = employeeID, GivenName = model.GivenName, FamilyName = model.FamilyName, UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, "newuser"); if (result.Succeeded) { return(RedirectToAction("Index", "Admin")); } AddErrors(result); } } } catch { // Creating Employee Failed return(View(model)); } } // ModelState was not valid return(View(model)); }
public async Task <IActionResult> GetUserById(string id) { var user = await Usermanager.FindByIdAsync(id); if (user != null) { RegisterEmployeeViewModel r = new RegisterEmployeeViewModel() { id = user.Id, FullName = user.FullName, Email = user.Email, City = util.getCities().FirstOrDefault(x => x.id == user.City).city, PhoneNumber = user.PhoneNumber, Photopath = user.Photopath, StreetAdress = user.StreetAdress, }; if (user.store_id != null) { r.store_id = (int)user.store_id; } if (User.IsInRole("Super Admin") || User.IsInRole("Admin")) { var userClaims = await Usermanager.GetClaimsAsync(user); var userRoles = await Usermanager.GetRolesAsync(user); if (user.store_id != null) { r.StoreName = util.GetAllStores().FirstOrDefault(x => x.store_id == user.store_id).StoreName; } r.addedBy = user.addedBy; foreach (var claim in userClaims) { UserClaim u = new UserClaim() { ClaimType = claim.Type, ClaimValue = claim.Value }; r.Claims.Add(u); } foreach (var role in userRoles) { UserRoles ro = new UserRoles() { RoleName = role }; r.Roles.Add(ro); } } return(View("~/Views/Home/Profile.cshtml", r)); } //not Found ViewBag.Name = "User"; return(View("ProductNotFound", id)); }
public ActionResult RegisterEmployee() { var viewModel = new RegisterEmployeeViewModel(); viewModel.Roles = new List <string>() { RoleName.Technician, RoleName.Manager }; return(View(viewModel)); }
public void ЕслиСоздаюСотрудника() { RegisterEmployeeViewModel model = ModelData.RegEmployeeSuccess(); TextToElement("FName", model.FirstName); TextToElement("SName", model.SecondName); TextToElement("TName", model.MiddleName); TextToElement("Position", model.Position); TextToElement("Email", model.Email); Click("id", "SendClick"); }
public async Task <IActionResult> Register(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { await _employeeViewModelService.CreateAsync(model); return(RedirectToAction(nameof(EmployeeList))); } return(View()); }
public void UpdateEmployee(User user, RegisterEmployeeViewModel model) { EmployeeInfo employeeInfo = context.EmployeeInfos.FirstOrDefault(e => e.UserId == model.UserId); employeeInfo.FirstName = model.FirstName; employeeInfo.SecondName = model.SecondName; employeeInfo.MiddleName = model.MiddleName; employeeInfo.Position = model.Position; context.EmployeeInfos.Update(employeeInfo); context.Users.Update(user); context.SaveChanges(); }
public async Task <ActionResult> RegisterEmployeeUser(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { // check to see if the user is in the existing database LogicLayer.UserManager usrMgr = new LogicLayer.UserManager(); try { if (usrMgr.FindUser(model.Email)) { // if the user already exists, we need to use the regular Register method return(RedirectToAction("Register", "Account")); } else // not an existing user, create a DataObjects.User without any roles { var employee = new DataObjects.User() { // these fields are needed by sp_insert_user Email = model.Email, FirstName = model.GivenName, LastName = model.FamilyName, PhoneNumber = model.PhoneNumber }; if (usrMgr.CreateEmployee(employee.FirstName, employee.LastName, employee.PhoneNumber, employee.Email)) // add the DataObjects.User to Employee table { var employeeID = usrMgr.RetrieveUserIdFromEmail(model.Email); var user = new ApplicationUser // if it worked, create an Identity user { EmployeeID = employeeID, GivenName = model.GivenName, FamilyName = model.FamilyName, UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, "newuser"); if (result.Succeeded) // go back to Admin/Index View { return(RedirectToAction("Index", "Admin")); } AddErrors(result); } } } catch { // creating employee failed return(View(model)); } } // modelstate was not valid return(View(model)); }
public async Task <IActionResult> Profile() { var user = await Usermanager.GetUserAsync(User); if (user != null) { RegisterEmployeeViewModel r = new RegisterEmployeeViewModel() { id = user.Id, FullName = user.FullName, Email = user.Email, City = util.getCities().FirstOrDefault(x => x.id == user.City).city, PhoneNumber = user.PhoneNumber, Photopath = user.Photopath, StreetAdress = user.StreetAdress, }; if (await Usermanager.IsInRoleAsync(user, "Super Admin") || await Usermanager.IsInRoleAsync(user, "Admin")) { var userClaims = await Usermanager.GetClaimsAsync(user); var userRoles = await Usermanager.GetRolesAsync(user); if (user.store_id != null) { r.StoreName = util.GetAllStores().FirstOrDefault(x => x.store_id == user.store_id).StoreName; } r.addedBy = user.addedBy; foreach (var claim in userClaims) { UserClaim u = new UserClaim() { ClaimType = claim.Type, ClaimValue = claim.Value }; r.Claims.Add(u); } foreach (var role in userRoles) { UserRoles ro = new UserRoles() { RoleName = role }; r.Roles.Add(ro); } } return(View(r)); } else { RedirectToAction("Login"); } return(View()); }
public async Task <ActionResult> RegisterEmployeeUser(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { LogicLayer.UserManager usrMgr = new LogicLayer.UserManager(); try { if (usrMgr.FindUser(model.Email)) { return(RedirectToAction("Register", "Account")); } else { var employee = new DataTransferObjects.PetUniverseUser { FirstName = model.GivenName, LastName = model.FamilyName, Email = model.Email, PhoneNumber = model.PhoneNumber, Address1 = model.AddressLine1, Address2 = model.AddressLine2, City = model.City, State = model.State, ZipCode = model.ZipCode }; if (usrMgr.CreateNewUser(employee)) { var employeeID = usrMgr.getUserByEmail(model.Email).PUUserID; var user = new ApplicationUser { EmployeeID = employeeID, GivenName = model.GivenName, FamilyName = model.FamilyName, UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, "newuser"); if (result.Succeeded) { return(RedirectToAction("Index", "Admin")); } AddErrors(result); } } } catch (Exception) { return(View(model)); } } return(View(model)); }
public static RegisterEmployeeViewModel RegEmployeeSuccess() { RegisterEmployeeViewModel model = new RegisterEmployeeViewModel { FirstName = "Rob", SecondName = "Stark", MiddleName = "Eddardovich", Email = "*****@*****.**", Position = "Boss", }; return(model); }
public async Task <ActionResult> Edit(RegisterEmployeeViewModel model) { try { User user = await userService.FindUserById(model.UserId); user.Email = model.Email; user.IsTwoFactorOn = model.TwoFactorOn; employeeService.UpdateEmployee(user, model); return(RedirectToAction("Index", "Employee", new { id = model.CompanyId })); } catch { return(View()); } }
public IActionResult NewEmployee(RegisterEmployeeViewModel registerEmployeeViewModel) { if (!_peopleRepository.IsUniqueLogin(registerEmployeeViewModel.Login, registerEmployeeViewModel.Email)) { ModelState.AddModelError("", "Логин или Email уже занят!"); } if (ModelState.IsValid) { _peopleRepository.AddHuman(registerEmployeeViewModel.Login, registerEmployeeViewModel.Email, Encryption.Encryption.GetHash(registerEmployeeViewModel.Password), registerEmployeeViewModel.Name, registerEmployeeViewModel.Surname, registerEmployeeViewModel.MiddleName, registerEmployeeViewModel.PhoneNumber, registerEmployeeViewModel.Role); return(RedirectToAction("Employees", "Staff")); } return(View(registerEmployeeViewModel)); }
public async Task <IActionResult> RegisterEmployeeAsync([Microsoft.AspNetCore.Mvc.FromBody] RegisterEmployeeViewModel model) { if (ModelState.IsValid) { var result = await _employeeService.RegisterEmployeeAsync(model); if (result.IsSuccess) { return(Ok(result)); } return(BadRequest(result)); } return(BadRequest("Some properties are not valid")); // Status Code: 400 }
public async Task <ActionResult> RegisterEmployee(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { //TODO: Add fields to user here so they will be saved to do the database var user = new AppUser { UserName = model.Email, Email = model.Email, PhoneNumber = model.PhoneNumber, FirstName = model.FirstName, MiddleInitial = model.MiddleInitial, LastName = model.LastName, EmployeeType = model.EmployeeType, Address = model.Address, City = model.City, State = model.State, Zip = model.Zip, DateofBirth = DateTime.Now }; var result = await UserManager.CreateAsync(user, model.Password); //TODO: Once you get roles working, you may want to add users to roles upon creation // --OR-- // await UserManager.AddToRoleAsync(user.Id, "Employee"); 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 <ActionResult> RegisterEmployee(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, UserType = "Employee" }; 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 https://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>"); UserManager.AddToRole(user.Id, "Employee"); Employee employee = new Employee() { FirstName = model.FirstName, LastName = model.LastName, Address = model.Address, PhoneNumber = model.PhoneNumber, ApplicationUserId = user.Id, CNIC = model.CNIC, HireDate = model.HireDate, Wage = model.Wage }; ApplicationDbContext db = new ApplicationDbContext(); db.employees.Add(employee); Console.WriteLine(employee); db.SaveChanges(); return(RedirectToAction("Index", "Home", null)); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <ActionResult> RegisterEmployee(RegisterEmployeeViewModel 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) { UserManager.AddToRole(user.Id, "Employee"); 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>"); try { EmployeeManager _employeeManager = new EmployeeManager(); if (_employeeManager.CreateEmployee(model.FirstName, model.LastName, model.PhoneNum, model.Zip, model.Email)) { UserManager.AddClaim(user.Id, new Claim(ClaimTypes.GivenName, model.FirstName)); UserManager.AddClaim(user.Id, new Claim(ClaimTypes.Surname, model.LastName)); } } catch (Exception) { ViewBag.Message = "Bad registration. Invalid username or password."; return(View()); } return(RedirectToAction("Index", "Home")); } AddErrors(result); } // If we got this far, something failed, redisplay form ViewBag.Message = "No."; return(View(model)); }
//[ValidateAntiForgeryToken] public async Task <IActionResult> RegisterEmployee([FromBody] RegisterEmployeeViewModel employeeModel) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = employeeModel.Email, Email = employeeModel.Email }; var result = await _userManager.CreateAsync(user, employeeModel.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); var createdEmployee = await _userManager.FindByEmailAsync(employeeModel.Email); await _userManager.AddToRoleAsync(createdEmployee, "DonationCenterDoctor"); var employeeDb = Mappers.MapperRegisterEmployee.ToEmployeeDb(employeeModel, createdEmployee); try { _employeeService.AddEmployee(employeeDb); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); //var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme); //await _emailSender.SendEmailConfirmationAsync(doctorModel.Email, callbackUrl); //await _signInManager.SignInAsync(user, isPersistent: false); _logger.LogInformation("User created a new account with password."); //return RedirectToLocal(returnUrl); return(Ok(employeeModel)); } catch (Exception ex) { return(BadRequest(ex.Message)); } } AddErrors(result); } // If we got this far, something failed, redisplay form return(BadRequest("Register employee failed")); }
public EmployeeInfo CreateEmployeeInfo(User user, RegisterEmployeeViewModel model) { bool chief = context.EmployeeInfos.FirstOrDefault(ei => ei.CompanyId == model.CompanyId && ei.Chief) == null; EmployeeInfo employee = new EmployeeInfo { UserId = user.Id, FirstName = model.FirstName, SecondName = model.SecondName, MiddleName = model.MiddleName, Position = model.Position, CompanyId = model.CompanyId, Chief = chief }; context.EmployeeInfos.Add(employee); context.SaveChanges(); return(employee); }
public async Task <ActionResult> RegisterEmployee(RegisterEmployeeViewModel 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) { result = await UserManager.AddToRoleAsync(user.Id, model.Role); } if (result.Succeeded) { var appUser = new AppUser() { EmailAddress = model.Email, Id = user.Id, PhoneNumber = model.PhoneNumber, NameFirst = model.NameFirst, NameLast = model.NameLast }; _context.AppUsers.Add(appUser); _context.SaveChanges(); // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // For more information on how to enable account confirmation and password reset please visit https://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", "Employee")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
//public ActionResult Details(int id) //{ // return View(); //} public async Task <ActionResult> Edit(int id) { EmployeeInfo employee = employeeService.FindEmployeeById(id); User user = await userService.FindUserById(employee.UserId); RegisterEmployeeViewModel model = new RegisterEmployeeViewModel { Email = user.Email, FirstName = employee.FirstName, SecondName = employee.SecondName, MiddleName = employee.MiddleName, Position = employee.Position, TwoFactorOn = user.IsTwoFactorOn, UserId = user.Id, CompanyId = employee.CompanyId }; return(View(model)); }
public async Task <ActionResult> RegisterEmployee(RegisterEmployeeViewModel model) { if (ModelState.IsValid) { var user = new User { UserName = model.Email, Email = model.Email, Surname = model.SurName, OrganizationalUnitId = model.Id, Name = model.UserName, PasswordHashed = System.Web.Helpers.Crypto.SHA256(model.Password) }; var result = await UserManager.CreateAsync(user, model.Password); // Roles var userStore = new UserStore <User>(db); var userManager = new UserManager <User>(userStore); // if (result.Succeeded) { userManager.AddToRole(user.Id, "employee"); //await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // For more information on how to enable account confirmation and password reset please visit https://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("RegisterEmployeeStepTwo", "Account")); } AddErrors(result); } // If we got this far, something failed, redisplay form ViewBag.Id = new SelectList(db.OrganizationalUnits, "Id", "Name"); return(View(model)); }