public IActionResult Register(RegisterViewModels register)
{
if (!ModelState.IsValid)
{
return(View(register));
}
CheckUser checkUser = userService.CheckUser(register.UserName, register.Email);
if (checkUser != CheckUser.Ok)
{
ViewBag.Check = checkUser;
return(View(register));
}
User user = new User
{
Email = register.Email.Trim(),
Password = PasswordHelper.EncodePasswordMd5(register.Password.Trim()),
UserName = register.UserName.Trim()
};
userService.RegisterUser(user);
return(View("SuccessRegister", register));
}
public async Task <IActionResult> Register(RegisterViewModels model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//Inicia sesión con el usuario especificado
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModels models)
{
if (ModelState.IsValid)
{
int result = await _manager.Register(new Users()
{
LoginId = models.UserName,
Name = models.Name,
LoginPwd = models.UserPwd,
Address = models.Adress,
Phone = models.Phone,
Mail = models.Email,
UserRoleId = 1,
UserStateId = 1
});
if (result != 1)
{
return(Content("False"));
}
return(Content("Success"));
}
return(View("Register", models));
}
public async Task <ActionResult> Register(RegisterViewModels 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 int Register(RegisterViewModels registerViewModels)
{
var employee = new Employee()
{
NIK = registerViewModels.NIK,
Name = registerViewModels.Name,
BirthDate = registerViewModels.BirthDate,
Gender = registerViewModels.Gender,
Religion = registerViewModels.Religion,
Email = registerViewModels.Email,
PhoneNumber = registerViewModels.PhoneNumber,
RoleId = 4,
CustomerId = registerViewModels.CustomerId
};
var account = new Account()
{
NIK = registerViewModels.NIK,
Password = Hashing.HashPassword("B0o7c@mp")
};
var resultEmployee = employeeRepository.Create(employee);
myContext.Add(account);
var resultAccount = myContext.SaveChanges();
if (resultEmployee > 0 && resultAccount > 0)
{
sendEmail.SendPassword(employee.Email);
return(1);
}
else
{
return(0);
}
}
public async Task <IActionResult> Register(RegisterViewModels model)
{
if (ModelState.IsValid)
{
User user = new User {
UserName = model.Name, DName = model.Dname, Date = model.Date, Color = model.Color, Pot = model.Pot, PhoneNumber = model.Number
};
// добавляем пользователя
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
// установка куки
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
public IActionResult Register(RegisterViewModels model)
{
if (_context.Users.Where(u => u.Email == model.Email).SingleOrDefault() != null)
{
ModelState.AddModelError("Username", "Username in use");
}
if (ModelState.IsValid)
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
User NewUser = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
NewUser.Password = Hasher.HashPassword(NewUser, model.Password);
_context.Add(NewUser);
_context.SaveChanges();
HttpContext.Session.SetInt32("UserId", NewUser.UserId);
return(RedirectToAction("Index", "Activity"));
}
else
{
return(View("Index"));
}
}
public ActionResult Register(RegisterViewModels registerViewModels)
{
if (ModelState.IsValid)
{
UserManager um = new UserManager();
BusınessLayerResult <EverNoteUser> res = um.RegisterUser(registerViewModels);
if (res.Errors.Count > 0)
{
res.Errors.ForEach(x => ModelState.AddModelError("", x.Message));
return(View(registerViewModels));
}
else
{
//OkViewModel model = new OkViewModel()
//{
// Title = "Yönlendiriliyor..",
// RedirectingUrl = "/Home/Login",
// RedirectingTimeOut = 2000,
//};
//model.ıtems.Add("Lütfen E-Posta adresinize yolladığımız linke tıklayarak hesabınızı aktivite ediniz..");
return(RedirectToAction("Login", "Home"));
}
}
return(View(registerViewModels));
}
public async Task <IActionResult> Register(RegisterViewModels model)
{
if (ModelState.IsValid)
{
List <User> users = await db.GetUsersAsync();
User user = users.FirstOrDefault(u => u.Email == model.Email);
if (user == null)
{
Role userRole = await db.GetUserRoleAsync();
user = new User {
Email = model.Email, Password = model.Password, Name = model.Name, Role = userRole
};
await db.SetUserAsync(user);
await Authenticate(user);
return(RedirectToAction("Index", "Store"));
}
else
{
ModelState.AddModelError("", "Wrong Email or Password");
}
}
return(View("Index"));
}
//[OverrideAuthentication]
//[HostAuthentication(DefaultAuthenticationTypes.ExternalCookie)]
//[AllowAnonymous]
//[Route("ExternalLogin", Name = "ExternalLogin")]
//public async Task<IHttpActionResult> GetExternalLogin(string provider, string error = null)
//{
// string redirectUri = string.Empty;
// if (error != null)
// {
// return BadRequest(Uri.EscapeDataString(error));
// }
// if (!User.Identity.IsAuthenticated)
// {
// return new _ExternalOAuthServer(provider, this.Request);
// }
// var redirectUriValidationResult = ValidateClientAndRedirectUri(this.Request, ref redirectUri);
// if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
// {
// return BadRequest(redirectUriValidationResult);
// }
// ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
// if (externalLogin == null)
// {
// return InternalServerError();
// }
// if (externalLogin.LoginProvider != provider)
// {
// Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
// return new _ExternalOAuthServer(provider, this.Request);
// }
// var user = await _identityService.LoginExternalAsync(externalLogin.LoginProvider, externalLogin.ProviderKey);
// bool hasRegistered = user != null;
// redirectUri = string.Format("{0}#external_access_token={1}&provider={2}&haslocalaccount={3}&external_user_name={4}",
// redirectUri,
// externalLogin.ExternalAccessToken,
// externalLogin.LoginProvider,
// hasRegistered.ToString(),
// externalLogin.UserName);
// return Redirect(redirectUri);
//}
public async Task <IHttpActionResult> Register(RegisterViewModels register)
{
try
{
if (ModelState.IsValid)
{
_IdentityData result = await _identityService.Create(register.EmailAddress, register.Password,
register.FullName, register.Address, register.PhoneNumber,
register.Birthdate, nameof(RoleType.User));
if (result.IsError)
{
base.AddModelError(result.Errors[0]);
return(BadRequest(ModelState));
}
else
{
return(Ok());
}//end if check is existed errors
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_loggingService.Write(GetType().Name, nameof(Register), ex);
return(InternalServerError(ex));
}
}
public ActionResult Register(RegisterViewModels model)
{
AccountModels account = new AccountModels();
account.RegisterUser(model.Username, model.Name, model.PhoneNumber, model.Email, model.Password);
return(View(model));
}
public HttpStatusCode Register(RegisterViewModels registerViewModels)
{
var httpClient = new HttpClient();
StringContent stringContent = new StringContent(JsonConvert.SerializeObject(registerViewModels), Encoding.UTF8, "application/json");
var result = httpClient.PostAsync("https://localhost:44346/api/Account/Register/", stringContent).Result;
return(result.StatusCode);
}
public HttpStatusCode ForgotPassword(RegisterViewModels registerVM)
{
var httpClient = new HttpClient();
StringContent content = new StringContent(JsonConvert.SerializeObject(registerVM), Encoding.UTF8, "application/json");
var result = httpClient.PutAsync("https://localhost:44346/api/Account/reset/", content).Result;
return(result.StatusCode);
}
public HttpStatusCode UpdateRole(RegisterViewModels registerViewModels)
{
var httpClient = new HttpClient();
StringContent content = new StringContent(JsonConvert.SerializeObject(registerViewModels), Encoding.UTF8, "application/json");
var result = httpClient.PutAsync("https://localhost:44346/api/employee/", content).Result;
return(result.StatusCode);
}
public IActionResult AddReview(RegisterViewModels NewReview)
{
if (ModelState.IsValid)
{
_context.Reviews.Add(NewReview);
_context.SaveChanges();
return(RedirectToAction("Reviews"));
}
return(View("Index"));
}
public IActionResult RegisterUser(RegisterViewModels userAdd)
{
if (ModelState.IsValid)
{
CreateUser(userAdd);
int?userIdQ = HttpContext.Session.GetInt32(key: "userId");
int userId = (int)userIdQ;
return(RedirectToAction("WeddingDash", "Wedding"));
}
return(View("Index"));
}
public void CreateUser(RegisterViewModels userAdd)
{
users user = new users
{
firstName = userAdd.firstName,
lastName = userAdd.lastName,
email = userAdd.email,
psw = userAdd.psw,
};
_context.Add(user);
_context.SaveChanges();
SelectUser(userAdd);
}
public async Task RegisterReturnsIndexViewResultAsync()
{
//Arrange
RegisterViewModels reg = new RegisterViewModels();
var mock = new Mock <IStore>();
var controller = new AccountController(mock.Object);
controller.ModelState.AddModelError("Email", "Wrong Email");
//Act
ViewResult result = (ViewResult)await controller.Register(reg);
//Assert
Assert.Equal("Index", result.ViewName);
}
public async Task <IActionResult> Register(RegisterViewModels model)
{
var user = new ApplicationUser {
UserName = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public IActionResult RegisterUser(RegisterViewModels userAdd)
{
users user = _context.users.Where(u => u.email == userAdd.email).SingleOrDefault();
if (ModelState.IsValid && user == null)
{
CreateUser(userAdd);
int?userIdQ = HttpContext.Session.GetInt32(key: "userId");
int userId = (int)userIdQ;
return(RedirectToAction("Dashboard", "BeltExam"));
}
if (user != null && ModelState.IsValid)
{
ViewBag.emailError = "That email is already in the database!";
}
return(View("Index"));
}
public async Task <IActionResult> Edit(RegisterViewModels registerViewModels)
{
if (ModelState.IsValid)
{
try
{
var persona = _mapper.Map <Persona>(registerViewModels);
await _context.Update(persona, persona.Id);
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(registerViewModels));
}
public async Task <object> Register([FromBody] RegisterViewModels model)
{
var user = new IdentityUser
{
UserName = model.UserName,
Email = model.Email,
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, false);
return(await GenerateJwtToken(model.Email, user));
}
throw new ApplicationException("UNKNOWN_ERROR");
}
public ActionResult Register(RegisterViewModels registerViewModels)
{
if (ModelState.IsValid)
{
var data = accountRepository.Register(registerViewModels);
if (data > 0)
{
return(Ok(new { status = "Registration Successed" }));
}
else
{
return(StatusCode(500, new { status = "Internal server error" }));
}
}
else
{
return(BadRequest(new { status = "Bad request", errorMessage = "Data input is not valid" }));
}
}
public BusinessLayerResult <ND_User> RegisterUser(RegisterViewModels data)
{
ND_User user = Find(x => x.Username == data.Username || x.Email == data.Email);
BusinessLayerResult <ND_User> layerResult = new BusinessLayerResult <ND_User>();
if (user != null)
{
if (user.Username == data.Username)
{
layerResult.AddError(ErrorMessagesCode.UsernameAlreadyExist, "Kullanıcı adı kayıtlı.");
}
if (user.Email == data.Email)
{
layerResult.AddError(ErrorMessagesCode.EmailAlreadyExist, "E-mail adresi kayıtlı.");
}
}
else
{
int dbResult = base.Insert(new ND_User()
{
Username = data.Username,
Email = data.Email,
Password = data.Password,
ActivatedGuid = Guid.NewGuid(),
ProfileImageFilename = "user-default.png",
IsActive = false,
IsAdmin = false
});
if (dbResult > 0)
{
layerResult.Result = Find(x => x.Email == data.Email && x.Username == data.Username);
string siteUri = ConfigHelper.Get <string>("SiteRootUri");
string activateUri = $"{siteUri}/Home/UserActivate/{layerResult.Result.ActivatedGuid}";
string body = $"Merhaba {layerResult.Result.Username} hesabınızı aktifleştirmek için <a href='{activateUri}' target='_blank'>tıklayınız.</a>";
MailHelper.SendMail(body, layerResult.Result.Email, "Not Defteri Hesap Aktifleştirme");
}
}
return(layerResult);
}
public async Task RegisterReturnsIndexViewResultAndAddModelErorrAsync()
{
//Arrange
RegisterViewModels reg = new RegisterViewModels()
{
Email = "*****@*****.**"
};
var mock = new Mock <IStore>();
mock.Setup(m => m.GetUsersAsync()).ReturnsAsync(new TestContext().Users);
var controller = new AccountController(mock.Object);
//Act
ViewResult result = (ViewResult)await controller.Register(reg);
//Assert
Assert.False(controller.ModelState.IsValid);
Assert.Equal("Index", result.ViewName);
}
public BusınessLayerResult <EverNoteUser> RegisterUser(RegisterViewModels data)
{
EverNoteUser user = Find(x => x.Name == data.Name || x.Email == data.Email);
BusınessLayerResult <EverNoteUser> res = new BusınessLayerResult <EverNoteUser>();
if (user != null)
{
if (user.Name == data.Name)
{
res.AddErrors(ErrorMessageCode.UserNameAlreadyExıst, "Kullanıcı Adı Kayıtlı");
}
if (user.Email == data.Email)
{
res.AddErrors(ErrorMessageCode.EmailAlreadyExıst, "E posta Kayıtlarda Var");
}
}
else
{
int db_result = base.Insert(new EverNoteUser()
{
UserName = data.Name,
Email = data.Email,
Password = data.Password,
ProfileImageFilename = "",
ActıveGuıd = Guid.NewGuid(),
IsActıve = false,
IsAdmın = false
});
if (db_result > 0)
{
res.Result = Find(x => x.Email == data.Email && x.UserName == data.Name);
string site = "http://localhost:54817";
string activateuri = $"{site}/Home/UserActivate/{res.Result.ActıveGuıd}";
string body = $" Merhaba {res.Result.UserName} Hesasabınız Aktifleştirmek için Lütfen <a href='{activateuri}'" +
$"target='_blank'>Tıklayınız</a>..";
MailHelper.SendMail(body, res.Result.Email, "Hesap Actifleştirme");
}
}
return(res);
}
public async Task <IActionResult> SignUp(RegisterViewModels model)
{
if (ModelState.IsValid)
{
User user = new User {
Email = model.Email, UserName = model.Email, Name = model.Name
};
// Adding user
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"ConfirmEmail",
"Registration",
new { userId = user.Id, code = code },
protocol: HttpContext.Request.Scheme);
EmailService emailService = new EmailService();
await emailService.SendEmailAsync(model.Email, "Confirm your account",
$"Confirm registration, use: <a href='{callbackUrl}'>link</a>");
return(Content("To complete the registration, check your email and follow the link provided in the letter"));
// cookie connection
//await _signInManager.SignInAsync(user, false);
//return RedirectToAction("Index", "Home");
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
public async Task <IHttpActionResult> Register(RegisterViewModels register)
{
try
{
var year = UserController.DateDiffYears(register.Birthdate, DateTimeOffset.Now);
if (year <= 10)
{
ModelState.AddModelError(string.Empty, "Ngày sinh phải cách hiện tại 10 năm");
}
if (ModelState.IsValid)
{
_IdentityData result = await _identityService.Create(register.EmailAddress, register.Password,
register.FullName, register.Address, register.PhoneNumber,
register.Birthdate, nameof(RoleType.User));
if (result.IsError)
{
base.AddModelError(result.Errors[0]);
return(BadRequest(ModelState));
}
else
{
return(Ok());
}//end if check is existed errors
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_loggingService.Write(GetType().Name, nameof(Register), ex);
return(InternalServerError(ex));
}
}
public ActionResult Register(RegisterViewModels user)
{
if (ModelState.IsValid)
{
if (securityService.EmailExist(user.Email))
{
message = "Podany email został już zarejestrowany";
}
else
{
var newuser = new Users()
{
email = user.Email,
password = user.Password,
firstname = user.FirstName,
lastname = user.LastName,
city = user.City,
address = user.Address,
number = user.Number,
zipcode = user.ZipCode,
phonenumber = user.PhoneNumber
};
db.Users.Add(newuser);
db.SaveChanges();
message = "Rejestracja zakończona pomyślnie. Możesz zalogować sie na swoje konto.";
Status = true;
}
}
else
{
message = "Nieprawidłowe żądanie";
Status = false;
}
ViewBag.Message = message;
ViewBag.Status = Status;
return(View(user));
}
public ActionResult Register(RegisterViewModels model)
{
if (ModelState.IsValid)
{
BusinessLayerResult <ND_User> res = userManager.RegisterUser(model);
if (res.Errors.Count > 0)
{
res.Errors.ForEach(x => ModelState.AddModelError("", x.Message));
return(View(model));
}
OkViewModel okModel = new OkViewModel()
{
Title = "Kayıt Başarılı",
RedirectingUrl = "/Home/Login"
};
okModel.Items.Add("Kayıt olma işlemi başarılı. Lütfen e-mail adresinize gönderilen linkten üyeliğinizi aktifleştirin.");
return(View("Ok", okModel));
}
return(View(model));
}
