public async Task <IActionResult> Registrar(RegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
if (await _userManager.FindByEmailAsync(modelo.Email) != null)
{
return(View("../ConfirmeEmail/AguardandoConfirmacao"));
}
var usuario = new ApplicationUser {
Nome = modelo.Nome, UserName = modelo.Email, Email = modelo.Email
};
var resultado = await _userManager.CreateAsync(usuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailDeConfirmacaoAsync(usuario);
return(View("../ConfirmeEmail/AguardandoConfirmacao"));
}
else
{
AdicionarErros(resultado);
}
}
modelo.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
return(View(modelo));
}
public async Task <IActionResult> Registrar(RegistrarViewModel model, string ReturnUrl = null)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.UserName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
ViewData["ReturnUrl"] = ReturnUrl;
var result2 = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.Remenberme, lockoutOnFailure : false);
if (result2.Succeeded)
{
return(ReturnToLocalUrl(ReturnUrl));
}
foreach (var Error in result.Errors)
{
ModelState.AddModelError(string.Empty, "tentativa de login invalida");
}
}
foreach (var Error in result.Errors)
{
ModelState.AddModelError(string.Empty, "tentativa de login invalida");
}
}
Console.WriteLine("fudeu!");
return(View(model));
}
public IActionResult EditarAlumno(int id)
{
AlumnosRepository repos = new AlumnosRepository(context);
RegistrarViewModel vm = new RegistrarViewModel();
vm.Alumno = repos.Get(id);
if (User.IsInRole("Maestro"))
{
vm.IdMaestro = int.Parse(User.Claims.FirstOrDefault(x => x.Type == "IdUsuario").Value);
}
if (vm.Alumno != null)
{
return(View(vm));
}
else
{
if (User.IsInRole("Maestro"))
{
return(RedirectToAction("ListaAlumnos", new { id = vm.IdMaestro }));
}
else
{
return(RedirectToAction("ListaAlumnos"));
}
}
}
public IActionResult AltaMaestro(RegistrarViewModel vm)
{
MaestrosRepository reposMaestro = new MaestrosRepository(context);
try
{
if (vm.Maestro.Contrasena.ToString() == vm.ConfirmarContraseña.ToString())
{
var contraHash = HashingHelper.GetHash(vm.Maestro.Contrasena);
vm.Maestro.Contrasena = contraHash;
reposMaestro.Insert(vm.Maestro);
return(RedirectToAction("ListaMaestros"));
}
else
{
ModelState.AddModelError("", "Las contraseñas no coinciden");
return(View(vm));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(vm));
}
}
public async Task <ActionResult> Registrar(RegistrarViewModel registrar)
{
if (!ModelState.IsValid)
{
return(Result(ModelState));
}
var user = new IdentityUser
{
UserName = registrar.Login
};
var result = await _userManager.CreateAsync(user, registrar.Senha);
if (result.Succeeded)
{
return(Result("Usuário criado com sucesso!"));
}
foreach (var erro in result.Errors)
{
NotificarErro(erro.Description);
}
return(Result());
}
public async Task <IActionResult> Registrar(RegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var usuario = new UsuarioAplicacao()
{
UserName = modelo.Email,
Nome = modelo.Nome,
Email = modelo.Email,
DataCadastro = DateTime.Now,
DataUltimoAcesso = DateTime.Now
};
var resultadoCadastro = await _userManager.CreateAsync(usuario, modelo.Senha).ConfigureAwait(false);
if (resultadoCadastro.Succeeded)
{
await _userManager.AddToRoleAsync(usuario, PerfisPadroes.USUARIO).ConfigureAwait(false);
var login = await _signInManager.PasswordSignInAsync(usuario, modelo.Senha, false, lockoutOnFailure : false).ConfigureAwait(false);
if (login.Succeeded)
{
return(RedirectToAction("Index", "Painel"));
}
}
}
ViewData["erroLoginOuCadastro"] = 1;
ViewData["ApresentarRegrasSenha"] = 1;
ModelState.AddModelError("", _localizador["Não foi possivel completar o cadastro"]);
ModelState.AddModelError("", _localizador["Informe todos os campos obrigatórios"]);
return(View(modelo));
}
public async Task <IActionResult> Create([FromBody] RegistrarViewModel model)
{
if (model == null)
{
return(NotFound());
}
var validation = new RegistrarValidation(_usuario, _pessoa).Validate(model);
if (!validation.IsValid)
{
var returnValidate = new
{
erros = validation.Errors.Select(x => new
{
field = x.PropertyName,
error = x.ErrorMessage
})
};
return(BadRequest(returnValidate));
}
var retorno = await _registrarServices.Create(model);
if (retorno == null)
{
return(BadRequest(new { data = "Ocorreu um erro ao cadastrar." }));
}
else
{
return(Ok(retorno));
}
}
public async Task <ActionResult> Register(RegistrarViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Conta", 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", "Inicial"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> RegistrarAsync()
{
var modelo = new RegistrarViewModel();
modelo.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
return(View(modelo));
}
public IActionResult CambiarContraseña(int id)
{
MaestrosRepository repos = new MaestrosRepository(context);
RegistrarViewModel vm = new RegistrarViewModel();
vm.Maestro = repos.Get(id);
return(View(vm));
}
public async Task <LoginResultDTO> PostCadastrarAsync(RegistrarViewModel model)
{
var resposta = await _httpClient.PostAsJsonAsync("Cadastrar", model);
return(new LoginResultDTO
{
Succeeded = resposta.IsSuccessStatusCode,
Token = await resposta.Content.ReadAsStringAsync()
});
}
public IActionResult AgregarAlumno(int?id)
{
RegistrarViewModel vm = new RegistrarViewModel();
if (User.IsInRole("Maestro"))
{
vm.IdMaestro = (int)id;
return(View(vm));
}
return(View(vm));
}
public ActionResult Eliminar(int id)
{
RegistrarViewModel model = new RegistrarViewModel();
using (EmpleadosBDEntities db = new EmpleadosBDEntities())
{
var oTabla = db.Empleado.Find(id);
db.Empleado.Remove(oTabla);
db.SaveChanges();
}
return(Redirect("~/Empleado/"));
}
public async Task <IActionResult> Registrar(RegistrarViewModel model)
{
if (ModelState.IsValid)
{
var result = await _auth.PostCadastrarAsync(model);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
return(View(model));
}
public ActionResult Registrar(RegistrarViewModel model)
{
List <PaisViewModel> ListaPais;
using (BaseDatos2 db = new BaseDatos2())
{
ListaPais = (from dato in db.Pais
select new PaisViewModel
{
codigo = dato.Id_Pais,
nombre = dato.Nombre,
abrev = dato.Abrev
}).ToList();
}
ViewBag.Paises = ListaPais;
if (ModelState.IsValid)
{
using (BaseDatos2 db = new BaseDatos2())
{
var user = db.Jugador.FirstOrDefault(dato => dato.Nombre_Usuario == model.Usuario);
var correo = db.Jugador.FirstOrDefault(dato => dato.Correo == model.Correo_electronico);
if (user == null)
{
if (model.contaseña == model.recontaseña)
{
if (correo == null)
{
var Usuario = new Jugador();
Usuario.Nombres_Jugador = model.nombre;
Usuario.Apellidos_Jugador = model.Apellido;
Usuario.Nombre_Usuario = model.Usuario;
Usuario.Correo = model.Correo_electronico;
Usuario.Pass = model.contaseña;
Usuario.Confirm_Pass = model.recontaseña;
Usuario.Id_Pais = model.codigo_pais;
db.Jugador.Add(Usuario);
db.SaveChanges();
return(RedirectToAction("Login", "Login"));
}
}
}
}
}
return(View());
}
public ActionResult Registrar(RegistrarViewModel model)
{
using (PrimeraExpoContext db = new PrimeraExpoContext())
{
var persona = new Persona
{
Nombre = model.Nombre,
Apellidos = model.Apellidos,
Edad = model.Edad,
Correo = model.Correo,
Contrasenna = model.Contrasenna
};
db.Personas.Add(persona);
db.SaveChanges();
ViewBag.Confirmacion = "Registro completado!";
}
return(View());
}
public ActionResult Register(RegistrarViewModel registrarObj)
{
Empresa empresa = registrarObj.Empresa;
empresa.UsuarioAdmin = registrarObj.Usuario;
empresa.UsuarioAdmin.CdPassword = registrarObj.Password;
new EmpresaBo().Create(empresa);
if (empresa.Status == 0)
{
ModelState.AddModelError(string.Empty, empresa.Mensagem);
return(View(registrarObj));
}
TempData["message"] = "Parabens, você se cadastrou com sucesso. Utilize o formulário abaixo para entrar e começar.";
return(RedirectToAction("Login", "Account"));
}
public async Task <IActionResult> RegisterAsync([FromBody] RegistrarViewModel registerUser)
{
var user = new Usuario
{
UserName = registerUser.UserName,
Email = registerUser.Email,
QualquerCoisa = registerUser.QualquerCoisa
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (!result.Succeeded)
{
return(BadRequest());
}
await _signInManager.SignInAsync(user, false);
return(new OkObjectResult(await GerarJwt(user.UserName)));
}
public async Task <RegistrarViewModel> Create(RegistrarViewModel model)
{
var pessoa = new Pessoa();
pessoa.Nome = model.Nome;
pessoa.Email = model.Email;
pessoa.IdCidade = model.IdCidade;
await _pessoa.Add(pessoa);
var usuario = new Usuario();
usuario.Login = model.Email;
usuario.Senha = HashMD5.getMD5(model.Senha);
usuario.DataAtivacao = DateTime.Now;
usuario.Pessoa = pessoa;
await _usuario.Add(usuario);
return(model);
}
public IActionResult CambiarContraseña(RegistrarViewModel vm)
{
MaestrosRepository repos = new MaestrosRepository(context);
var original = repos.Get(vm.Maestro.Id);
if (original != null)
{
if (vm.Maestro.Contrasena == vm.ConfirmarContraseña)
{
var nuevaContraHash = HashingHelper.GetHash(vm.Maestro.Contrasena);
original.Contrasena = nuevaContraHash;
repos.Update(original);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Las contraseñas no coiniciden.");
return(View(vm));
}
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Registrar(RegistrarViewModel model)
{
// Valida los datos ingresados
if (ModelState.IsValid)
{
// Crea una nueva instancia de usuario y le asigna los valores pasados en el modelo
var usuario = new Usuario()
{
UserName = model.Usuario,
Nombre = model.Nombre,
Apellido = model.Apellido,
Email = model.Email,
PhoneNumber = model.Telefono
};
// Usa userManager para crear un nuevo usuario y guardarlo en la BBDD
var resultado = await userManager.CreateAsync(usuario, model.Pwd);
// Evalua el resultado del registro del nuevo usuario
if (resultado.Succeeded)
{
// Si es valido lo loguea (isPersistent es para las cookies)
await signInManager.SignInAsync(usuario, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
else
{
// En caso de haber error, los agrega al ModelState antes de volver a la vista
foreach (var error in resultado.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public ActionResult Editar(RegistrarViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (EmpleadosBDEntities db = new EmpleadosBDEntities())
{
var oTabla = db.Empleado.Find(model.EmpleadoID);
oTabla.EmpleadoID = model.EmpleadoID;
oTabla.rut = model.rut;
oTabla.pnombre = model.pnombre;
oTabla.apaterno = model.apaterno;
oTabla.amaterno = model.amaterno;
oTabla.direccion = model.direccion;
oTabla.email = model.email;
oTabla.genero = model.genero;
oTabla.fec_nac = model.fec_nac;
oTabla.annos_xp = model.annos_xp;
oTabla.telefono = model.telefono;
oTabla.n_profesion = model.n_profesion;
oTabla.foto = model.foto;
db.Entry(oTabla).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(Redirect("~/Empleado/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IActionResult EditarAlumno(RegistrarViewModel vm)
{
AlumnosRepository repos = new AlumnosRepository(context);
try
{
var m = context.Maestro.FirstOrDefault(x => x.Grupo == vm.Alumno.Grupo);
var original = repos.Get(vm.Alumno.Id);
if (original != null)
{
original.Nombre = vm.Alumno.Nombre;
original.Grupo = vm.Alumno.Grupo;
if (m == null)
{
ModelState.AddModelError("", "Aún no hay ningun maestro asignado a ese grupo.");
return(View(vm));
}
else
{
original.IdMaestro = m.Id;
}
repos.Update(original);
}
if (User.IsInRole("Maestro"))
{
return(RedirectToAction("ListaAlumnos", new { id = vm.IdMaestro }));
}
else
{
return(RedirectToAction("ListaAlumnos"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(vm));
}
}
public ActionResult Editar(int id)
{
RegistrarViewModel model = new RegistrarViewModel();
using (EmpleadosBDEntities db = new EmpleadosBDEntities())
{
var oTabla = db.Empleado.Find(id);
model.EmpleadoID = oTabla.EmpleadoID;
model.rut = oTabla.rut;
model.pnombre = oTabla.pnombre;
model.apaterno = oTabla.apaterno;
model.amaterno = oTabla.amaterno;
model.direccion = oTabla.direccion;
model.email = oTabla.email;
model.genero = oTabla.genero;
model.fec_nac = oTabla.fec_nac;
model.annos_xp = oTabla.annos_xp;
model.telefono = oTabla.telefono;
model.n_profesion = oTabla.n_profesion;
model.foto = oTabla.foto;
}
return(View(model));
}
public async Task <IActionResult> Registrar(RegistrarViewModel registrarViewModel)
{
if (ModelState.IsValid)
{
var user = new Usuario()
{
UserName = registrarViewModel.Nombre
};
var result = await _userManager.CreateAsync(user, registrarViewModel.Clave);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(registrarViewModel.TipoUsuario))
{
await _roleManager.CreateAsync(new IdentityRole(registrarViewModel.TipoUsuario));
}
await _userManager.AddToRoleAsync(user, registrarViewModel.TipoUsuario);
return(RedirectToAction("Index", "Home"));
}
}
return(View(registrarViewModel));
}
public IActionResult AgregarAlumno(RegistrarViewModel vm)
{
AlumnosRepository repos = new AlumnosRepository(context);
try
{
MaestrosRepository maestroRepos = new MaestrosRepository(context);
var maestro = maestroRepos.Get(vm.IdMaestro);
if (maestro == null)
{
if (User.IsInRole("Director"))
{
var GrupoMaestro = context.Maestro.FirstOrDefault(x => x.Grupo == vm.Alumno.Grupo);
if (GrupoMaestro == null)
{
ModelState.AddModelError("", "Aún no hay ningun maestro asignado a ese grupo.");
return(View(vm));
}
else
{
vm.Alumno.IdMaestro = GrupoMaestro.Id;
repos.Insert(vm.Alumno);
}
}
else
{
ModelState.AddModelError("", "Aún no hay ningun maestro asignado a ese grupo.");
return(View(vm));
}
}
else
{
if (context.Maestro.Any(x => x.Grupo == vm.Alumno.Grupo))
{
if (maestro.Grupo != vm.Alumno.Grupo)
{
ModelState.AddModelError("", "Usted no tiene permitido agregar alumnos a dicho grupo");
return(View(vm));
}
vm.Alumno.IdMaestro = vm.IdMaestro;
repos.Insert(vm.Alumno);
}
}
if (User.IsInRole("Maestro"))
{
return(RedirectToAction("ListaAlumnos", new { id = vm.IdMaestro }));
}
else
{
return(RedirectToAction("ListaAlumnos"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(vm));
}
}
public ActionResult Registrar(RegistrarViewModel registrarViewModel)
{
return(View());
}
public Registrarse()
{
InitializeComponent();
BindingContext = _vm = new RegistrarViewModel();
}
public async Task <IActionResult> RegistroExternoCallbackAsync(string remoteError = null)
{
try
{
if (remoteError != null)
{
throw new ArgumentException($"Erro de provedor externo: {remoteError}");
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ArgumentException("Erro ao carregar informações de login externo");
}
var email = info.Principal.FindFirstValue(ClaimTypes.Email);
if (await _userManager.FindByEmailAsync(email) != null)
{
throw new ArgumentException("Este email já possui uma conta");
}
var usuario = new ApplicationUser {
Nome = info.Principal.FindFirstValue(ClaimTypes.Name), UserName = email, Email = email, EmailConfirmed = true
};
var resultado = await _userManager.CreateAsync(usuario);
if (resultado.Succeeded)
{
resultado = await _userManager.AddLoginAsync(usuario, info);
if (resultado.Succeeded)
{
await _signInManager.SignInAsync(usuario, isPersistent : false, info.LoginProvider);
return(LocalRedirect(Url.Action("Index", "Lista", new { area = "Painel" })));
}
else
{
throw new ArgumentException($"Não foi possível criar uma conta usando {info.ProviderDisplayName}");
}
}
else
{
foreach (var error in resultado.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
var modelo = new RegistrarViewModel();
modelo.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
return(View("../Registro/Registrar", modelo));
}
public async Task <IActionResult> Registrar(RegistrarViewModel model)
{
return(View());
}
