public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
// API Resquet to validate email with DB
var customer = new HttpClient();
var responseApi = await customer.GetAsync("https://rocketrestapi.azurewebsites.net/api/Customers");
var content = responseApi.Content.ReadAsStringAsync().Result;
if (content.Contains(Input.Email))
{
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Invalid email. Please use valide email or contact us.");
return(Page());
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
Addres = Input.Addres,
City = Input.City,
PostalCode = Input.PostalCode,
PhoneNumber = Input.PhoneNumber
};
if (!Input.isAdmin)
{
user.EmailConfirmed = true;
}
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(StaticDetails.AdminEndUser))
{
await _roleManager.CreateAsync(new IdentityRole(StaticDetails.AdminEndUser));
}
if (!await _roleManager.RoleExistsAsync(StaticDetails.CustomerEndUser))
{
await _roleManager.CreateAsync(new IdentityRole(StaticDetails.CustomerEndUser));
}
_logger.LogInformation("El usuario creó una nueva cuenta con password");
if (Input.isAdmin)
{
await _userManager.AddToRoleAsync(user, StaticDetails.AdminEndUser);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(RedirectToPage("/Users/Index"));
}
else
{
await _userManager.AddToRoleAsync(user, StaticDetails.CustomerEndUser);
//este SigIn solo se debe llamar para usuarios que no sean Admin
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var roleCheck = false;
switch (Input.Email)
{
case "*****@*****.**":
roleCheck = await _roleManager.RoleExistsAsync("Laboratory");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("Laboratory"));
}
await _userManager.AddToRoleAsync(user, "Laboratory");
break;
case "*****@*****.**":
roleCheck = await _roleManager.RoleExistsAsync("CEO");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("CEO"));
}
await _userManager.AddToRoleAsync(user, "CEO");
break;
default:
roleCheck = await _roleManager.RoleExistsAsync("Taster");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("Taster"));
}
await _userManager.AddToRoleAsync(user, "Taster");
if (await _userManager.IsInRoleAsync(user, "Taster"))
{
var taster = new Taster {
TasterEmail = Input.Email, TasterName = Input.FirstName, TasterSecondName = Input.SecondName
};
_context.Add(taster);
await _context.SaveChangesAsync();
}
break;
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new User {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync("reply"))
{
await _roleManager.CreateAsync(new Role("reply"));
}
if (!await _roleManager.RoleExistsAsync("publish"))
{
await _roleManager.CreateAsync(new Role("publish"));
}
if (!await _roleManager.RoleExistsAsync("buy"))
{
await _roleManager.CreateAsync(new Role("buy"));
}
await _userManager.AddToRoleAsync(user, "reply");
await _userManager.AddToRoleAsync(user, "publish");
await _userManager.AddToRoleAsync(user, "buy");
_logger.LogInformation("用户成功的创建了一个新账户");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(
Input.Email,
"欢迎来到河马回收平台",
$"请点击 <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>来注册</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new MemCheckUser {
UserName = Input.UserName, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code },
protocol: Request.Scheme) !;
var mailBody = new StringBuilder();
mailBody.Append($"<p>{localizer["Hello"].Value} {user.UserName}</p>");
mailBody.Append($"<p>{localizer["BeforeHyperLink"].Value}</p>");
mailBody.Append($"<p><a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>{localizer["HyperLinkText"].Value}</a></p>");
mailBody.Append($"<p>{localizer["AfterHyperLink"].Value}</p>");
mailBody.Append($"<p>{localizer["Final"].Value}</p>");
await _emailSender.SendEmailAsync(Input.Email, localizer["MailSubject"].Value, mailBody.ToString());
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { UserAddress = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(Input.Email)) }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect("/"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
//adding user to application use table insted of Identity user
//adding with more properties like FN, LN, PN
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
PhoneNumber = Input.PhoneNumber
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
//Assign Facebook register user customer role
//so that all user that register with facbook they are only customer
await _userManager.AddToRoleAsync(user, SD.CustomerRole);
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
Input.SportType = Input.SportType ?? null;
Input.BallRenting = Input.BallRenting ?? false;
Input.LockerRoom = Input.LockerRoom ?? false;
Input.Safe = Input.Safe ?? false;
Input.Toilet = Input.Toilet ?? false;
Input.ForLadies = Input.ForLadies ?? false;
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
FullName = Input.FullName,
biography = Input.Biography,
Location = Input.Location,
SportType = Input.SportType,
Category = SelectedRole,
BallRenting = Input.BallRenting,
LockerRoom = Input.LockerRoom,
Safe = Input.Safe,
Toilet = Input.Toilet,
ForLadies = Input.ForLadies
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
System.Diagnostics.Debug.WriteLine(SelectedRole);
var createdUser = await _userManager.FindByNameAsync(user.UserName);
await _userManager.AddToRoleAsync(createdUser, SelectedRole);
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
CompanyId = Input.CompanyId,
StreetAddress = Input.StreetAddress,
City = Input.City,
State = Input.State,
PostalCode = Input.PostalCode,
Name = Input.Name,
PhoneNumber = Input.PhoneNumber,
Role = Input.Role
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
if (user.Role == null)
{
await _userManager.AddToRoleAsync(user, SD.Role_User_Indi);
}
else
{
if (user.CompanyId > 0)
{
await _userManager.AddToRoleAsync(user, SD.Role_User_Comp);
}
await _userManager.AddToRoleAsync(user, user.Role);
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
if (user.Role == null)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
else
{
//admin is registering a new user
return(RedirectToAction("Index", "User", new { Area = "Admin" }));
}
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
Input = new InputModel()
{
CompanyList = _unitOfWork.Company.GetAll().Select(i => new SelectListItem
{
Text = i.Name,
Value = i.Id.ToString()
}),
RoleList = _roleManager.Roles.Where(u => u.Name != SD.Role_User_Indi).Select(x => x.Name).Select(i => new SelectListItem
{
Text = i,
Value = i
})
};
// If we got this far, something failed, redisplay form
return(Page());
}
/// <summary>
/// este método reage a uma interação por HTTP POST
/// </summary>
/// <param name="fotoUser">Fotografia do novo Utilizador</param>
/// <param name="returnUrl">caso exista, define para onde se reencaminha a ação do programa, após o Registo </param>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync(IFormFile fotoUser, string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
// se o InputModel é válido...
// neste sítio, temos de adicionar o código
// construído na criação de um novo veterinário
// para a adição de uma fotografia
// **************************************
// processar a fotografia
// **************************************
// vars. auxiliares
string caminhoCompleto = "";
string nomeFoto = "";
bool haImagem = false;
// será q há fotografia?
// - uma hipótese possível, seria reenviar os dados para a View e solicitar a adição da imagem
// - outra hipótese, será associar ao veterinário uma fotografia 'por defeito'
if (fotoUser == null)
{
nomeFoto = "NoUser.png";
}
else
{
// há ficheiro
// será o ficheiro uma imagem?
if (fotoUser.ContentType == "image/jpeg" ||
fotoUser.ContentType == "image/png")
{
// o ficheiro é uma imagem válida
// preparar a imagem para ser guardada no disco rígido
// e o seu nome associado ao Veterinario
Guid g;
g = Guid.NewGuid();
string extensao = Path.GetExtension(fotoUser.FileName).ToLower();
string nome = g.ToString() + extensao;
// onde guardar o ficheiro
caminhoCompleto = Path.Combine(_caminho.WebRootPath, "Imagens\\Users", nome);
// associar o nome do ficheiro ao Veterinário
nomeFoto = nome;
// assinalar que existe imagem e é preciso guardá-la no disco rígido
haImagem = true;
}
else
{
// há imagem, mas não é do tipo correto
nomeFoto = "NoUser.png";
}
}
// criação de um novo utilizador
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
Nome = Input.Nome,
Fotografia = nomeFoto,
Timestamp = DateTime.Now
};
// vou escrever esses dados na BD
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
// se cheguei aqui, é pq houve sucesso na escrita na BD
// vou, agora, guardar a imagem no disco rígido do Servidor
// se há imagem, vou guardá-la no disco rígido
if (haImagem)
{
using var stream = new FileStream(caminhoCompleto, FileMode.Create);
await fotoUser.CopyToAsync(stream);
}
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
