public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
user.HomeTown = model.HomeTown;
user.MyUserInfo = new MyUserInfo() { FirstName = model.UserName };
// Store Gender as Claim
user.Claims.Add(new IdentityUserClaim() { ClaimType = ClaimTypes.Gender, ClaimValue = "Male" });
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
using(var db= new ELearningContext())
{
User userr= new User(){UserName=model.UserName, Password= model.Password};
db.Users.Add(userr);
db.SaveChanges();
}
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName};
try
{
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, false);
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
catch (Exception)
{
//When no database, sometimes database creation fails.
AddErrors(new IdentityResult("Database creation failed, please restart the application!"));
return View(model);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Create(RegisterViewModel userViewModel, params string[] selectedRoles)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = userViewModel.Email, Email = userViewModel.Email, NickName = userViewModel.NickName };
var adminresult = await UserManager.CreateAsync(user, userViewModel.Password);
if (adminresult.Succeeded)
{
if (selectedRoles != null)
{
var result = await UserManager.AddToRolesAsync(user.Id, selectedRoles);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name");
return View();
}
}
}
else
{
ModelState.AddModelError("", adminresult.Errors.First());
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");
return View();
}
return RedirectToAction("Index");
}
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");
return View();
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
try
{
// Create a profile, password, and link the local login before signing in the user
User user = new User(model.UserName);
if (await IdentityStore.CreateLocalUser(user, model.Password))
{
await AuthenticationManager.SignIn(HttpContext, user.Id, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
ModelState.AddModelError("", "Failed to register user name: " + model.UserName);
}
}
catch (IdentityException e)
{
ModelState.AddModelError("", e.Message);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
var service = new Service();
User register = new User();
register.Active = true;
register.BirthYear = model.BirthYear;
register.DisplayName = model.DisplayName;
register.Email = model.Email;
register.Gender = model.Gender;
register.UserName = model.UserName;
service.CreateUser(ref register);
DisplayWelcomeMessage(register);
return RedirectToAction("Index", "User");
}
else
{
ModelState.AddModelError("UserName", "That username is already taken");
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form.
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
var userValidator = UserManager.UserValidator as UserValidator<ApplicationUser>;
userValidator.AllowOnlyAlphanumericUserNames = false; //not sure why these two lines work, but I can now use @symbol in username allowing for emails as userName.
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName, SuggestedAccount = model.SuggestedAccount, GradeLevel = model.GradeLevel};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, model.SuggestedAccount);
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var confirmationToken = CreateConfirmationToken();
var user = new ApplicationUser
{
UserName = model.UserName,
EmailAddress = model.EmailAddress,
ConfirmationToken = confirmationToken,
IsConfirmed = false
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//await SignInAsync(user, isPersistent: false);
SendEmailConfirmation(model.EmailAddress, model.UserName, confirmationToken);
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
OglasController aleksaoglas = new OglasController();
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
var korisnik = new Korisnik() { IDKorisnik = user.Id, eMail = user.UserName, MailStize = 0 };
aleksaoglas.baza.Korisnik.Add(korisnik);
aleksaoglas.baza.SaveChanges();
return RedirectToAction("Login", "Account");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult Register(RegisterViewModel viewModel)
{
var anyUser = userService.GetAllUserEntities().Any(u => u.Login==viewModel.Login);
if (anyUser)
{
ModelState.AddModelError("", "User with this address already registered.");
return View(viewModel);
}
if (ModelState.IsValid)
{
var membershipUser = ((CustomMembershipProvider)Membership.Provider)
.CreateUser(viewModel.Login, viewModel.Password,viewModel.Name);
if (membershipUser != null)
{
FormsAuthentication.SetAuthCookie(viewModel.Login, false);
TempData["user"] = userService.GetByLogin(viewModel.Login).ToPlUser();
return RedirectToAction("Index", "Home");
}
else
{
ModelState.AddModelError("", "Error registration.");
}
}
return View(viewModel);
}
public async Task<User> RegisterAsync (RegisterViewModel registerViewModel)
{
// client = clientFactory.CreateHttpClient ();
HttpClient client = new HttpClient ();
client.BaseAddress = new Uri("http://spotvox.azurewebsites.net/");
client.DefaultRequestHeaders.Clear ();
client.DefaultRequestHeaders.Accept.Clear ();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
using (client) {
string userJson = JsonConvert.SerializeObject (registerViewModel);
HttpContent content = new StringContent (userJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync ("api/account/register", content);
if (response.IsSuccessStatusCode) {
string jsonMessage;
using (Stream responseStream = await response.Content.ReadAsStreamAsync ()) {
jsonMessage = new StreamReader (responseStream).ReadToEnd ();
}
User user = (User)JsonConvert.DeserializeObject (jsonMessage, typeof(User));
LoginViewModel loginModel = new LoginViewModel ();
loginModel.Email = user.Email;
loginModel.Password = registerViewModel.Password;
user = await LoginAsync(loginModel);
return user;
} else {
return null;
}
}
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.UserName,
MoneyBirdAccountName = model.MoneyBirdAccountName,
MoneyBirdUserName = model.MoneyBirdUserName,
MoneyBirdPassword = model.MoneyBirdPassword
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Create()
{
//Get the list of Roles
var model = new RegisterViewModel();
model.CategoriesList = new SelectList(await CategoryManager.Categories.ToListAsync(), "Name", "Name");
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
using (var context = new ApplicationDbContext())
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName, Name = model.Name, LastName = model.LastName, Status = "Active" };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
userManager.AddToRole(user.Id, "SimpleUser");
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
// Create a local login before signing in the user
var user = new ApplicationUser()
{
UserName = model.UserName,
DisplayName = model.DisplayName,
FacebookProfile = model.FacebookProfile,
};
var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password);
if (result.Success)
{
await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new MailPigUser
{
UserName = model.Email,
Email = model.Email,
Oib = model.Oib,
UsedForCommercialPurposes = model.UsedForCommercialPurposes,
OrganisationName = model.OrganisationName
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: 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", "Dashboard");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
user.Email = model.Email;
user.ConfirmedEmail = false;
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
System.Net.Mail.MailMessage m = new System.Net.Mail.MailMessage(
new System.Net.Mail.MailAddress("*****@*****.**", "Web Registration"),
new System.Net.Mail.MailAddress(user.Email));
m.Subject = "Email confirmation";
m.Body = string.Format("Dear {0}<BR/>Thank you for your registration, please click on the below link to complete your registration: <a href=\"{1}\" title=\"User Email Confirm\">{1}</a>", user.UserName, Url.Action("ConfirmEmail", "Account", new { Token = user.Id, Email = user.Email }, Request.Url.Scheme));
m.IsBodyHtml = true;
System.Net.Mail.SmtpClient smtp = new System.Net.Mail.SmtpClient("smtp.mydomain.com");
smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "password");
smtp.EnableSsl = true;
smtp.Send(m);
return RedirectToAction("Confirm", "Account", new { Email = user.Email });
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (model.UserName.Length > 16 || model.UserName.Length < 6)
{
ModelState.AddModelError("UserName", "The username should be between 6 and 16 characters long.");
}
if (ModelState.IsValid)
{
// Create a local login before signing in the user
var user = new ApplicationUser { UserName = model.UserName, Points = 10};
var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password);
if (result.Success)
{
await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
// Create a local login before signing in the user
var user = new ApplicationUser
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
PhotoUrl = (model.Photo ?? @"../../img/Avatars/default-avatar.jpg")
};
var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password);
if (result.Success)
{
await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
return Json(new ServiceOperationResult(false, Main.InvalidForm), JsonRequestBehavior.AllowGet);
return Json(PiServices.UserService.AddUser(model), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User()
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Phone = model.Phone,
CellPhone = model.CellPhone,
Gender = model.Gender,
Birthday = model.Birthday,
Address = model.Address,
CreationDate = DateTime.UtcNow.AddHours(-5)
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
CreateResponse response = await this.Membership.CreateAsync(new CreateRequest()
{
UserName = model.UserName,
Password = model.Password,
AuthenticationType = DataContract.AuthenticationTypeEnum.ApplicationCookie
});
if (response.Success)
{
ClaimsIdentity identity = response.ClaimIdentity.ConvertToClaimsIdentity();
SignInAsync(identity, IsPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(response.Errors);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Create(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var succeded = true;
var user = new CustomUser { UserName = model.Email, Email = model.Email };
var adminresult = await UserManager.CreateAsync(user, model.Password);
if (!adminresult.Succeeded)
{
ModelState.AddModelError("", adminresult.Errors.First());
}
else
{
user = await UserManager.FindByEmailAsync(model.Email);
var result = await UserManager.AddToCategoryAsync(user.Id, model.Category);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
}
else
{
return RedirectToAction("Index");
}
}
}
model.CategoriesList = new SelectList(await CategoryManager.Categories.ToListAsync(), "Name", "Name");
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
ServiceUser serviceUser = new ServiceUser
{
Name = model.UserName,
RoleId = 2
};
ServiceUserRepository.Instance.AddUser(serviceUser);
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
if (await RecaptchaIsValid(Request.Form["g-recaptcha-response"]))
//if(true)
{
var user = new ApplicationUser() { UserName = model.UserName };
var result = UserManager.Create(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
ModelState.AddModelError(
"invalid-recaptcha-response",
"Please answer the recaptcha challenge.");
}
return View();
}
public async Task<ActionResult> Join(string JoinCode)
{
//set up the confirmation page so the user can confim he wants to change households
//might also need a view model for this page
var invitation = await db.Invitations.FirstOrDefaultAsync(i => i.JoinCode.ToString() == JoinCode);
if (invitation != null)
{
var model = new RegisterViewModel
{
HouseholdId = invitation.Household.Id,
HouseholdName = invitation.Household.Name,
Email = invitation.ToEmail
};
var user = db.Users.FirstOrDefault(u => u.Email == invitation.ToEmail);
if (user != null)
{
//then user exists / populate user info
model.FirstName = user.FirstName;
model.LastName = user.LastName;
}
return View(model);
}
else
{
return RedirectToAction("Login", "Account", new {message = "Unauthorized"});
}
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserService.AddUser(new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Username = model.UserName,
Password = UserManager.PasswordHasher.HashPassword(model.Password),
Email = model.EmailAddress,
IsAdmin = false
});
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Home", "User");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (user.Roles.Count == 0)
{
UserManager.AddToRole(user.Id, "User");
}
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
TimeZoneId = _generalSettings.Value.DefaultTimeZone
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(new UrlActionContext { Action = nameof(ConfirmEmail), Controller = "Admin", Values = new { userId = user.Id, token = token }, Protocol = Request.Scheme });
await _mediator.SendAsync(new SendConfirmAccountEmail { Email = model.Email, CallbackUrl = callbackUrl });
return RedirectToAction(nameof(DisplayEmail), "Admin");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser() { UserName = model.UserName };
user.UserInfo = new ApplicationUserInfo { ApplicationUser = user };
Image defaultAvatar = new Image { Name = "defaultAvatar" };
user.UserInfo.Avatar = defaultAvatar;
db.SaveChanges();
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
db.SaveChanges();
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task <ActionResult> Register(RegisterViewModel 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)
{
// ############################################################
// Claims-aware "Register" method to handle user-submitted data
// GivenName and Surname are claims - we gather them on the HTML Form
// The RegisterViewModel class was modified, to add these properties
// We also configure some "role" claims
// Add claims
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Email, model.Email));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.GivenName, model.GivenName));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Surname, model.Surname));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, "User"));
// Role claims processing
// In this web app template, the user submits zero or more claims, as strings
// We will go through the collection, and add each one
foreach (var role in model.Roles)
{
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, role.Trim()));
}
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("Details", "Account"));
// ############################################################
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
var form = AutoMapper.Mapper.Map <RegisterViewModelForm>(model);
Manager m = new Manager();
var roles = m.RoleClaimGetAllStrings();
form.RoleList = new MultiSelectList(
items: roles,
selectedValues: model.Roles);
return(View(form));
}
private ActionResult RegisterView(RegisterViewModel model)
{
ViewBag.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled;
return(View("Register", model));
}
/// <summary>
/// Create instagram user.
/// </summary>
/// <param name="connection"></param>
/// <param name="userId"></param>
/// <param name="userInfo"></param>
public static void CreateInstagramUser(IDbConnection connection, string userId, RegisterViewModel userInfo)
{
var p = new DynamicParameters();
p.Add("A_Id", userId);
p.Add("A_UserName", userInfo.User_Name);
p.Add("A_Email", userInfo.Email);
p.Add("A_FullName", userInfo.Full_Name);
connection.Execute("CreateInstagramUser", p, commandType: CommandType.StoredProcedure);
}
public async Task <IdentityResult> RegisterAccount(RegisterViewModel model)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
RegisterDate = DateTime.Now,
RegisterIP = System.Web.HttpContext.Current.Request.GetVisitorIP(),
LastAccessDate = DateTime.Now,
LastAccessIP = System.Web.HttpContext.Current.Request.GetVisitorIP()
};
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>");
// Send Message
var roleAdministrator = await RoleManager.FindByNameAsync(BeYourMarket.Model.Enum.Enum_UserRole.Administrator.ToString());
var administrator = roleAdministrator.Users.FirstOrDefault();
var message = new MessageSendModel()
{
UserFrom = administrator.UserId,
UserTo = user.Id,
Subject = HttpContext.ParseAndTranslate(string.Format("[[[Welcome to {0}!]]]", CacheHelper.Settings.Name)),
Body = HttpContext.ParseAndTranslate(string.Format("[[[Hi, Welcome to {0}! I am happy to assist you if you has any questions.]]]", CacheHelper.Settings.Name))
};
await MessageHelper.SendMessage(message);
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var urlHelper = new UrlHelper(System.Web.HttpContext.Current.Request.RequestContext);
var callbackUrl = urlHelper.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: System.Web.HttpContext.Current.Request.Url.Scheme);
var emailTemplateQuery = await _emailTemplateService.Query(x => x.Slug.ToLower() == "signup").SelectAsync();
var emailTemplate = emailTemplateQuery.FirstOrDefault();
if (emailTemplate != null)
{
dynamic email = new Postal.Email("Email");
email.To = user.Email;
email.From = CacheHelper.Settings.EmailAddress;
email.Subject = emailTemplate.Subject;
email.Body = emailTemplate.Body;
email.CallbackUrl = callbackUrl;
EmailHelper.SendEmail(email);
}
}
return(result);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
ExternalLoginInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
throw new Exception("Can not external login!");
}
model.UserName = model.EmailAddress;
model.Password = Authorization.Users.User.CreateRandomPassword();
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
var user = await _userRegistrationManager.RegisterAsync(
model.Name,
model.Surname,
model.EmailAddress,
model.UserName,
model.Password,
true // Assumed email address is always confirmed. Change this if you want to implement email confirmation.
);
// Getting tenant-specific settings
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
if (model.IsExternalLogin)
{
Debug.Assert(externalLoginInfo != null);
if (string.Equals(externalLoginInfo.Principal.FindFirstValue(ClaimTypes.Email), model.EmailAddress, StringComparison.OrdinalIgnoreCase))
{
user.IsEmailConfirmed = true;
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.ProviderKey,
TenantId = user.TenantId
}
};
}
await _unitOfWorkManager.Current.SaveChangesAsync();
Debug.Assert(user.TenantId != null);
var tenant = await _tenantManager.GetByIdAsync(user.TenantId.Value);
// Directly login if possible
if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await _signInManager.SignInAsync(loginResult.Identity, false);
return(Redirect(GetAppHomeUrl()));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsEmailConfirmed = user.IsEmailConfirmed,
IsActive = user.IsActive,
IsEmailConfirmationRequiredForLogin = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public virtual async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
//Get tenancy name and tenant
if (!_multiTenancyConfig.IsEnabled)
{
model.TenancyName = Tenant.DefaultTenantName;
}
else if (model.TenancyName.IsNullOrEmpty())
{
throw new UserFriendlyException(L("TenantNameCanNotBeEmpty"));
}
CurrentUnitOfWork.SetTenantId(null);
var tenant = await GetActiveTenantAsync(model.TenancyName);
CurrentUnitOfWork.SetTenantId(tenant.Id);
//Create user
var user = new User
{
TenantId = tenant.Id,
Name = model.Name,
Surname = model.Surname,
EmailAddress = model.EmailAddress,
IsActive = true
};
//Get external login info if possible
ExternalLoginUserInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await HttpContext.Authentication.GetExternalLoginUserInfo(model.ExternalLoginAuthSchema);
if (externalLoginInfo == null)
{
throw new ApplicationException("Can not external login!");
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.LoginInfo.ProviderKey,
TenantId = tenant.Id
}
};
model.UserName = model.UserName;
model.Password = Users.User.CreateRandomPassword();
if (string.Equals(externalLoginInfo.EmailAddress, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
user.IsEmailConfirmed = true;
}
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
user.UserName = model.UserName;
user.Password = new PasswordHasher().HashPassword(model.Password);
//Add default roles
user.Roles = new List <UserRole>();
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
user.Roles.Add(new UserRole {
RoleId = defaultRole.Id
});
}
//Save user
CheckErrors(await _userManager.CreateAsync(user));
await _unitOfWorkManager.Current.SaveChangesAsync();
//Directly login if possible
if (user.IsActive)
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo.LoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
return(Redirect(Url.Action("Index", "Home")));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
//If can not login, show a register result page
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsActive = user.IsActive
}));
}
catch (UserFriendlyException ex)
{
ViewBag.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled;
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public void SetUp()
{
assembler = Substitute.For <IUserAssembler>();
dataAccess = Substitute.For <IUserDataAccess>();
errorHelper = Substitute.For <IErrorHelper>();
errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
validRegisterUserRequest = new RegisterUserRequest
{
DateOfBirth = DateTime.Now,
EmailAddress = "TEST",
FirstName = "TEST",
LastName = "TEST",
Password = "******",
Username = "******"
};
validValidateUserResponse = new ValidateUserResponse
{
LoginSuccess = true,
RequestReference = Guid.NewGuid(),
User =
new UserProxy
{
EmailAddress = "TEST",
DateOfBirth = DateTime.Now,
FirstName = "TEST",
Id = Guid.NewGuid(),
LastName = "TEST"
}
};
invalidValidateUserResponse = new ValidateUserResponse {
Errors = { new ResponseErrorWrapper() }
};
validValidateUserRequest = new ValidateUserRequest
{
EmailAddress = "TEST",
Password = "******",
Username = "******"
};
invalidValidateUserRequest = new ValidateUserRequest
{
EmailAddress = string.Empty,
Password = string.Empty,
Username = string.Empty
};
validLoginViewModel = new LoginViewModel {
EmailAddress = "TEST", Password = "******", ReturnUrl = "TEST"
};
invalidLoginViewModel = new LoginViewModel
{
EmailAddress = string.Empty,
Password = string.Empty,
ReturnUrl = string.Empty
};
invalidRegisterViewModel = new RegisterViewModel
{
AcceptTermsAndConditions = false,
ConfirmPassword = string.Empty,
DateOfBirth = DateTime.MinValue,
EmailAddress = string.Empty,
FirstName = string.Empty,
LastName = string.Empty,
Password = string.Empty
};
validRegisterUserResponse = new RegisterUserResponse
{
RequestReference = Guid.NewGuid(),
RegisterSuccess = true
};
invalidRegisterUserResponse = new RegisterUserResponse
{
RequestReference = Guid.NewGuid(),
Errors =
{
new ResponseErrorWrapper()
},
RegisterSuccess = false
};
validRegisterViewModel = new RegisterViewModel
{
AcceptTermsAndConditions = true,
ConfirmPassword = "******",
DateOfBirth = DateTime.Now,
EmailAddress = "TEST",
FirstName = "TEST",
LastName = "TEST",
Password = "******"
};
invalidRegisterUserRequest = new RegisterUserRequest
{
DateOfBirth = DateTime.MinValue,
EmailAddress = string.Empty,
FirstName = string.Empty,
LastName = string.Empty,
Password = string.Empty,
Username = string.Empty
};
assembler.NewRegisterUserRequest(invalidRegisterViewModel).Returns(invalidRegisterUserRequest);
assembler.NewRegisterUserRequest(validRegisterViewModel).Returns(validRegisterUserRequest);
assembler.NewRegisterUserRequest(null).Throws(new Exception("TEST EXCEPTION"));
assembler.NewValidateUserRequest(invalidLoginViewModel).Returns(invalidValidateUserRequest);
assembler.NewValidateUserRequest(validLoginViewModel).Returns(validValidateUserRequest);
assembler.NewValidateUserRequest(null).Throws(new Exception("TEST EXCEPTION"));
assembler.NewClaimsIdentity(validValidateUserResponse).Returns(new ClaimsIdentity());
dataAccess.RegisterUser(invalidRegisterUserRequest).Returns(invalidRegisterUserResponse);
dataAccess.RegisterUser(validRegisterUserRequest).Returns(validRegisterUserResponse);
dataAccess.ValidateUser(invalidValidateUserRequest).Returns(invalidValidateUserResponse);
dataAccess.ValidateUser(validValidateUserRequest).Returns(validValidateUserResponse);
orchestrator = new UserOrchestrator(assembler, dataAccess, errorHelper);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (model.Role == "Patient")
{
if (ModelState.IsValid)
{
var user = new Patient {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date, Profession = model.Profession, Allergies = model.Allergies, SpecialReq = model.SpecialReq
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771
// Envoyer un message électronique avec ce lien
// 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return(View(model));
}
else if (model.Role == "Doctor")
{
if (ModelState.IsValid)
{
var user = new Doctor {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date, Speciality = model.Speciality, Location = model.Location
};
if (model.Surgeon == "Yes")
{
user.Surgeon = true;
}
else if (model.Surgeon == "No")
{
user.Surgeon = false;
}
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771
// Envoyer un message électronique avec ce lien
// 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return(View(model));
}
else
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771
// Envoyer un message électronique avec ce lien
// 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return(View(model));
}
}
public virtual async Task <UserLoginResult> TryRegister(
RegisterViewModel model,
ModelStateDictionary modelState,
HttpContext httpContext,
IHandleCustomRegistration customRegistration
)
{
var template = new LoginResultTemplate();
IUserContext userContext = null;
var userName = !string.IsNullOrWhiteSpace(model.Username) ? model.Username : await _userManager.SuggestLoginNameFromEmail(_userManager.Site.Id, model.Email);
var userNameAvailable = await _userManager.LoginIsAvailable(Guid.Empty, userName);
if (!userNameAvailable)
{
userName = await _userManager.SuggestLoginNameFromEmail(_userManager.Site.Id, model.Email);
}
var user = new SiteUser
{
SiteId = _userManager.Site.Id,
UserName = userName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
DisplayName = model.DisplayName,
LastLoginUtc = DateTime.UtcNow,
AccountApproved = _userManager.Site.RequireApprovalBeforeLogin ? false : true
};
await customRegistration.ProcessUserBeforeCreate(user, httpContext);
if (model.DateOfBirth.HasValue)
{
user.DateOfBirth = model.DateOfBirth.Value;
}
if (!string.IsNullOrWhiteSpace(_userManager.Site.RegistrationAgreement))
{
if (model.AgreeToTerms)
{
user.AgreementAcceptedUtc = DateTime.UtcNow;
}
}
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
template.User = user;
template.IsNewUserRegistration = true;
await _loginRulesProcessor.ProcessAccountLoginRules(template);
}
else
{
foreach (var error in result.Errors)
{
modelState.AddModelError(string.Empty, error.Description);
}
}
if (template.RejectReasons.Count == 0 &&
user != null &&
template.SignInResult == SignInResult.Failed && // failed is initial state, could have been changed to lockedout
result.Errors.Count <IdentityError>() == 0
)
{
await _signInManager.SignInAsync(user, isPersistent : false);
template.SignInResult = SignInResult.Success;
}
if (template.User != null)
{
userContext = new UserContext(template.User);
}
return(new UserLoginResult(
template.SignInResult,
template.RejectReasons,
userContext,
template.IsNewUserRegistration,
template.MustAcceptTerms,
template.NeedsAccountApproval,
template.NeedsEmailConfirmation,
template.EmailConfirmationToken,
template.NeedsPhoneConfirmation
));
}
public async Task <IActionResult> Create(RegisterViewModel registerViewModel)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
if (!User.IsInRole("Admin"))
{
return(RedirectToAction("Login", "Account"));
}
if (!ModelState.IsValid)
{
ViewBag.Active = "Home";
return(View(registerViewModel));
}
AppUser newUser;
if (registerViewModel.Photo != null)
{
if (!registerViewModel.Photo.IsImage())
{
ViewBag.Active = "Home";
ModelState.AddModelError("Photo", "File type should be image");
return(View(registerViewModel));
}
string filename = await registerViewModel.Photo.SaveAsync(_env.WebRootPath);
registerViewModel.PhotoURL = filename;
newUser = new AppUser
{
Firstname = registerViewModel.Firstname.Trim(),
Lastname = registerViewModel.Lastname.Trim(),
Email = registerViewModel.Email.Trim(),
UserName = registerViewModel.Username.Trim(),
PhoneNumber = registerViewModel.Phone.Trim(),
PhotoURL = registerViewModel.PhotoURL
};
}
else
{
newUser = new AppUser
{
Firstname = registerViewModel.Firstname.Trim(),
Lastname = registerViewModel.Lastname.Trim(),
Email = registerViewModel.Email.Trim(),
UserName = registerViewModel.Username.Trim(),
PhoneNumber = registerViewModel.Phone.Trim(),
PhotoURL = "Person-icon.png"
};
}
IdentityResult identityResult = await _usermanager.CreateAsync(newUser, registerViewModel.Password);
if (!identityResult.Succeeded)
{
foreach (var error in identityResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
ViewBag.Active = "Home";
return(View(registerViewModel));
}
//add default member role to user
await _usermanager.AddToRoleAsync(newUser, StaticUsers.Member);
ViewBag.Active = "Home";
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
if (model == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Fullname, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
//Assign Role to user Here
await this.UserManager.AddToRoleAsync(user.Id, model.RoleName);
//Ends Here
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
}
else
{
ModelState.AddModelError(string.Empty,
"Error: Failed to create the user. Check password requirements.");
switch (model.RoleName)
{
case "Super Admin":
return(RedirectToAction("Login", "Account"));
case "Sales Admin":
return(RedirectToAction("RegisterSalesAdmin", "Account"));
default:
break;
}
//return View(model);
}
}
catch (Exception ex)
{
Console.WriteLine("Error Message:" + ex.Message);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
