public void ShouldReturnValidCpf(string value)
{
ValidateCpf validateCpf = new ValidateCpf();
var result = validateCpf.IsValidCpf(_generateCpf.GenerateNewCpf(value));
Assert.True(result);
}
public void Deve_VerificarSeCpfEhValido_Quando_Criado()
{
var employee = CriaEmployee();
employee.Cpf = "275.925.310-46";
var valid = new ValidateCpf().IsValid(employee.Cpf);
Assert.IsTrue(valid);
}
public ValidateCpfTest()
{
_validateCpf = new ValidateCpf();
}
public static bool IsValidCNPJ(string cpf) => ValidateCpf.IsCpf(cpf);
public async Task <IActionResult> AddOrEdit([Bind("Id,Nome,Sobrenome,Matricula,Cpf,PhoneNumber,Email,TipoUsuarioId,IdCurso")] Usuario usuario)
{
if (usuario.Email == null || usuario.Email.Length == 0 ||
!(new System.ComponentModel.DataAnnotations.EmailAddressAttribute())
.IsValid(usuario.Email))
{
ModelState.AddModelError("usuario.Email", "Informe um e-mail válido");
}
usuario.Cpf = ValidateCpf.RemoveNaoNumericos(usuario.Cpf);
if (ModelState.IsValid)
{
if (usuario.Id != null)
{
//Administrador
var admId = _context.TipoUsuario.FirstOrDefault(t => t.DescTipo == "Administrador").TipoUsuarioId;
// _context.Update(usuario);
// await _context.SaveChangesAsync();
var userTemp = _userManager.FindByIdAsync(usuario.Id).Result;
if (userTemp.TipoUsuarioId == admId &&
!User.IsInRole("Administrador"))
{
ModelState.AddModelError(String.Empty,
"O usuário que você está tentando alterar é um usuário administrador e apenas outro administrador pode realizar esta modificação");
return(AddOrEdit(userTemp.Id));
}
if (userTemp.TipoUsuarioId == admId &&
usuario.TipoUsuarioId != admId)
{
ModelState.AddModelError(String.Empty,
"Não é possível modificar o tipo de usuários que são administradores");
return(AddOrEdit(userTemp.Id));
}
var typeUser = userTemp.TipoUsuarioId;
userTemp.Nome = usuario.Nome;
userTemp.Sobrenome = usuario.Sobrenome;
userTemp.Matricula = usuario.Matricula;
userTemp.Cpf = usuario.Cpf;
userTemp.PhoneNumber = usuario.PhoneNumber;
userTemp.Email = usuario.Email;
userTemp.TipoUsuarioId = usuario.TipoUsuarioId;
userTemp.IdCurso = usuario.IdCurso;
// Atualiza o usuário
_context.LogAuditoria.Add(
new LogAuditoria
{
EmailUsuario = User.Identity.Name,
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Date = DateTime.Now.ToLongDateString(),
DetalhesAuditoria = string.Concat("Atualizou o usuário de ID:",
usuario.Id),
});
await _userManager.UpdateAsync(userTemp);
await _context.SaveChangesAsync();
if (typeUser != usuario.TipoUsuarioId)
{
var nameTipoUsuarioOld = _context.TipoUsuario.Find(typeUser).DescTipo;
// Obtem as Role nova e antiga do usuário
var nameTipoUsuarioNew = _context.TipoUsuario.Find(usuario.TipoUsuarioId).DescTipo;
var roleOld = _roleManager.FindByNameAsync(nameTipoUsuarioOld).Result;
var roleNew = _roleManager.FindByNameAsync(nameTipoUsuarioNew).Result;
// Remove a Role Antiga
await _userManager.RemoveFromRoleAsync(userTemp, roleOld.Name);
// Adiciona a Role Nova
await _userManager.AddToRoleAsync(userTemp, roleNew.Name);
}
}
else
{
_context.Add(usuario);
var senha = KeyGenerator.GetUniqueKey(8);
_context.LogAuditoria.Add(
new LogAuditoria
{
EmailUsuario = User.Identity.Name,
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Date = DateTime.Now.ToLongDateString(),
DetalhesAuditoria = string.Concat("Cadastrou o usuário de ID:",
usuario.Id),
});
await _context.SaveChangesAsync();
usuario.TipoUsuario = _context.TipoUsuario.Where(x => x.TipoUsuarioId == usuario.TipoUsuarioId).FirstOrDefault();
//_senderEmail.EnviarSenhaParaUsuarioViaEmail(usuario, senha);
}
return(RedirectToAction(nameof(Index)));
}
var errors = ModelState
.Where(x => x.Value.Errors.Count > 0)
.Select(x => new { x.Key, x.Value.Errors })
.ToArray();
return(AddOrEdit(usuario.Id));
//return RedirectToAction(nameof(AddOrEdit), new { id = usuario.Id });
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// search role
var nameTipoUsuario = _context.TipoUsuario.Find(Input.TipoUsuarioId).DescTipo;
//var nameTipoUsuario = "Aluno";
var role = _roleManager.FindByNameAsync(nameTipoUsuario).Result;
if (User.IsInRole("Administrador"))
{
ViewData["tiposUsuarios"] = _context.TipoUsuario.OrderBy(x => x.DescTipo).Where(x => x.DescTipo.Contains("Aluno") ||
x.DescTipo.Contains("Professor") ||
x.DescTipo.Contains("Administrador")).ToList();
}
else
{
ViewData["tiposUsuarios"] = _context.TipoUsuario.OrderBy(x => x.DescTipo).Where(x => x.DescTipo.Contains("Aluno") || x.DescTipo.Contains("Professor")).ToList();
}
ViewData["cursos"] = _context.Cursos.OrderBy(x => x.Nome).ToList();
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
var u = await _userManager.FindByNameAsync(Input.Email);
if (u != null)
{
ModelState.AddModelError(string.Empty, "O e-mail já encontra-se cadastrado no sistema");
}
// Existe dois erro no model que é o da senha que não está sendo informada
// Existe um bug em ValidacaoPersonalizadaCPF no campo do cpf, talvez seja js faltando
// o bug consiste que a requisição é enviada mesmo com cpf inválido
// por isso essa condição
if (ModelState.ErrorCount < 3)
{
var user = new Usuario
{
UserName = Input.Email,
Email = Input.Email,
Nome = Input.Nome,
Sobrenome = Input.Sobrenome,
Matricula = Input.Matricula,
Cpf = ValidateCpf.RemoveNaoNumericos(Input.Cpf),
PhoneNumber = Input.PhoneNumber,
TipoUsuarioId = Input.TipoUsuarioId,
IdCurso = Input.IdCurso
};
var senha = KeyGenerator.GetUniqueKey(8);
var result = await _userManager.CreateAsync(user, senha);
if (result.Succeeded)
{
//_logger.LogInformation("User created a new account with password.");
// code for adding user to role
await _userManager.AddToRoleAsync(user, role.Name);
/*
* 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);
* }
*/
_context.LogAuditoria.Add(
new LogAuditoria
{
EmailUsuario = User.Identity.Name,
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Date = DateTime.Now.ToLongDateString(),
DetalhesAuditoria = "Cadastrou o usuário de ID:",
IdItem = user.Id
});
_context.SaveChanges();
StatusMessage = "Conta criada e enviado e-mail com a senha de acesso.";
user.TipoUsuario = _context.TipoUsuario.Where(x => x.TipoUsuarioId == user.TipoUsuarioId).FirstOrDefault();
user.Curso = _context.Cursos.Where(x => x.Id == user.IdCurso).FirstOrDefault();
_senderEmail.EnviarSenhaParaUsuarioViaEmail(user, senha);
//_logger.LogInformation("User created a new account with password ("+ senha +").");
return(RedirectToPage());
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
