public async Task<bool> RegisterAsync(UserRegisterModel userRegisterModel)
{
string url = $"http://{await _serverFinder.GetServerAddressAsync()}/api/Account/";
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var json = JsonConvert.SerializeObject(userRegisterModel);
var content = new StringContent(json, Encoding.UTF8, "application/json");
try
{
var response = await client.PostAsync("Register", content);
if (!response.IsSuccessStatusCode)
{
return false;
}
}
catch (Exception e)
{
Debug.WriteLine($"type = {e.GetType()}, msg = {e.Message}");
return false;
}
}
return true;
}
public ActionResult Register(UserRegisterModel model)
{
try
{
if (ModelState.IsValid)
{
HttpContext.Handler = new ServiceLogic.Handlers.RegisterHandler();
HttpContext.Handler.ProcessRequest(System.Web.HttpContext.Current);
if (System.Web.HttpContext.Current.Response.StatusCode == 200)
{
return RedirectToAction("Login", "Home");
}
else
{
ModelState.AddModelError("", "User with this email already exists");
}
}
else
{
ModelState.AddModelError("", "Wrong email or password");
}
return View(model);
}
catch (Exception ex)
{
return View("Error");
}
}
public RegisterPage(IUserRepository userRepository = null)
{
_userRepository = userRepository ?? DependencyService.Get<IUserRepository>();
_notifyPage = new NotifyPage(this);
_userRegisterModel = new UserRegisterModel
{
Email = _userRepository?.GetUserLoginModel()?.Email ?? string.Empty,
};
BindingContext = _userRegisterModel;
InitializeComponent();
}
public async Task <IActionResult> Authenticate()
{
int sourceId = await sourceService.GetSourceIdByName(Constants.OAuthSourceNames.GitHubSourceName);
string accessToken = await httpContextInfoProvider.GetAccessTokenAsync();
var user = new UserRegisterModel
{
UserName = httpContextInfoProvider.GetUsername(),
AvatarUrl = httpContextInfoProvider.GetAvatarUrl(),
Url = httpContextInfoProvider.GetExternalUrl(),
ExternalId = httpContextInfoProvider.GetExternalId(),
AccessToken = accessToken,
SourceId = sourceId
};
return(RedirectToAction("GitHubLogin", "Account", user));
}
public void CreateUser(UserRegisterModel model)
{
var salt = PasswordHasher.SaltGenerator();
User user = new User
{
Role = "Customer",
FirstName = model.FirstName,
LastName = model.LastName,
EmailAddress = model.Email,
Salt = salt,
Password = PasswordHasher.HashPassword(model.Password, salt),
RegisterDate = DateTime.Now
};
_context.Users.Add(user);
_context.SaveChanges();
}
public async Task <IHttpActionResult> PostRegister(UserRegisterModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await userManager.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok());
}
public async Task <IHttpActionResult> Post([FromBody] UserRegisterModel user)
{
try
{
if (!ModelState.IsValid)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Forbidden, JsonConvert.SerializeObject(string.Join(" | ", ModelState.Values)))));
}
UserRegisterDTO userPostDTO = UserMapper.Map <UserRegisterModel, UserRegisterDTO>(user);
UserCompleteDTO newUser = await UserBusinessContext.CreateNewUser(userPostDTO);
return(Ok(new { User = newUser }));
}
catch (Exception e)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Forbidden, JsonConvert.SerializeObject(e.Message))));
}
}
/// <summary>
/// 注册用户
/// </summary>
/// <param name="model"></param>
public void RegisterUser(UserRegisterModel model)
{
Check(model);
var findUserByMobile = _userDal.FindUserByMobile(model.Mobile);
if (findUserByMobile > 0)
{
Function.ExceptionThrow("Existed", "此号码已存在");
}
var addUserResult = _userDal.AddUser(model.Mobile, model.CompanyName, Function.GetMd5(model.Password),
model.Contact, model.RegType);
if (addUserResult < 1)
{
Function.ExceptionThrow("Error", "注册失败");
}
model.Id = addUserResult;
}
/// <summary>
/// Добавления пользователя в БД
/// </summary>
/// <param name="userModel"></param>
/// <returns>Id пользователя</returns>
public async Task <Guid> AddAsync(UserRegisterModel userModel)
{
if (userModel == null)
{
throw new NullReferenceException($"Ссылка на пользователя указывате на Null.");
}
//Передаем пароль сразу с солью(сначала пароль, потом соль)!!!
var passwordSalt = Randomizer.GetString(8);
var passworhHash = _passwordHasher.HashPassword(null, userModel.Password + passwordSalt);
var resultUser = new User(userModel.UserName, userModel.Email, userModel.PhoneNumber, passwordSalt,
passworhHash, userModel.RoleId);
//Сохраняем пользователя
await _context.AddAsync(resultUser);
await _context.SaveChangesAsync();
return(resultUser.UserId);
}
public async Task <IActionResult> Register(UserRegisterModel userModel)
{
var user = new User
{
UserName = userModel.UserName,
Email = userModel.Email,
EmailConfirmed = true,
PhoneNumber = userModel.PhoneNumber,
PhoneNumberConfirmed = true,
FirstName = userModel.FirstName,
LastName = userModel.LastName,
Address = userModel.Address,
City = userModel.City
};
var result = await _userDataRegister.UserRegisterAsync(user, userModel.Password);
return(Ok(result));
}
public IActionResult Register([FromBody] UserRegisterModel model)
{
if (!ModelState.IsValid)
{
return(Json(new { success = false }));
}
try
{
this._authService.RegisterUser(model);
return(Json(new { success = true }));
}
catch (Exception)
{
return(Json(new { success = false }));
}
}
public async Task <ActionResult <RequestResult> > Update([FromBody] UserRegisterModel model)
{
if (!ModelState.IsValid)
{
return(RequestResult.CreateErrorResult(ModelState));
}
var result = await serivice.Update(model);
if (result.Result)
{
return(RequestResult.CreateSuccessResult());
}
else
{
return(RequestResult.CreateErrorResult(result.Message));
}
}
public object Register(UserRegisterModel model)
{
if (model.Password != model.ConfirmPassword)
{
throw new Common.Exceptions.ValidationException("Password confirmation not valid!");
}
Users user = new Data.Model.Users {
Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.ConfirmPassword, Username = model.Username
};
Users registeredUser = UserManager.Register(user);
UserModel userModel = new UserModel {
Email = registeredUser.Email, FirstName = registeredUser.FirstName, Id = registeredUser.Id, IsAdmin = true, LastName = registeredUser.LastName, RegistrationDate = registeredUser.DateCreated
};
return(new { User = userModel, Token = CreateLoginToken(user) });
}
public async Task <IActionResult> Register([FromBody] UserRegisterModel model)
{
var result = await _userManager.CreateAsync(
new ApplicationUser()
{
Email = model.Email,
UserName = model.Email,
Name = model.Name
},
model.Password
);
if (result.Succeeded)
{
return(Ok());
}
return(StatusCode(500, result.Errors));
}
public async Task <AuthResponse <object> > Register(UserRegisterModel userRegisterModel)
{
var identityUser = new ApplicationUser {
Email = userRegisterModel.Email, UserName = userRegisterModel.Email, PhoneNumber = userRegisterModel.PhoneNumber, Gender = userRegisterModel.Gender, Birthdate = userRegisterModel.BirthDate
};
var result = await _userManager.CreateAsync(identityUser, userRegisterModel.Password);
if (result.Succeeded)
{
var emailConfirm = await _userManager.GenerateEmailConfirmationTokenAsync(identityUser);
var encodedEmailToken = Encoding.UTF8.GetBytes(emailConfirm);
var validEmailToken = WebEncoders.Base64UrlEncode(encodedEmailToken);
string uri = $"{_configuration["Server"]}api/auth/confirmEmail?userId={identityUser.Id}&token={validEmailToken}";
var jsonData = JsonSerializer.Serialize(new UserEmailModel()
{
Email = userRegisterModel.Email, Message = $"<h1>Email Adresi Onaylama</h1> <p>Lütfen Email Onaylayın <a href='{uri}'> Tıklayın</a> </p>", Title = "Email Onayı"
});
try
{
_sendEmailPublisher.PublishEmail(EventBusConsts.SendEmailQueque, jsonData);
}
catch (Exception)
{
throw;
}
//_publisher.OnPublish("mailQueque", jsonData);
//_publisher = new Publisher("mailQueque", jsonData);
_authResponse.Result = "Kullancı Kayıt Olma İşlemi Başarıyla Gerçekleşti";
_authResponse.isSuccess = true;
}
else
{
foreach (var item in result.Errors)
{
var errorItem = new ErrorModel(item.Code, item.Description);
_authResponse.Errors.Add(errorItem);
}
_authResponse.isSuccess = false;
}
return(_authResponse);
}
public async Task <IdentityResult> Register(UserRegisterModel userRegisterModel)
{
var user = userRegisterModel.AdaptToUser();
var result = await _unitOfWork.UserManager.CreateAsync(user, userRegisterModel.Password);
if (result.Succeeded)
{
await _unitOfWork.UserManager.AddToRoleAsync(user, userRegisterModel.UserRole);
await _unitOfWork.SignInManager.SignInAsync(user, false);
return(result);
}
else
{
return(result);
}
}
public void RegisterTest()
{
using (TransactionScope transaction = new TransactionScope())
{
UserRegisterModel model = new UserRegisterModel();
HomeController controller = new HomeController();
model.Age = 21;
model.Autonomous_community = "Andalucía";
model.Email = "*****@*****.**";
model.Genre = "Masculino";
model.Username = "******";
model.Password = "******";
model.ConfirmPassword = "******";
ActionResult ar = controller.Register(model);
Assert.IsNotNull(ar);
}
}
public ActionResult Register(UserRegisterModel model)
{
AppUser user = new AppUser()
{
Email = model.Email,
UserName = model.Email
};
var res = UserManager.Create(user, model.Password);
if (res.Succeeded)
{
return(RedirectToAction("Index", "Rooms"));
}
foreach (var err in res.Errors)
{
ModelState.AddModelError("", err);
}
return(View());
}
public async Task <IActionResult> Index(UserRegisterModel model)
{
// Ignore properties
ModelState.Remove(nameof(model.UserName));
ModelState.Remove(nameof(model.Password));
ModelState.Remove(nameof(model.PasswordConfirm));
ApplicationUser currentUser = await userManager.GetUserAsync(User);
if (ModelState.IsValid)
{
// Update user
model.UserName = currentUser.UserName;
model.ApplyToApplicationUser(currentUser);
await dbContext.SaveChangesAsync();
}
return(View(new UserRegisterModel(currentUser)));
}
public async Task <IActionResult> Register([FromBody] UserRegisterModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest($"{this.GetModelStateAllErrors()}"));
}
try
{
var applicationUser = new ApplicationUser
{
Email = user.Email,
UserName = user.Email
};
var userFromDatabase = await _userManager.FindByEmailAsync(applicationUser.Email);
if (userFromDatabase != null)
{
return(BadRequest("Email address already registered"));
}
var result = await _userManager.CreateAsync(applicationUser, user.Password);
if (!result.Succeeded)
{
_logger.LogError(LoggingEvents.ACCOUNT_REGISTER, $"Failed registration for user with email '{user.Email}' and password '{user.Password}'. Error messages: {string.Join(",", result.Errors)}");
return(BadRequest("Your registration could not be completed. Please refer to an admin of the site to help you"));
}
var registeredUser = new UserRegisteredModel
{
Email = applicationUser.Email,
Id = applicationUser.Id
};
return(Created($"/api/user/{registeredUser.Id}", registeredUser));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.ACCOUNT_REGISTER, ex, $"Registration failed for user '{user.Email}' with password '{user.Password}'");
return(this.InternalServerError());
}
}
/// <summary>
/// 修改用户信息
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool UpdateUserInfo(UserRegisterModel model)
{
string strSql = "update Hot_UserBaseInfo set UB_UserRealName=@UB_UserRealName,UB_UserNickName=@UB_UserNickName,UB_UserMobile=@UB_UserMobile";
if (!string.IsNullOrEmpty(model.loginPassword))
{
strSql += ",UB_UserLoginPassword =@UB_UserLoginPassword";
}
strSql += " where UB_UserID=@UserID";
var parm = new[] {
new SqlParameter("@UB_UserRealName", model.username),
new SqlParameter("@UB_UserNickName", model.nickname),
new SqlParameter("@UB_UserMobile", model.mobile),
new SqlParameter("@UB_UserLoginPassword", model.loginPassword),
new SqlParameter("@UserID", model.UserId),
};
return(DbHelperSQLP.ExecuteNonQuery(WebConfig.getConnectionString(), CommandType.Text, strSql.ToString(), parm) > 0);
}
public ActionResult Login(UserRegisterModel model)
{
var user = UserManager.Find(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "User is not exists");
return(View());
}
ClaimsIdentity claim = UserManager.CreateIdentity(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
return(RedirectToAction("Index", "Rooms"));
}
public async Task <ActionResult> InsertUser([FromBody] UserRegisterModel model)
{
var user = new IdentityUser
{
Email = model.EmailId,
UserName = model.Username,
// UserType=model.UserType,
SecurityStamp = Guid.NewGuid().ToString()
};
try
{
var Emodel = _mapper.Map <UserRegister>(model);
await _userRegisterActions.InsertStudentAysc(Emodel);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (model.UserType == "Staff")
{
await _userManager.AddToRoleAsync(user, "Staff");
}
else if (model.UserType == "Student")
{
await _userManager.AddToRoleAsync(user, "Student");
}
else
{
await _userManager.AddToRoleAsync(user, "Admin");
}
return(Ok(new { Username = user.UserName }));
}
else
{
return(Ok(new { Username = result.Errors }));
}
}
catch (Exception ex)
{
return(Ok(new { ex.InnerException }));
}
}
public IHttpActionResult Registeration([FromBody] RequestModel requestModel)
{
// = JsonConvert.DeserializeObject<ApiRequestModel>(System.Web.HttpContext.Current.Request.Form["encrypted"].ToString());
//var data = new JwtTokenManager().DecodeToken(requestModel.Data);
var data = requestModel.Data;
UserRegisterModel user = JsonConvert.DeserializeObject <UserRegisterModel>(data);
// if (request.ContainsKey("unique_name"))
{
var sendResponse = new ResponseModel()
{
Response = JsonConvert.SerializeObject(userServices.RegisterUser(user)), Success = true
};
var sendJson = Json(sendResponse);
return(sendJson);
}
// return Json(new ResponseModel() { Response = BadRequest().ToString(), Success = false });
}
public async Task <IHttpActionResult> UpdateUser([FromBody] UserRegisterModel model, [FromUri] string username)
{
if (model == null)
{
throw new THQArgumentException(Errors.corruptJson);
}
IPrincipal currentUser = HttpContext.Current.User;
if (!currentUser.IsInRole("Administrator") && username != currentUser.Identity.Name)
{
throw new THQNotAuthorizedException(Errors.cantUpdateProfile);
}
User user = Mapper.Map <User>(model);
await this._userManager.UpdateUser(user, username, model.Password, model.PasswordRepeat);
return(this.StatusCode(HttpStatusCode.NoContent));
}
public void RegisterTest()
{
using (TransactionScope transaction = new TransactionScope())
{
UserRegisterModel model = new UserRegisterModel();
HomeController controller = new HomeController();
model.Age = 21;
model.Autonomous_community = "Andalucía";
model.Email = "*****@*****.**";
model.Genre = "Masculino";
model.Username = "******";
model.Password = "******";
model.ConfirmPassword = "******";
ActionResult ar = controller.Register(model);
Assert.IsNotNull(ar);
}
}
public void Setup()
{
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Test");
_factory = new WebApplicationFactory <Startup>();
_client = _factory.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = "Test";
options.DefaultChallengeScheme = "Test";
options.DefaultScheme = "Test";
}).AddScheme <AuthenticationSchemeOptions, TestAuthHandler>(
"Test", options => { });
services.AddAuthorization(options =>
{
options.DefaultPolicy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
});
services.AddControllers().AddApplicationPart(typeof(Startup).Assembly);
});
}).CreateClient();
var register = new UserRegisterModel
{
FirstName = "John",
LastName = "Doe",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
using (var scope = _factory.Services.CreateScope())
{
var userService = scope.ServiceProvider.GetRequiredService <IUsersService>();
userService.RegisterAsync(register).Wait();
}
_client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Test");
}
public ActionResult Register(UserRegisterModel model)
{
// Validate user input.
model.ResetErrorMessages();
bool hasError = false;
if (ModelState.ContainsKey("Username") && ModelState["Username"].Errors.Count > 0)
{
hasError = true;
model.UsernameErrorMessage = ModelState["Username"].Errors[0].ErrorMessage;
}
if (ModelState.ContainsKey("Password") && ModelState["Password"].Errors.Count > 0)
{
hasError = true;
model.PasswordErrorMessage = ModelState["Password"].Errors[0].ErrorMessage;
}
if (ModelState.ContainsKey("PasswordConfirmation") && ModelState["PasswordConfirmation"].Errors.Count > 0)
{
hasError = true;
model.PasswordConfirmationErrorMessage = ModelState["PasswordConfirmation"].Errors[0].ErrorMessage;
}
if (hasError)
{
return(View(model));
}
if (string.Compare(model.Password, model.PasswordConfirmation, false) != 0)
{
model.PasswordConfirmationErrorMessage = "Password and its confirmation is not the same.";
return(View(model));
}
if (DoRegister(model))
{
return(View("Succeed", model));
}
else
{
return(View(model));
}
}
public ActionResult Login(UserRegisterModel ObjModel)
{
var otp = Session["OtpData"];
String OtpCheck = (string)otp;
if (string.IsNullOrWhiteSpace(ObjModel.Otp))
{
return(View("OTP", ObjModel));
}
if (OtpCheck.Equals(ObjModel.Otp))
{
ObjModel.Mobile = (string)Session["Mobile"];
var _request = JsonConvert.SerializeObject(ObjModel);
ResponseModel ObjResponse = GetApiResponse(Constant.ApiLogin, _request);
if (String.IsNullOrWhiteSpace(ObjResponse.Response))
{
return(View("Index", ObjModel));
}
String VarResponse = ObjResponse.Response;
string[] ArrResponse = VarResponse.Split(',');
Services.SetCookie(this.ControllerContext.HttpContext, "usrId", ArrResponse[0]);
Services.SetCookie(this.ControllerContext.HttpContext, "usrName", ArrResponse[1]);
//ViewBag.LoginMessage = "Login Success";
String LoginType = (string)Session["LoginType"];
if (LoginType.Equals("R"))
{
return(RedirectToAction("Index", "Interest"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ViewBag.OtpMessage = OtpCheck;
ViewBag.LoginMessage = "OtpNot";
}
return(View("OTP"));
}
public async Task <bool> RegisterNewUser(UserRegisterModel userRegister)
{
await using var sqlConnection = new SqlConnection(ConnectionString);
sqlConnection.Open();
var sqlCommand = new SqlCommand("RegisterNewUser", sqlConnection)
{
CommandType = System.Data.CommandType.StoredProcedure
};
sqlCommand.Parameters.AddWithValue("@ID_User", Convert.ToInt32(RegisterNewUserConst));
sqlCommand.Parameters.AddWithValue("@First_Name", userRegister.FirstName.Trim());
sqlCommand.Parameters.AddWithValue("@Last_Name", userRegister.LastName.Trim());
sqlCommand.Parameters.AddWithValue("@Email", userRegister.Email.Trim());
sqlCommand.Parameters.AddWithValue("@Password", userRegister.Password.Trim());
sqlCommand.Parameters.AddWithValue("@ID_User_Type", Convert.ToInt32(userRegister.IdUserType));
var rowsAffected = sqlCommand.ExecuteNonQuery();
return(rowsAffected > 0);
}
private async void ButtonRegister_Clicked(object sender, EventArgs e)
{
RegisterService _registrationService = new RegisterService();
var registerModel = new UserRegisterModel
{
Email = string.IsNullOrWhiteSpace(email.Text) ? "*****@*****.**" : email.Text,
Password = string.IsNullOrWhiteSpace(password.Text) ? "password" : password.Text,
ConfirmPassword = string.IsNullOrWhiteSpace(confirmpassword.Text) ? "password" : confirmpassword.Text,
BillingAddress = new Address
{
AddressLine1 = string.IsNullOrWhiteSpace(addressLine1.Text) ? "addressLine1" : addressLine1.Text,
AddressLine2 = string.IsNullOrWhiteSpace(addressLine2.Text) ? "addressLine2" : addressLine2.Text,
City = string.IsNullOrWhiteSpace(city.Text) ? "hammond" : city.Text,
State = string.IsNullOrWhiteSpace(state.Text) ? "LA" : state.Text,
ZipCode = string.IsNullOrWhiteSpace(zipCode.Text) ? "70401" : zipCode.Text
}
};
var getRegistration = await _registrationService.Registration(registerModel);
if (getRegistration)
{
await DisplayAlert("Register success", "Registration Successful. Please wait while we log you in.", "Okay", "Cancel");
var _loginService = new LoginService();
var loginResult = await _loginService.Login(registerModel);
if (!loginResult)
{
await DisplayAlert("Error!!", "Login unsuccessful. Please try again.", "Okay", "Cancel");
}
else
{
await DisplayAlert("Success!!", "Login successful", "Okay", "Cancel");
}
await Navigation.PushAsync(new TicketView());
}
else
{
await DisplayAlert("Error!!", "Registration unsuccessful. Please try again.", "Okay", "Cancel");
}
}
public ActionResult Register(UserRegisterModel userRegisterModel)
{
if (string.IsNullOrEmpty(userRegisterModel.Username) ||
string.IsNullOrEmpty(userRegisterModel.Password) ||
string.IsNullOrEmpty(userRegisterModel.PasswordCheck))
{
ModelState.AddModelError("Username", "Заполните все поля!");
return(View(userRegisterModel));
}
if (userRegisterModel.Password != userRegisterModel.PasswordCheck)
{
ModelState.AddModelError("", "Пароли не совпадают!");
return(View(userRegisterModel));
}
if (UserModel.Load(userRegisterModel.Username) != null)
{
ModelState.AddModelError("Username", "Пользователь с таким именем уже зарегистрирован в системе!");
return(View(userRegisterModel));
}
ITransaction tr = Context.Instance.Session.BeginTransaction();
UserModel user = new UserModel()
{
Username = userRegisterModel.Username, Password = userRegisterModel.Password
};
try
{
Context.Instance.Session.Save(user);
tr.Commit();
}
catch (Exception ex)
{
ModelState.AddModelError("", "Пользователь с таким именем уже зарегистрирован в системе!");
return(View(userRegisterModel));
}
Context.Instance.CurrentUser = user;
FormsAuthentication.SetAuthCookie(userRegisterModel.Username, true);
return(RedirectToAction("Index", "Home"));
}
public ActionResult Create(UserRegisterModel u)
{
if (ModelState.IsValid)
{
User us = new User();
us.UserName = u.UserName;
us.Password = u.Password;
us.Email = u.Email;
us.Address = u.Address;
us.Password = u.Password;
us.FullName = u.FullName;
us.Status = true;
us.GroupId = 2;
_u.Add(us);
return(RedirectToAction("Index"));
}
return(View());
}
public async Task Crete_User_Success()
{
var user = new UserRegisterModel
{
Email = "Email",
Password = "******",
RoleId = RolesOption.User,
UserName = "******"
};
//Act
var userGuud = await _userService.AddAsync(user);
var resultUser = await _context.Users.SingleOrDefaultAsync(x => x.UserId == userGuud);
//Assrt
Assert.AreEqual(user.Email, resultUser.Email);
Assert.AreEqual(user.UserName, resultUser.UserName);
Assert.AreEqual(user.RoleId, resultUser.RoleId);
}
public ActionResult Register(UserRegisterModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
else
{
ModelState.AddModelError("", "Registro correcto.");
User user = new Models.User();
user.age = (int)model.age;
user.autonomous_community = model.autonomous_community;
user.email = model.email;
user.genre = model.genre;
user.password = UserRepository.GetSHA512(model.password, model.username);
user.username = model.username;
ur.Add(user);
return RedirectToAction("login", "home");
}
}
public ActionResult Register(UserRegisterModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
else
{
ModelState.AddModelError("", "Registro correcto.");
User user = new Models.User();
user.Age = (int)model.Age;
user.Autonomous_community = model.Autonomous_community;
user.Email = model.Email;
user.Genre = model.Genre;
user.Is_admin = false;
user.Password = UserRepository.GetSHA512(model.Password, model.Username);
user.UserName = model.Username;
user.Confirmed = false;
ur.Add(user);
sendConfirmationEmail(user);
return RedirectToAction("login", "home");
}
}
public ActionResult Register()
{
UserRegisterModel model = new UserRegisterModel();
return View(model);
}
