public ActionResult Register(RegisterVM user)
{
if (ModelState.IsValid)
{
var pwd = new PasswordManager();
//var password = Membership.GeneratePassword(10, 0);
var password = "******";
string salt = null;
var passwordHash = pwd.GeneratePasswordHash(password, out salt);
var newUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
LoginEmail = user.LoginEmail,
PasswordHash = passwordHash,
PasswordSalt = salt,
CreationDate = DateTime.Now,
Gender = user.Gender,
IsDeleted = false
};
var link = "?password="******"<p>Email From: {0} ({1})</p><p>Message:</p><p>{2}</p>";
var message = new MailMessage();
message.To.Add(new MailAddress(user.LoginEmail)); // replace with valid value
message.From = new MailAddress("*****@*****.**"); // replace with valid value
message.Subject = "Account confirmation";
message.Body = string.Format(body, message.From, "AI Research", "Please confirm by clicking this link ");
message.IsBodyHtml = true;
using (var smtp = new SmtpClient())
{
var credential = new NetworkCredential
{
UserName = "******", // replace with valid value
Password = "******" // replace with valid value
};
smtp.Credentials = credential;
smtp.Host = "smtp-mail.outlook.com";
smtp.Port = 587;
smtp.EnableSsl = true;
// await smtp.SendMailAsync(message);
//return RedirectToAction("Sent");
}
Services.UserService.AddUser(newUser, user.RoleID);
user.Roles = GetRoles();
return(RedirectToAction("Login", "Account"));
}
return(View(user));
}
public IActionResult Register(RegisterVM model)
{
if (ModelState.IsValid)
{
var isRegistered = this.accountService.Register(signIn, model);
if (isRegistered)
{
return(this.Redirect("/home/index"));
}
}
return(this.View(model));
}
public void CreateUser(RegisterVM registerVM)
{
User user = new User
{
Name = registerVM.UserName,
Email = registerVM.Email,
Password = registerVM.Password
};
_repository.Create <User>(user);
_repository.Save();
return;
}
//Este proceso sera boolean --- si funciona enviar true // sino false
public ActionResult Register(RegisterVM model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
_manejoUserServices.CrearUsuario(model);
}
return(RedirectToAction("Login", "Account"));
}
public bool CrearUsuario(RegisterVM model)
{
Usuario user = new Usuario();
user.Nombre_Usuario = model.Nombre_Usuario;
user.Password = model.Password;
//user.Posicion = model.Posicion;
//user.premio = model.premio;
_manejoUsuarioRepo.ReistrarUsuarios(user);
return(true);
}
public JsonResult Insert(RegisterVM model)
{
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("JWTToken"));
var myContent = JsonConvert.SerializeObject(model);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var result = client.PostAsync("auth/register", byteContent).Result;
return(Json(result));
}
public async Task <string> RegisterUserAsync(RegisterVM model, string url)
{
var user = new IdentityUser()
{
Email = model.Email,
PasswordHash = model.Password,
UserName = model.Email,
PhoneNumber = model.Phone,
EmailConfirmed = /*false*/ true
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
throw new Exception($"Register error ({result.Errors.FirstOrDefault()?.Description})");
}
_userManager.AddToRoleAsync(user, model.Role).Wait();
var fileId = (await _fileService.CreateFileDbAsync(model.Photo, userId: user.Id)).Id;
var userProfile = new UserProfile()
{
FirstName = model.FirstName,
LastName = model.LastName,
DateBirth = model.DateBirth,
//DateLastOnline = DateTime.Now,
SexId = model.SexId,
FileId = fileId,
UserId = user.Id
};
await _db.UserProfiles.CreateAsync(userProfile);
if (model.Role == "manager")
{
var manager = new Manager {
UserProfileId = userProfile.Id, LocationId = model.LocationId
};
await _db.Managers.CreateAsync(manager);
}
//await _chatService.SetLastOnlineAsync(user.Id);
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var encode = HttpUtility.UrlEncode(code);
//var callbackUrl = new StringBuilder("https://")
// .AppendFormat(url)
// .AppendFormat("/api/account/email")
// .AppendFormat($"?user_id={user.Id}&code={encode}");
//await _emailService.SendEmailAsync(user.Email, "Confirm your account",
//$"Confirm the registration by clicking on the link: <a href='{callbackUrl}'>link</a>");
return(user.Id);
}
public ActionResult Register([Bind(Include = "Id,Username,Password,ConfirmPassword,Title,Forename,Surname,Dob,AddressStreet," +
"AddressTown,AddressCounty,AddressPostalCode,HomePhoneNo,WorkPhoneNo,MobilePhoneNo,Email")] RegisterVM registration)
{
if (ModelState.IsValid)
{
if (_authFacade.Register(registration.Username, registration.Password, registration.ConfirmPassword))
{
_authFacade.GetToken(registration.Username, registration.Password);
GenericFacade.UserName = registration.Username;
string owinId = _authFacade.GetUserId();
GenericFacade.OwinId = owinId;
_authFacade.AddCustomerRole();
Session[Global.RolesSessionVar] = GenericFacade.IsAdmin;
_customerFacade.Create(new Customer
{
OwinUserId = owinId,
UserName = registration.Username,
Title = registration.Title,
Forename = registration.Forename,
Surname = registration.Surname,
DoB = registration.Dob,
AddressStreet = registration.AddressStreet,
AddressTown = registration.AddressTown,
AddressCounty = registration.AddressCounty,
AddressPostalCode = registration.AddressPostalCode,
HomePhoneNo = registration.HomePhoneNo,
WorkPhoneNo = registration.WorkPhoneNo,
MobilePhoneNo = registration.MobilePhoneNo,
Email = registration.Email
});
Customer c = _customerFacade.Get();
Session[Global.UserIdSessionVar] = c.Id;
Session[Global.UsernameSessionVar] = registration.Username;
return(RedirectToAction("index", "home"));
}
else
{
return(View(registration));
}
}
return(View(registration));
}
public async Task <IActionResult> Register(RegisterVM registerVM)
{
if (!ModelState.IsValid)
{
return(View(registerVM));
}
CustomUser customUser = new CustomUser
{
FirstName = registerVM.FirstName,
LastName = registerVM.LastName,
Email = registerVM.Email,
PhoneNumber = registerVM.PhoneNumber,
UserName = registerVM.UserName
};
IdentityResult result = await _userManager.CreateAsync(customUser, registerVM.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
error.Description = "Qeydiyyat zamanı xəta baş verdi";
ModelState.AddModelError("", error.Description);
}
return(View(registerVM));
}
await _userManager.AddToRoleAsync(customUser, "İstifadəçi");
#region Sending Email Confirmation Message
SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
client.UseDefaultCredentials = false;
client.EnableSsl = true;
client.Credentials = new NetworkCredential(_configuration["ConnectionStrings:SmtpClientCredentialEmail"], _configuration["ConnectionStrings:SmtpClientCredentialPassword"]);
MailMessage message = new MailMessage("*****@*****.**", registerVM.Email);
message.IsBodyHtml = true;
message.Subject = "Hesabın təsdiqlənməsi";
message.Body = $"<a href='https://localhost:44365/Account/Confirmation/?userId={customUser.Id}'>Hesabını təsdiqlə</a>";
client.Send(message);
#endregion
TempData["Confirm"] = true;
return(View());
}
//public AccountService(IHttpContextAccessor accessor)
//{
// userId = userManager.GetUserId(accessor.HttpContext.User);
//}
public async Task <SignInResult> TrySignInUser(RegisterVM vM)
{
var user = await userManager.FindByIdAsync(userId);
var result = await signInManager.PasswordSignInAsync(
user.UserName,
user.PasswordHash,
isPersistent : false,
lockoutOnFailure : false
);
return(result);
}
public int UserRegistration(RegisterVM registerVM)
{
try
{
_mapper = profile.Map().CreateMapper();
UserMaster userMaster = _mapper.Map <RegisterVM, UserMaster>(registerVM);
_uow.UserMasters.Add(userMaster);
return(_uow.CommitChanges());
}
catch (Exception ex)
{
return(0);
}
}
public void RejectRevertAudit(RegisterVM vm, EventHandler <RestClientEventArgs <RMARegisterInfo> > callback)
{
string relativeUrl = "/RMAService/Register/RejectRevertAudit";
RMARegisterInfo msg = vm.ConvertVM <RegisterVM, RMARegisterInfo>();
restClient.Update <RMARegisterInfo>(relativeUrl, msg, (obj, args) =>
{
if (args.FaultsHandle())
{
return;
}
callback(obj, args);
});
}
public async Task <IActionResult> Register(RegisterVM register)
{
var res = await _roleManager.RoleExistsAsync("NormalUser");
if (!res == true)
{
IdentityRole identityRole = new IdentityRole
{
Name = "NormalUser"
};
await _roleManager.CreateAsync(identityRole);
}
if (ModelState.IsValid)
{
var user = new User()
{
FirstName = register.FirstName,
LastName = register.LastName,
Email = register.Email,
PhoneNumber = register.Phone,
UserName = register.Email,
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "NormalUser");
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(register));
}
public static void CreateInstructor(RegisterVM vm)
{
Instructor p = new Instructor();
//HireDate is particular to Instructor
p.HireDate = vm.HireDate;
p.Email = vm.Email;
p.FirstMidName = vm.FirstMidName;
p.LastName = vm.LastName;
p.Password = SaltAndHash(vm.Password);
p.UserName = vm.UserName;
db.Instructors.Add(p);
db.SaveChanges();
}
public static void CreateStudent(RegisterVM vm)
{
Student p = new Student();
//EnrollmentDate is particular to Student
p.EnrollmentDate = vm.HireDate;
p.Email = vm.Email;
p.FirstMidName = vm.FirstMidName;
p.LastName = vm.LastName;
p.Password = SaltAndHash(vm.Password);
p.UserName = vm.UserName;
db.Students.Add(p);
db.SaveChanges();
}
public async Task <IActionResult> OnPostAsync([FromBody] RegisterVM registerVM)
{
MemberRepo cRP = new MemberRepo(_context);
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
if (cRP.checkExist(registerVM.Email))
{
var Obj = new
{
errorMessage = "User Already Exist",
StatusCode = "Invalid Register."
};
return(new ObjectResult(Obj));
}
var user = new IdentityUser {
UserName = registerVM.Email, Email = registerVM.Email,
};
var result = await _userManager.CreateAsync(user, registerVM.Password);
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var enCode = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
await _userManager.ConfirmEmailAsync(user, enCode);
bool isNewClient = cRP.Create(registerVM.Username, registerVM.LastName, registerVM.FirstName, registerVM.Email);
if (isNewClient)
{
var tokenString = GenerateJSONWebToken(user);
var jsonOK = new
{
tokenString = tokenString,
StatusCode = "OK",
currentUser = registerVM.Email
};
return(new ObjectResult(jsonOK));
}
}
}
var jsonInvalid = new { tokenString = "", StatusCode = "Invalid register." };
return(new ObjectResult(jsonInvalid));
}
public ActionResult Register(RegisterVM model)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
ApplicationUser user = new ApplicationUser {
UserName = model.Username
};
var r = userManager.CreateAsync(user, model.Password);
if (r.Result.Succeeded)
{
return(RedirectToAction("Login"));
}
return(View(model));
}
// GET: Users/Create
public ActionResult Register()
{
var model = new RegisterVM();
//Create a temporary user than can be passed to the UI and
//used to store the data that needs to be posted to the database
model.tempUser = new User
{
Role = 1,
ShowCV = true
};
ViewBag.UserTypeId = new SelectList(db.UserTypes, "UserTypeId", "UserTypeText");
return(View(model));
}
public async Task <IActionResult> CreateUserAsync([FromBody] RegisterVM model)
{
if (model == null)
{
throw new NullReferenceException("Register Model Is Null");
}
var result = await _identityService.CreateUserAsync(model);
if (result.Succeeded)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Register(RegisterVM registerVM)
{
var user = new User
{
Email = registerVM.Email,
FirstName = registerVM.FirstName,
LastName = registerVM.LastName,
Password = registerVM.Password
};
unitOfWork.Users.Insert(user);
SetAuthCookie(unitOfWork.Users.GetUserByCredentials(user.Email, registerVM.Password));
return(Redirect("Index"));
}
public async Task <IdentityResult> RegisterAsync(RegisterVM model)
{
var user = new User()
{
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Customer");
}
return(result);
}
public async Task <ActionResult> Register(RegisterVM registerViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Please try again.");
return(View(registerViewModel));
}
string username = registerViewModel.Username;
Users user = await _unitOfWork.usersRolesRepo.GetAsync(username);
if (user != null)
{
ModelState.AddModelError(string.Empty, "User already exists");
return(View(registerViewModel));
}
string hashInfo = Hasher.HashGenerator(registerViewModel.HashedPassword);
string myHash = hashInfo.Split(':')[0]; // returns the hash
user = new Users()
{
Username = username, HashedPassword = hashInfo
};
_unitOfWork.usersRolesRepo.Add(user);
UserRolesMapping roleMap = new UserRolesMapping()
{
UserID = user.ID, RoleID = _roleId
};
_unitOfWork.rolesMappingRepo.Add(roleMap);
bool registerOk = await _accountRest.RegisterServiceAsync(username, myHash, _userRole);
if (registerOk)
{
int saved = await _unitOfWork.SaveAsync();
if (saved < 0)
{
ModelState.AddModelError(string.Empty, "Unable to save User to client.");
return(View(registerViewModel));
}
bool tokenOk = await LoginHelper(username, myHash);
if (tokenOk)
{
return(RedirectToAction("Inbox", "Messages"));
}
}
ModelState.AddModelError(string.Empty, "Unable to register user.");
return(View(registerViewModel));
}
public async Task <IActionResult> Register(RegisterVM model, string returnUrl)
{
if (await _db.UserClients.AnyAsync(a => a.Email == model.User.Email))
{
ModelState.AddModelError("User.Email", "This Email was Registered");
model.Breadcrumb = new Breadcrumb
{
Path = new Dictionary <string, string> {
{ "Home", Url.Action("Index", "Home") },
{ "Register", null }
},
Page = Page.Login
};
TempData["Error"] = "This user have been Registered";
return(View(model));
}
if (ModelState.IsValid)
{
model.User.CreatedAt = DateTime.Now;
PasswordHasher <UserClient> hasher = new PasswordHasher <UserClient>(
new OptionsWrapper <PasswordHasherOptions>(
new PasswordHasherOptions()
{
CompatibilityMode = PasswordHasherCompatibilityMode.IdentityV2
})
);
model.User.Password = hasher.HashPassword(model.User, model.User.Password);
model.User.Token = Guid.NewGuid().ToString();
await _db.UserClients.AddAsync(model.User);
await _db.SaveChangesAsync();
var option = new CookieOptions {
Expires = DateTime.Now.AddMinutes(60),
IsEssential = true
};
Response.Cookies.Append("Token", model.User.Token, option);
return(LocalRedirect(returnUrl));
}
model.Breadcrumb = new Breadcrumb
{
Path = new Dictionary <string, string> {
{ "Home", Url.Action("Index", "Home") },
{ "Register", null }
},
Page = Page.Login
};
return(View(model));
}
public int Create(RegisterVM registerVM)
{
var spName = "SP_Register";
parameters.Add("@name", registerVM.EmployeeName);
parameters.Add("@birthdate", registerVM.BirthDate);
parameters.Add("@address", registerVM.Address);
parameters.Add("@email", registerVM.Email);
parameters.Add("@phone", registerVM.Phone);
parameters.Add("@password", registerVM.Password);
var result = connection.Execute(spName, parameters, commandType: CommandType.StoredProcedure);
return(result);
}
public ActionResult Registration(RegisterVM entity)
{
string HASHValue = string.Empty;
byte[] SALT = new byte[saltLengthLimit];
try
{
using (RepshoDBE db = new RepshoDBE())
{
// Ensure we have a valid viewModel to work with
if (!ModelState.IsValid)
{
return(View(entity));
}
//Retrive Stored HASH Value From Database According To Username (one unique field)
var userInfo = db.UserMasters.Where(s => s.Username == entity.Username.Trim()).FirstOrDefault();
//Assign HASH Value
if (userInfo == null)
{
UserMaster user = new UserMaster();
SALT = Get_SALT();
HASHValue = Get_HASH_SHA512(entity.Password, entity.Username, SALT);
user.SALT = SALT;
user.HASH = HASHValue;
user.Username = entity.Username;
user.FirstName = entity.FirstName;
user.LastName = entity.LastName;
user.UserEmail = entity.UserEmail;
db.UserMasters.Add(user);
db.SaveChanges();
ModelState.Clear();
return(RedirectToAction("Login", "Login"));
}
else
{
//Login Fail
TempData["ErrorMSG"] = "User Exists";
return(View(entity));
}
}
}
catch (Exception ex)
{
throw;
}
}
public IActionResult Register(RegisterVM input)
{
if (ModelState.IsValid)
{
if (CheckEmail(input.Email)) //dodatna back-end provjera za zauzetost maila jer ModelState.IsValid ne provjerava REMOTE
{
ModelState.AddModelError("Email", $"Email {input.Email} je zauzet!");
//TempData["ErrorMessage"] = "Check the fields";
}
if (CheckEmail(input.Username)) //dodatna back-end provjera za zauzetost username jer ModelState.IsValid ne provjerava REMOTE
{
ModelState.AddModelError("Username", $"Username {input.Username} je zauzet!");
//TempData["ErrorMessage"] = "Check the fields";
}
if (CheckEmail(input.Username) || CheckEmail(input.Email))
{
return(PartialView("Register", input));
}
TempData["ErrorMessage"] = "Uspjesna registracija!"; //obavijesti korisnika o uspjesnoj registraciji
//dodaj korisnika u bazu
User novi = new User
{
Username = input.Username,
Password = input.Password,
Email = input.Email,
Role = 0
};
db.Users.Add(novi);
db.SaveChanges();
Zaposlenik novi_zaposlenik = new Zaposlenik
{
User = novi,
UserId = novi.UserId
};
db.Zaposlenici.Add(novi_zaposlenik);
db.SaveChanges();
GetSetUser.SetLoggedUser(HttpContext, novi, false); //automatski logiraj novoregistrovanog korisnika
//dodaj zaposlenika u tabelu zaposlenici, default korisnik je zaposlenik
return(RedirectToAction("Index", "Index"));
}
else
{
//TempData["ErrorMessage"] = "Check the fields";
return(PartialView("Register", input));
}
}
public bool AssignToRole(RegisterVM uservm)
{
try
{
ApplicationUserIdentity user = TheUnitOfWork.Account.FindByName(uservm.UserName);
if (uservm.userType == UserType.Teacher)
{
TheUnitOfWork.Account.AssignToRole(user.Id, "Teacher");
Teacher teacher = new Teacher()
{
user = user,
ID = user.Id,
firstName = uservm.firstName,
lastName = uservm.lastName,
gender = uservm.gender.ToString(),
age = uservm.age,
image = "defaultProfile.jpg"
};
user.teacher = teacher;
TheUnitOfWork.Teacher.InsertTeacher(teacher);
TheUnitOfWork.Commit();
}
else if (uservm.userType == UserType.Student)
{
TheUnitOfWork.Account.AssignToRole(user.Id, "Student");
Student student = new Student()
{
user = user,
ID = user.Id,
firstName = uservm.firstName,
lastName = uservm.lastName,
gender = uservm.gender.ToString(),
age = uservm.age,
image = "defaultProfile.jpg"
};
user.student = student;
TheUnitOfWork.Student.InsertStudent(student);
TheUnitOfWork.Commit();
}
return(true);
}
catch
{
return(false);
}
}
public async Task <IActionResult> RegisterAsync([FromBody] RegisterVM model)
{
if (model == null)
{
throw new NullReferenceException("Register model is null");
}
if (ModelState.IsValid)
{
var role = _roleManager.FindByIdAsync(model.RoleId).Result;
if (role.Name == "Customer" || role.Name == "Admin")
{
throw new NullReferenceException("Role is not good");
}
var user = new Account
{
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var roleResult = await _userManager.AddToRoleAsync(user, role.Name);
if (!roleResult.Succeeded)
{
throw new NullReferenceException("Role is not good");
}
await SendPasswordAsync(model.Email, model.Password, model.Email);
Employee employee = new Employee
{
Account = user,
BranchID = model.BranchId
};
_employeeService.AddEmployee(employee);
return(Ok(result)); // Status Code: 200
}
return(BadRequest(result));
}
return(BadRequest("Some properties are not valid")); // Status code: 400
}
public async Task <IActionResult> Register(RegisterVM model)
{
if (ModelState.IsValid)
{
ApplicationUserVM newUser = new ApplicationUserVM
{
UserName = model.Name,
Email = model.Email,
PhoneNumber = model.PhoneNumber
};
MapperConfiguration config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ApplicationUserVM, ApplicationUser>();
});
IMapper map = config.CreateMapper();
ApplicationUser user = map.Map <ApplicationUserVM, ApplicationUser>(newUser);
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
string rgx = @"^(?=.+[0-9])(?=.+[!@#$%^&*])(?=.+[a-z])(?=.+[A-Z])[0-9a-zA-Z!@#$%^&*]{6,}$";
//if (Regex.IsMatch(model.Password, rgx))
//{
// IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
bool roleCheck = await _roleManager.RoleExistsAsync("User");
if (!roleCheck)
{
IdentityResult roleResult = await _roleManager.CreateAsync(new IdentityRole("User"));
}
await _userManager.AddToRoleAsync(user, "User");
SendMessage(user);
return(PartialView("DisplayEmail"));
// }
}
else
{
ModelState.AddModelError("", " Пароль от 6 символов с использованием цифр, спец. символов, латиницы, наличием строчных и прописных символов.");
}
ModelState.AddModelError("", "Пользователь с таким Еmail или именем уже существует");
}
return(View(model));
}
public async Task <IActionResult> Register(RegisterVM register)
{
if (!ModelState.IsValid)
{
ViewBag.RegError = 1;
return(View(register));
}
User user = new User
{
Name = register.Name,
UserName = register.Username,
Email = register.Email,
RegDate = DateTime.Now
};
IdentityResult identityResult = await _userManager.CreateAsync(user, register.Password);
if (!identityResult.Succeeded)
{
foreach (var error in identityResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
ViewBag.RegError = 1;
return(View(register));
}
await _userManager.AddToRoleAsync(user, Helpers.Extensions.Role.User.ToString());
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var link = Url.Action(nameof(VerifyEmail), "Account", new { userId = user.Id, code }, Request.Scheme, Request.Host.ToString());
MailMessage mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**", "Perivallo");
mail.To.Add(new MailAddress(user.Email));
mail.Subject = "Verify your email";
mail.Body = $"<a href=\"{link}\">Verify Email</a>";
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
smtp.Credentials = new NetworkCredential("*****@*****.**", "mybstwrk@prvll");
smtp.Send(mail);
//await _signInManager.SignInAsync(user, true);
return(RedirectToAction("EmailVerification"));
}
public async Task<bool> Create(RegisterVM model)
{
var newUser = new ApplicationUser
{
DisplayName = model.DisplayName,
Email = model.Email,
UserName = model.UserName,
RegistrationDate = DateTime.Now
};
var result = await _users.CreateAsync(newUser, model.Password);
if (result)
{
_loggingService.Info(string.Format("创建用户：{0}",newUser.UserName));
return true;
}
_loggingService.Error(string.Format("创建用户 {0} 失败", newUser.UserName));
return false;
}
public async Task<JsonResult> Create(RegisterVM model)
{
if (ModelState.IsValid)
{
var result = await _userService.Create(model);
//return RedirectToAction("index");
return Json(result, JsonRequestBehavior.DenyGet);
}
return Json(false, JsonRequestBehavior.DenyGet);
}
public async Task<ActionResult> Register(RegisterVM model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.UserName, 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);
}
