public static MainUser MapAddUserModelToUser(AddUserModel model) { MainUser u = new MainUser(); u.UserName = model.UserName; u.Password = model.Password; u.UserType = model.UserType; UserDetail d = new UserDetail(); d.FirstName = model.FirstName; d.LastName = model.LastName; d.Language = model.Language; d.PhoneNumber = model.PhoneNumber; d.BirthDate = model.BirthDate; d.HobbiesAndInterest = model.HobbiesAndInterest; d.CivilStatus = model.CivilStatus; d.Gender = model.Gender; d.Address = model.Address; d.Country = model.Country; d.State = model.State; u.Details = d; return(u); }
public JsonResult ThemUser(AddUserModel item) { var result = false; if (ModelState.IsValid) { var userByEmail = (from u in db.User where u.Email == item.txtEmail select u).FirstOrDefault(); if (userByEmail != null) { result = false; } else { User user = new User(); user.Email = item.txtEmail; user.LoginId = item.txtUser; user.Password = item.txtPass; user.IsActive = item.level; user.Balance = 0; db.User.Add(user); db.SaveChanges(); result = true; } // RedirectToAction("ThanhToan", "ThanhToan", new { @Idproduct = _idProduct }); } return(Json(new { result }, JsonRequestBehavior.AllowGet)); }
private Connection CreateConnection() { var addUserModel = new AddUserModel { Name = "name", Surname = "surname", Email = "*****@*****.**", Password = "******", }; User user = userController.Create(addUserModel); LoginModel model = new LoginModel { Email = "*****@*****.**", Password = "******", OS = "Windows", Browser = "Firefox" }; Connection connection = controller.Login(model); return(connection); }
public async Task <ApplicationUser> RegisterUser(AddUserModel userModel, string UserDepartment, bool IsHeadOfdepartment) { var _userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(_ctx)); ApplicationUser user = new ApplicationUser { UserName = userModel.UserName, Email = userModel.Email, EmailConfirmed = true }; var result = await _userManager.CreateAsync(user, userModel.Password); if (UserDepartment == "Procurement" && IsHeadOfdepartment == false) { var AddUserToProcurement = _userManager.AddToRole(user.Id, "Procurement Officer"); } if (UserDepartment != "Procurement" && IsHeadOfdepartment == false) { var AddUserToEmployee = _userManager.AddToRole(user.Id, "Employee"); } if (UserDepartment == "Procurement" && IsHeadOfdepartment == true) { var AddUserToProcurement = _userManager.AddToRole(user.Id, "Procurement Head"); } if (UserDepartment != "Procurement" && IsHeadOfdepartment == false) { var AddUserToEmployee = _userManager.AddToRole(user.Id, "Head of Department"); } return(user); }
public async Task <ActionResult> AddUser(AddUserModel model) { if (!ModelState.IsValid) { return(AddUser()); } var(userId, result) = await _addUserCommand.Execute(model, UserManager); if (!result.Succeeded) { model.GlobalSettingsTabEnumerations = GetGlobalSettingsTabsWithUsersSelected(); AddErrors(result); return(View(model)); } _editUserRoleCommand.Execute(new EditUserRoleModel { UserId = userId, RoleId = Role.Admin.Value.ToString() }); SuccessToastMessage("New User added successfully. \n Please inform the user of the initial password."); return(RedirectToAction("Users", "GlobalSettings")); }
public async Task <IActionResult> AddNewUser([FromBody] AddUserModel addUserModel) { if (ModelState.IsValid) { IdentityResult result, result1; AppUser findedUser = null; var user = new AppUser { UserName = addUserModel.Email, PasswordHash = addUserModel.password, Email = addUserModel.Email, EmailConfirmed = true, AgeRangeId = addUserModel.AgeRangeId }; result = await _userManager.CreateAsync(user, user.PasswordHash); if (result.Succeeded) { findedUser = await _userManager.FindByEmailAsync(user.Email); result1 = await _userManager.AddToRoleAsync(findedUser, "User"); await _signInManager.PasswordSignInAsync(addUserModel.Email, addUserModel.password, true, false); return(Ok("done")); } return(Ok(result)); } return(BadRequest("")); }
public async Task <IActionResult> CreateNewUser(AddUserModel model) { if (ModelState.IsValid) { UserModel user = new UserModel() { UserName = model.UserName, Email = model.Email, PhoneNumber = model.PhoneNumber, EmailConfirmed = model?.ConfirmEmail == true, EmailVerificationKey = model.EmailConfirmationString.ToUpper(), }; IdentityResult result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return(RedirectToAction("UsersList")); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } } return(View(model)); }
public async Task <IDataResult <Int64> > AddAsync(AddUserModel addUserModel) { if (addUserModel is null) { throw new ArgumentNullException(nameof(addUserModel)); } var validation = new AddUserModelValidator().Validate(addUserModel); if (validation.IsError) { return(DataResult <Int64> .Error(validation.Message)); } addUserModel.SignIn = _signInService.CreateSignIn(addUserModel.SignIn); var userEntity = UserFactory.Create(addUserModel); userEntity.Add(); await _userRepository.AddAsync(userEntity).ConfigureAwait(false); await _unitOfWork.SaveChangesAsync().ConfigureAwait(false); return(DataResult <Int64> .Success(userEntity.Id)); }
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel) { var validation = new AddUserModelValidator().Valid(addUserModel); if (!validation.Success) { return(new ErrorDataResult <long>(validation.Message)); } addUserModel.Login = UserDomainService.GenerateHash(addUserModel.Login); addUserModel.Password = UserDomainService.GenerateHash(addUserModel.Password); var userDomain = UserDomainFactory.Create(addUserModel); userDomain.Add(); var userEntity = userDomain.Map <UserEntity>(); await UserRepository.AddAsync(userEntity); await DatabaseUnitOfWork.SaveChangesAsync(); return(new SuccessDataResult <long>(userEntity.UserId)); }
public async Task <ApplicationUser> AddUserAsync(AddUserModel model) { if (model == null) { return(null); } var user = new ApplicationUser { UserName = model.Username, Email = model.Email, EmailConfirmed = model.EmailConfirmed, Country = model.Country, PhoneNumber = model.PhoneNumber, }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { if (await _roleManager.RoleExistsAsync("User")) { if (!await _userManager.IsInRoleAsync(user, "User") && !await _userManager.IsInRoleAsync(user, "Admin")) { await _userManager.AddToRoleAsync(user, "User"); } } return(user); } return(null); }
public JsonResult Add(AddUserModel model) { CommonModelResult result = new CommonModelResult(); try { _userService.CreateNewUser(new LoginUserInfo() { UserId = model.UserId, FullName = model.FullName, Status = UserStatus.Enable, Rights = new List <UserRightCode>(CommonUtils.GetListDefaultUserRightCode()) }, CommonConstant.DefaultPassword); } catch (BusinessException exception) { _logger.DebugFormat("BusinessException: {0}-{1}", exception.ErrorCode, exception.Message); result.ErrorCode = exception.ErrorCode; result.ErrorDescription = CommonUtils.GetErrorMessage(exception); } catch (Exception exception) { _logger.Error(string.Format("Iternal error {0}", exception)); result.ErrorCode = ErrorCode.InternalErrorException; result.ErrorDescription = CommonUtils.GetEnumDescription(ErrorCode.InternalErrorException); } return(Json(result)); }
public IActionResult AddUser() { AddUserModel addUserModel = new AddUserModel(); addUserModel.Genders = _db.Genders.ToList(); return(View(addUserModel)); }
public User Create([FromBody] AddUserModel model) { if (userRepository.Exists(a => a.Email == model.Email)) { ModelState.ThrowModelError("email", "Cet adresse électronique est déjà utilisée"); } User user = new User { Name = model.Name, Surname = model.Surname, Email = model.Email }; string username = model.Name + model.Surname.Substring(0, 1).ToUpper() + model.Surname.Substring(1); long usernameUsage = userRepository.Count(a => a.Name == model.Name && a.Surname == model.Surname); if (usernameUsage == 0) { user.Username = username; } else { user.Username = username + usernameUsage; } string password = passwordHasher.HashPassword(user, model.Password); user.Password = password; user = userRepository.Save(user); return(user); }
public async Task ShouldAddUserWithRequirePasswordChangeAsTrue() { var guidString = Guid.NewGuid().ToString("N"); var newUser = new AddUserModel { Email = $"test{guidString}@test.com", Password = "******", ConfirmPassword = "******" }; await ScopedAsync <UserManager <AdminAppUser> >(async manager => { var command = new AddUserCommand(); var(userId, identityResult) = await command.Execute(newUser, manager); string.Join(Environment.NewLine, identityResult.Errors.Select(x => x.Description)).ShouldBe(""); identityResult.Succeeded.ShouldBeTrue(); var addedUser = Query(userId); addedUser.UserName.ShouldBe($"test{guidString}@test.com"); addedUser.Email.ShouldBe($"test{guidString}@test.com"); addedUser.RequirePasswordChange.ShouldBe(true); }); }
public ActionResult Add(AddUserModel model) { if (ModelState.IsValid) { if (_empRepo.AlreadyRegistered(model.UserName)) { ModelState.AddModelError("UserName", "UserName already used."); } else { if (IsValidCountryAndStates(model.Country, model.State)) { MainUser u = UserHelper.MapAddUserModelToUser(model); u.IsActive = true; u.AddedDate = DateTime.Now; _empRepo.Add(u); LogActivity("Add User", u.UserName + " is Added by " + User.Identity.Name); return(RedirectToAction("Index", "Employees")); } ModelState.AddModelError("Country", "Country or state is invalid"); } } model.Countries = GetCountries(); return(View(model)); }
public IActionResult AddUser(AddUserModel addUser) { if (!ModelState.IsValid) { return(View(addUser)); } UserAddModel user = new UserAddModel() { IntialBalance = addUser.IntialBalance, Name = addUser.Name, Password = addUser.Password, UserName = addUser.UserName, AdminUserId = User.FindFirstValue(ClaimTypes.NameIdentifier) }; var result = userService.AddUser(user); if (!result.IsSuccessFul) { ModelState.AddModelError("", result.Data); return(View(addUser)); } return(RedirectToAction("UserList", "Account")); }
public async Task <IActionResult> Index() { var protectorProvider = _provider.GetService <IDataProtectionProvider>(); var protector = protectorProvider.CreateProtector(_dataProtectionKeys.ApplicationUserKey); var userProfile = await _userSvc.GetUserProfileByIdAsync(protector.Unprotect(_cookieSvc.Get("user_id"))); var addUserModel = new AddUserModel(); var protectorSendGrid = protectorProvider.CreateProtector(_dataProtectionKeys.SendGridProtectionKey); var dashboard = new DashBoardModel(); _adminBaseViewModel = new AdminBaseViewModel { Profile = userProfile, AddUser = addUserModel, AppSetting = _appSettings, SmtpOption = _writableSvcSmtpOptions.Value, SendGridOption = _writableSvcSendGridOptions.Value, SiteWideSetting = _writableSiteWideSettings.Value, Dashboard = dashboard }; _adminBaseViewModel.SendGridOption.SendGridKey = protectorSendGrid.Protect(_adminBaseViewModel.SendGridOption.SendGridKey); _adminBaseViewModel.SmtpOption.SmtpPassword = protectorSendGrid.Protect(_adminBaseViewModel.SmtpOption.SmtpPassword); return(View("Index", _adminBaseViewModel)); }
public PartialViewResult Add() { var model = new AddUserModel(); ViewData["culture-options"] = _getUserCultureOptions.Get(); return(PartialView(model)); }
public ActionResult AddUser(AddUserModel model) { string userName = User.Identity.Name, roleName = null; if (ModelState.IsValid) { // Attempt to register the user MembershipCreateStatus createStatus; Membership.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out createStatus); if (createStatus == MembershipCreateStatus.Success) { using (hunterCVEntities context = new hunterCVEntities()) { roleName = context.Users.Where(u => u.UserName == userName).Single().Roles.Single().RoleName; var user = context.Users.Single(u => u.UserName == model.UserName); user.ApplicationRole = model.ApplicationRole; context.SaveChanges(); } Roles.AddUserToRole(model.UserName, roleName); return(RedirectToAction("Manage", "Account")); } } // If we got this far, something failed, redisplay form return(RedirectToAction("Manage", "Account")); }
public ActionResult AddNewUser(string login) { if ((Session["UserLogin"] == null) || (Session["UserLogin"] != null && Session["UserLogin"].ToString() != "admin")) { return(HttpNotFound()); } if (UserController.ContainsUser(login)) { ViewBag.UserAlreadyExist = true; var addUserModel = new AddUserModel(login); return(View("AddUser", addUserModel)); } else { foreach (var user in UserController.Users) { if (user.Login == login) { return(RedirectToAction("Index")); } } UserController.Users.Add(new UserProfile(login, new List <string>())); } return(RedirectToAction("Index")); }
public async Task <IActionResult> AddUser([FromBody] AddUserModel ajaxModel) { if (!IsClientRegistered(ajaxModel.authKey)) { return(StatusCode(403)); } //Na początku sprawdzamy czy nie ma już osoby o takim imieniu i nazwisku var user1 = (from a in db.Users where (a.forname.ToUpper() + a.surname.ToUpper()) == (ajaxModel.forname.ToUpper() + ajaxModel.surname.ToUpper()) select a).FirstOrDefault(); if (user1 != null) { //Sprawdzamy czy ten użytkownik jest włączony if (!user1.enabled) { user1.enabled = true; db.Users.Update(user1); await db.SaveChangesAsync(); return(Content("true")); } else { return(Content("false")); } } var user = new User(ajaxModel.forname, ajaxModel.surname); db.Users.Add(user); await db.SaveChangesAsync(); return(Content("true")); }
[HttpPost("customeradd")] //добавление пользователя - Ok public async Task <IActionResult> AddCustomer([FromBody] AddUserModel request) { if (ModelState.IsValid) { if (await unitOfWork.Customers.GetAsync(request.Email) == null) { var customer = new Customer() { Name = request.Name, UserName = request.Email, Email = request.Email, Address = request.Address, Code = request.Code, Discount = request.Discount }; string pass = new Generator().GetPass(); await unitOfWork.Customers.CreateAsync(customer, pass); return(Ok(pass)); } else { return(BadRequest("This user already exists")); } } else { return(BadRequest("Request model is invalid")); } }
public async Task <Users> AddUser(AddUserModel view, string role) { var user = new Users { Address = view.Address, Document = view.Document, FirstName = view.FirstName, LastName = view.LastName, Movil = view.Movil, Activo = view.Activo, DateRegistro = DateTime.Now, Email = view.Username, UserName = view.Username }; var result = await AddUserAsync(user, view.Password); if (result != IdentityResult.Success) { return(null); } var newUser = await GetUserByEmailAsync(view.Username); await AddUserToRoleAsync(newUser, role); return(newUser); }
public virtual ActionResult addUser(AddUserModel user) { Authentication auth = new Authentication(); if (auth.isAdmin(this) || Authentication.DEBUG_bypassAuth) { if (ModelState.IsValid) { LDAPConnection newConnection = new LDAPConnection(); List <string> userInfo = newConnection.create(user.UserName); //Code here for creating TARSUser object; this will require // changing the LDAPConnection.create function to only // return the user information that is pertinent to TARS /* * var userEntry = new TARSUser(); * userEntry.userName = userInfo[1]; * TARSUserDB.TARSUserList.Add(userEntry); */ return(RedirectToAction("userMaintanence")); } return(View(user)); } else { return(View("error")); } }
public IHttpActionResult PutUser(string id, AddUserModel user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } User _user = null; using (SoilCareEntities db = new SoilCareEntities()) { _user = db.Users.Find(id); if (_user == null) { return(NotFound()); } // Map model to entity Mapper.Map <AddUserModel, User>(user, _user); try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { throw; } } return(Ok()); }
public async Task <IActionResult> AddAsync(AddUserModel addUserModel) { var signIn = addUserModel.SignIn; await _userApplicationService.AddAsync(addUserModel); return(Result(await _userApplicationService.SignInAsync(signIn))); }
public async Task <IHttpActionResult> AddUser(AddUserModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new ApplicationUser() { UserName = model.UserName, Email = model.Email, //StudyGroupId = model.StudyGroupId }; IdentityResult result = await UserManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(GetErrorResult(result)); } //Add to role UserManager.AddToRole(user.Id, "User"); return(Ok()); }
public ActionResult CreateUser(AddUserModel model) { if (ModelState.IsValid) { try { HttpPostedFileBase file = Request.Files["ImageData"]; _UsersManagementService.CreateUser(file, model); TempData["Success"] = "Success"; return(RedirectToAction("AddUser")); } catch (Exception e) { Response.StatusCode = (int)HttpStatusCode.BadRequest; ModelState.AddModelError("", e.Message); TempData["Fail"] = "Fail"; return(View("AddUser", model)); } } else { TempData["ModelsError"] = "Error"; return(RedirectToAction("AddUser")); } }
public ActionResult AddUser() { if (Session["Email"] != null && Session["UserID"] != null) { ViewBag.ActiveMenu = "AddUser"; AddUserModel _AddUserModel = new AddUserModel(); DataSet dbInitial = _UsersManagementService.LoadDetail(Session["Email"].ToString()); _AddUserModel.Position = dbInitial.Tables[0].AsEnumerable().Select(row => new PositionModel { PositionId = Convert.ToInt32(row["GR_CODE"]), PositionName = Convert.ToString(row["DESCRIPTION"]) }); _AddUserModel.Area = dbInitial.Tables[1].AsEnumerable().Select(row => new AreaModel { AreaCode = Convert.ToInt32(row["AREA_CODE"]), AreaName = Convert.ToString(row["AREA_NAME"]) }); _AddUserModel.sex = _SystemTools.GetGender(); return(View(_AddUserModel)); } else { return(RedirectToAction("Login", "Account")); } }//..End User
public async Task <IActionResult> UpdateUser(AddUserModel model) { if (!this.ModelState.IsValid) { return(this.BadRequest()); } var user = await this.userManager.FindByNameAsync(model.UserName); if (user == null) { throw new ApplicationException($"Could not found a use with named {model.UserName}."); } if (model.Email != user.Email) { var setEmailResult = await this.userManager.SetEmailAsync(user, model.Email); if (!setEmailResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'."); } } if (model.PhoneNumber != user.PhoneNumber) { var setPhoneNumberResult = await this.userManager.SetEmailAsync(user, model.Email); if (!setPhoneNumberResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'."); } } bool changed = false; if (model.FirstName != user.FirstName) { user.FirstName = model.FirstName; changed = true; } if (model.LastName != user.LastName) { user.LastName = model.LastName; changed = true; } if (changed) { var updateUserResult = await this.userManager.UpdateAsync(user); if (!updateUserResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating user with ID '{user.Id}'."); } } return(this.Ok()); }
public ActionResult Create(AddUserModel User) { // var errors = ModelState //.Where(x => x.Value.Errors.Count > 0) //.Select(x => new { x.Key, x.Value.Errors }) //.ToArray(); var chkemailid = ChkValidEmailID(User.Email_id); if (chkemailid.Data != "false") { ModelState.AddModelError("Email_id" ,"This Email id has already Registered"); } if (ModelState.IsValid) { try { // string usrpwd = Encode(User.Usr_pwd); // Insert Product User_Info objnewUser = new User_Info(); objnewUser.UidNo = (db.User_Info.Max(i => (int?)i.UidNo) ?? 0) + 1; //Convert.ToInt32(db.PRODUCTs.Max(x => x.Pid)) + 1; objnewUser.First_name = User.First_name; objnewUser.Last_name = User.Last_name; objnewUser.Isactive = true; objnewUser.E_mail_id = User.Email_id; objnewUser.Mobile_number = User.Mobile_number; objnewUser.Address_Communication = User.Address_Communication; objnewUser.DOB=User.DOB; objnewUser.Gender=User.Gender; objnewUser.Usr_pwd = Encode(User.Usr_pwd); db.User_Info.Add(objnewUser); db.SaveChanges(); TempData["Usr_Message"] = ConfigurationManager.AppSettings["INS_SUC"]; ModelState.Clear(); return RedirectToAction("UserLogin", "UserInfo"); } catch (Exception exception) { } return RedirectToAction("Create", "UserInfo"); } var list = new SelectList(new[] { new { ID = "M", Name = "Male" }, new { ID = "F", Name = "FeMale" }, new { ID = "O", Name = "Others" } }, "ID", "Name", 1); ViewBag.Genders = list; return View(User); }
public virtual ActionResult addUser(AddUserModel user) { Authentication auth = new Authentication(); if (auth.isAdmin(this) || Authentication.DEBUG_bypassAuth) { if (ModelState.IsValid) { LDAPConnection newConnection = new LDAPConnection(); List<string> userInfo = newConnection.create(user.UserName); //Code here for creating TARSUser object; this will require // changing the LDAPConnection.create function to only // return the user information that is pertinent to TARS /* var userEntry = new TARSUser(); userEntry.userName = userInfo[1]; TARSUserDB.TARSUserList.Add(userEntry); */ return RedirectToAction("userMaintanence"); } return View(user); } else { return View("error"); } }