private async Task CheckUserAsync(string firstName, string lastName, string email, string phone, string pwd, string role)
{
var userLogin = await _userHelper.GetUserByEmailAsync(email);
if (userLogin == null)
{
userLogin = new UserLogin {
Email = email, PhoneNumber = phone, UserName = email
};
var user = new Usuario {
FirstName = firstName, LastName = lastName, UserLogin = userLogin
};
await _userHelper.AddUserAsync(userLogin, pwd);
await _userHelper.AddUserToRoleAsync(userLogin, role);
_context.Usuarios.Add(user);
await _context.SaveChangesAsync();
var defaultToken = await _userHelper.GenerateEmailConfirmationTokenAsync(userLogin);
await _userHelper.ConfirmEmailAsync(userLogin, defaultToken);
}
}
private async Task <User> AddUserAsync(AddUserViewModel model)
{
User user = new User
{
Address = model.Address,
RFC = model.RFC,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username,
Latitude = model.Latitude,
Longitude = model.Longitude
};
IdentityResult result = await _userHelper.AddUserAsync(user, model.Password);
if (result != IdentityResult.Success)
{
return(null);
}
User newUser = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(newUser, "Customer");
return(newUser);
}
private async Task <User> CreateUserAsync(AddUserViewModel model)
{
var user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
var result = await _userHelper.AddUserAsync(user, model.Password);
if (result.Succeeded)
{
user = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(user, "Owner");
return(user);
}
return(null);
}
private async Task <User> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
string address,
string role)
{
var user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new User
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Address = address,
Document = document
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, role);
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
private async Task <User> AddUser(string userName, string firstName, string lastName, string role)
{
var user = new User
{
FirstName = firstName,
LastName = lastName,
Email = userName,
UserName = userName,
Address = "Quito"
};
var result = await _userHelper.AddUserAsync(user, "Pwd1234");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not create the user in seeder");
}
await _userHelper.AddUserToRoleAsync(user, role);
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
return(user);
}
private async Task <User> AddUser(AddUserViewModel view)
{
var user = new User
{
Address = view.Address,
Document = view.Document,
Email = view.Username,
FirstName = view.FirstName,
LastName = view.LastName,
PhoneNumber = view.PhoneNumber,
UserName = view.Username,
Latitude = view.Latitude,
Longitude = view.Longitude
};
var result = await _userHelper.AddUserAsync(user, view.Password);
if (result != IdentityResult.Success)
{
return(null);
}
var newUser = await _userHelper.GetUserByEmailAsync(view.Username);
await _userHelper.AddUserToRoleAsync(newUser, "Customer");
return(newUser);
}
private async Task <UserEntity> CheckUserAsync(string document, string firstName, string lastName, string email, string phone,
string address, UserType userType)
{
UserEntity user = await _userHelper.GetUserAsync(email); //busca email
if (user == null)
{
user = new UserEntity //crea el user
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Address = address,
Document = document,
Team = _context.Teams.FirstOrDefault(), //coge el primer equipo
UserType = userType
};
await _userHelper.AddUserAsync(user, "123456"); //crea el usuario
await _userHelper.AddUserToRoleAsync(user, userType.ToString()); //añade el role indicado
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
private async Task <Usuario> CheckUserAsync(string Nombres, string Apellidos, string email, string telefono, string rol)
{
var usuario = await _userHelper.GetUserByEmailAsync(email);
if (usuario == null)
{
usuario = new Usuario
{
Nombres = Nombres,
Apellidos = Apellidos,
Email = email,
UserName = email,
PhoneNumber = telefono
};
await _userHelper.AddUserAsync(usuario, "12345678");
await _userHelper.AddUserToRoleAsync(usuario, rol);
}
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(usuario);
await _userHelper.ConfirmEmailAsync(usuario, token);
return(usuario);
}
public async Task SeedAsync()
{
await context.Database.EnsureCreatedAsync();
var user = await userHelper.GetUserByEmailAsync("*****@*****.**");
if (user == null)
{
user = new User
{
FirstName = "Raúl",
LastName = "Grados",
Email = "*****@*****.**",
UserName = "******",
PhoneNumber = "+51961819297"
};
var result = await userHelper.AddUserAsync(user, "mejorando");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not create the user in seeder");
}
}
if (!context.Products.Any())
{
AddProduct("iPhone X", user);
AddProduct("Magic Mouse", user);
AddProduct("Keyboard Logitech", user);
await context.SaveChangesAsync();
}
}
private async Task <UserEntity> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
UserType userType)
{
var user = await _userHelper.GetUserAsync(email);
if (user == null)
{
user = new UserEntity
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Document = document,
UserType = userType,
PicturePath = $"~/images/Users/CaraFeliz.png",
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
public async Task SeedAsync()
{
await context.Database.EnsureCreatedAsync();
var user = await userHelper.GetUserByEmailAsync("*****@*****.**");
if (user == null)
{
user = new User
{
FirstName = "Carlos",
LastName = "Montoya",
Email = "*****@*****.**",
UserName = "******",
PhoneNumber = "1234567"
};
var result = await userHelper.AddUserAsync(user, "123");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("Could not create the user in seeder");
}
}
if (!context.Products.Any())
{
AddProduct("iPhone X", user);
AddProduct("Magic Mouse", user);
AddProduct("iWatch Series 4", user);
await context.SaveChangesAsync();
}
}
private async Task <User> AddUser(AddUserViewModel view)
{
var user = new User
{
Address = view.Address,
Document = view.Document,
Email = view.Username,
FirstName = view.FirstName,
LastName = view.LastName,
PhoneNumber = view.PhoneNumber,
UserName = view.Username
};
var result = await _userHelper.AddUserAsync(user, view.Password);
if (result != IdentityResult.Success)
{
ModelState.AddModelError(string.Empty, result.Errors.FirstOrDefault().Description);
return(null);
}
var newUser = await _userHelper.GetUserByEmailAsync(view.Username);
await _userHelper.AddUserToRoleAsync(newUser, "Customer");
return(newUser);
}
public async Task SeedAsync()
{
await _context.Database.EnsureCreatedAsync();
var user = await _userHelper.GetUserByEmailAsync("*****@*****.**");
if (user == null)
{
user = new User
{
FirstName = "rafael",
LastName = "jesus",
Email = "*****@*****.**",
UserName = "******",
};
var result = await _userHelper.AddUserAsync(user, "123456");
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("could not creat the user in seeder");
}
}
if (!_context.Products.Any())
{
this.AddProduct("iPhone X", user);
this.AddProduct("Rato Mickey", user);
this.AddProduct("iWatch serie 4", user);
this.AddProduct("millennium falcon", user);
await _context.SaveChangesAsync();
}
}
private async Task <User> CheckUserAsync(string document, string firstName, string lastName, string email, string phone, string address,
UserType userType)
{
var user = await _userHelper.GetUserAsync(email);
if (user == null)
{
user = new User
{
Document = document,
Email = email,
FirstName = firstName,
LastName = lastName,
Address = address,
City = _context.Cities.FirstOrDefault(),
UserType = userType,
UserName = email,
PhoneNumber = phone,
};
await _userHelper.AddUserAsync(user, "Eabs123.");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
//Aqui confirmo el usuario creado con token(este por que es el superusuario)
var token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
public async Task <IActionResult> Create(AddUserViewModel model)
{
if (ModelState.IsValid)
{
var user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
var response = await _userHelper.AddUserAsync(user, model.Password);
if (response.Succeeded)
{
var userInDB = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(userInDB, "Admin");
var admin = new Admin
{
User = userInDB
};
_dataContext.Admins.Add(admin);
try
{
await _dataContext.SaveChangesAsync();
var myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
var tokenLink = Url.Action("ConfirmEmail", "Account", new
{
userid = user.Id,
token = myToken
}, protocol: HttpContext.Request.Scheme);
_mailHelper.SendMail(model.Username, "Email confirmation", $"<h1>Email Confirmation</h1>" +
$"To allow the user, " +
$"plase click in this link:</br></br><a href = \"{tokenLink}\">Confirm Email</a>");
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.ToString());
return(View(model));
}
}
ModelState.AddModelError(string.Empty, response.Errors.FirstOrDefault().Description);
}
return(View(model));
}
private async Task <User> CheckUserAsync(
string firstName,
string lastName,
string email,
UserType userType)
{
User user = await _userHelper.GetUserAsyncByEmail(email);
if (user == null)
{
user = new User
{
FirstName = firstName,
LastName = lastName,
IsActive = true,
Email = email,
UserName = email,
UserType = userType
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
}
return(user);
}
private async Task <User> CheckUserAsync(string lastName, string firstName, string mail, string phone, string password, string rol)
{
var user = await userHelper.GetUserByEmailAsync(mail);
if (user == null)
{
user = new User
{
FirstName = firstName,
LastName = lastName,
Email = mail,
UserName = mail,
PhoneNumber = phone,
};
var result = await userHelper.AddUserAsync(user, password);
if (result != IdentityResult.Success)
{
throw new InvalidOperationException("No se puede crear el usuario en la base de datos");
}
await userHelper.AddUserToRoleAsync(user, rol);
}
return(user);
}
private async Task <SlaveEntity> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
UserType userType)
{
SlaveEntity user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new SlaveEntity
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Document = document,
UserType = userType
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
}
return(user);
}
//implementación de método en el mismo owner pero después de se debe pasar a un helpers.
private async Task <User> AddUser(AddUserViewModel model)
{
var user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username,
};
var response = await _userHelper.AddUserAsync(user, model.Password);
if (response != IdentityResult.Success)
{
return(null);
}
var userInDb = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(userInDb, "Customer");
return(userInDb);
}
private async Task <User> CheckUserAsync(string firsName, string lastName, string email, string phone, string address, UserType userType)
{
User user = await _userHelper.GetUserAsync(email);
if (user == null)
{
user = new User
{
FirstName = firsName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Address = address,
UserType = userType,
City = _context.Cities.FirstOrDefault()
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
string token = await _userHelper.GenerateEmailConfirmatioTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
private async Task <User> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
string role)
{
var user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new User
{
Document = document,
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, role);
}
return(user);
}
private async Task <User> CheckUserAsync(string document,
string firstName,
string lastName,
int age,
string gender,
string nationality,
string email,
string role)
{
var user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new User
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
Nationality = nationality,
Gender = gender,
Age = age,
Document = document
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, role);
}
return(user);
}
private async Task <User> CheckUserAsync(string document, TypeDocument TypeDocument, string firstName, string lastName, string email, string phone, string address, bool state, TypeUser role)
{
var user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new User
{
FirstName = firstName,
TypeDocument = TypeDocument,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Address = address,
Document = document,
TypeUser = role,
State = state
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, role.Type);
}
return(user);
}
private async Task <User> AddUser(AddUserViewModel model)
{
var user = new User
{
Address = model.Address,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
var result = await _userHelper.AddUserAsync(user, model.Password);
if (result != IdentityResult.Success)
{
return(null);
}
var newUser = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(newUser, "Admin");
return(newUser);
}
public async Task <IActionResult> Register(AddUserViewModel model)
{
if (ModelState.IsValid)
{
UserEntity user = await _userHelper.AddUserAsync(model, UserType.User);
if (user == null)
{
ModelState.AddModelError(string.Empty, "This email is already used.");
return(View(model));
}
var myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
var tokenLink = Url.Action("ConfirmEmail", "Account", new
{
userid = user.Id,
token = myToken
}, protocol: HttpContext.Request.Scheme);
var response = _mailHelper.SendMail(model.Username, "Email confirmation", $"<h1>Email Confirmation</h1>" +
$"To allow the user, " +
$"plase click in this link:</br></br><a href = \"{tokenLink}\">Confirm Email</a>");
if (response.IsSuccess)
{
ViewBag.Message = "The instructions to allow your user has been sent to email.";
return(View(model));
}
ModelState.AddModelError(string.Empty, response.Message);
}
return(View(model));
}
private async Task <UserEntity> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
string address,
UserType userType)
{
var user = await _userHelper.GetUserByEmailAsync(email);
if (user == null)
{
user = new UserEntity
{
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Address = address,
Document = document,
Team = _context.Teams.FirstOrDefault(),
UserType = userType
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
}
return(user);
}
private async Task <User> createUserAsync(AddUserViewModel model)//Debe retornar el usuario
{
//2. Creamos el objeto user con los atributos capturados del modelo
User user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
//3. Creamos el usuario usando el userHelper y el user que acabamos de crear
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.AddUserAsync(user, model.Password);
if (result.Succeeded)//4. Si lo pudo crear lo traemos de nuevo en nuestra variable user
{
user = await _userHelper.GetUserByEmailAsync(model.Username);
//5. Ahora le agregamos el rol a este usuario
await _userHelper.AddUserToRoleAsync(user, "Owner");
//6. retornamos el usuario
return(user);
}
//7. si falla retornamos null
return(null);
}
private async Task <User> CheckUserAsync(
string document,
string firstName,
string lastName,
string email,
string phone,
UserType userType)
{
User user = await _userHelper.GetUserAsync(email);
if (user == null)
{
user = new User
{
Name = firstName,
LastName = lastName,
Email = email,
UserName = email,
PhoneNumber = phone,
Document = document,
UserType = userType
};
await _userHelper.AddUserAsync(user, "123456");
await _userHelper.AddUserToRoleAsync(user, userType.ToString());
string token = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
await _userHelper.ConfirmEmailAsync(user, token);
}
return(user);
}
public async Task <IActionResult> Create(AddUserViewModel model)
{
if (ModelState.IsValid)
{
var imagePath = string.Empty;
if (model.ImageFile != null)
{
imagePath = await _imageHelper.UploadImageAsync(model.ImageFile, "users");
}
User user = await _userHelper.AddUserAsync(model, imagePath, UserType.Admin);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Este mail ya está en uso.");
model.Departments = _combosHelper.GetComboDepartments();
model.Cities = _combosHelper.GetComboCities(model.DepartmentId);
model.Neighborhoods = _combosHelper.GetComboNeighborhoods(model.CityId);
return(View(model));
}
string myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
string tokenLink = Url.Action("ConfirmEmail", "Account", new
{
userid = user.Id,
token = myToken
}, protocol: HttpContext.Request.Scheme);
Response response = _mailHelper.SendMail(model.Username, "Confirmación de Email", $"<h1>Confirmación de Email</h1>" +
$"Para habilitar el Usuario, " +
$"por favor haga click en este link:</br></br><a href = \"{tokenLink}\">Confirmación de Email</a>");
if (response.IsSuccess)
{
ViewBag.Message = "Las instrucciones para habilitar su usuario han sido enviadas por mail.";
return(View(model));
}
ModelState.AddModelError(string.Empty, response.Message);
}
model.Departments = _combosHelper.GetComboDepartments();
model.Cities = _combosHelper.GetComboCities(model.DepartmentId);
model.Neighborhoods = _combosHelper.GetComboNeighborhoods(model.CityId);
return(View(model));
}
public async Task <IActionResult> Register(AddUserViewModel model)
{
if (ModelState.IsValid)
{
Guid imageId = Guid.Empty;
if (model.ImageFile != null)
{
imageId = await _blobHelper.UploadBlobAsync(model.ImageFile, "users");
}
User user = await _userHelper.AddUserAsync(model, imageId, UserType.User);
if (user == null)
{
ModelState.AddModelError(string.Empty, "This email is already used.");
model.Countries = _combosHelper.GetComboCountries();
model.Departments = _combosHelper.GetComboDepartments(model.CountryId);
model.Cities = _combosHelper.GetComboCities(model.DepartmentId);
return(View(model));
}
string myToken = await _userHelper.GenerateEmailConfirmationTokenAsync(user);
string tokenLink = Url.Action("ConfirmEmail", "Account", new
{
userid = user.Id,
token = myToken
}, protocol: HttpContext.Request.Scheme);
Response response = _mailHelper.SendMail(model.Username, "Email confirmation", $"<h1>Email Confirmation</h1>" +
$"To allow the user, " +
$"plase click in this link:<p><a href = \"{tokenLink}\">Confirm Email</a></p>");
if (response.IsSuccess)
{
ViewBag.Message = "The instructions to allow your user has been sent to email.";
return(View(model));
}
ModelState.AddModelError(string.Empty, response.Message);
}
model.Countries = _combosHelper.GetComboCountries();
model.Departments = _combosHelper.GetComboDepartments(model.CountryId);
model.Cities = _combosHelper.GetComboCities(model.DepartmentId);
return(View(model));
}
