public ActionResult Login(UsuarioViewModel usuarioViewModel)
{
UsuarioRepository usuarioRepository = new UsuarioRepository();
Usuario usuario = usuarioRepository.Obter(usuarioViewModel.Email);
HttpCookie cookie = new HttpCookie("GuiaDaPescaUsuario");
if (usuario == null)
{
ViewBag.Mensagem = "Usuario não localizado.";
}
else
{
if (usuario.Senha == usuarioViewModel.Senha)
{
usuarioViewModel = Mapper.Map<Usuario, UsuarioViewModel>(usuario);
cookie.Value = JsonConvert.SerializeObject(usuarioViewModel);
cookie.Expires = new DateTime(DateTime.Now.Year + 10, 1, 1);
Response.Cookies.Add(cookie);
}
else
{
ViewBag.Mensagem = "A senha não pertence a esse usuario";
}
}
return RedirectToAction("Index", "GuiaDaPesca");
}
public void SalvarUsuarioSemSenha()
{
var unit = new MainUnitOfWork();
var usuarioRepository = new UsuarioRepository(unit);
string erroSenha = "erro";
Usuario usuario = new Usuario();
usuario.Login = "******";
//usuario.Senha = "123";
usuario.Status = "A";
usuario.Email = "*****@*****.**";
var erros = usuario.FazerSeForValido<Usuario>(() =>
{
usuarioRepository.Add(usuario);
usuarioRepository.UnitOfWork.Commit();
//unit.Commit();
});
if (erros.ExistemErros())
erroSenha = erros.FirstOrDefault();
Assert.IsTrue(erros.ExistemErros(), "Erros encontrados na validação da entidade!");
Assert.AreEqual(erroSenha, "O campo Senha da entidade não pode ser nulo...", "Validação do campo senha!");
//var usuarioCadastrado = usuarioRepository.ObterPeloLogin(usuario.Login).FirstOrDefault();
//Assert.IsNotNull(usuarioCadastrado);
//Assert.AreEqual(usuarioCadastrado.Login, usuario.Login, "Usuário cadastrado com sucesso!");
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (model.RecreateDB)
DBHelper.Generate();
var usuarioRepository = new UsuarioRepository();
if (usuarioRepository.ValidarUsuario(model.UserName, model.Password))
{
FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
&& !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult Novo(UsuarioViewModel usuarioViewModel)
{
Usuario usuario;
UsuarioRepository usuarioRepository = new UsuarioRepository();
HttpCookie cookie = new HttpCookie("GuiaDaPescaUsuario");
if (ModelState.IsValid)
{
try
{
usuario = new Usuario(usuarioViewModel.Email,
usuarioViewModel.Senha,
usuarioViewModel.SenhaConfirmacao);
usuarioRepository.Adicionar(usuario);
usuarioViewModel = Mapper.Map<Usuario, UsuarioViewModel>(usuario);
cookie.Value = JsonConvert.SerializeObject(usuarioViewModel);
cookie.Expires = new DateTime(DateTime.Now.Year + 10, 1, 1);
Response.Cookies.Add(cookie);
return RedirectToAction("Index", "GuiaDaPesca");
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex);
}
}
return View(usuarioViewModel);
}
public UsuarioService()
{
dbFactory = new DatabaseFactory();
uow = new UnitOfWork(dbFactory);
repository = new UsuarioRepository(dbFactory);
}
public void Initializer()
{
_unit = new MainUnitOfWork();
_usuarioRepository = new UsuarioRepository(_unit);
_usuarioService = new UsuarioService(_usuarioRepository);
_tarefaRepository = new TarefaRepository(_unit);
_tarefaService = new TarefaService(_tarefaRepository);
}
public ActionResult Index()
{
if (!Request.IsAuthenticated)
{
return Redirect("/Account/Logon");
}
else
{
var usuarioRepository = new UsuarioRepository();
var usuario = usuarioRepository.GetAllFilteredBy(x => x.Login.Equals(User.Identity.Name, StringComparison.InvariantCultureIgnoreCase)).Single();
return View(usuario);
}
}
public ActionResult Logar(string username, string password, string msg)
{
UsuarioRepository iUsuario = new UsuarioRepository(bd);
var usuario = iUsuario.ObterConta(username, password);
var session = new UserSession();
if (usuario.Item2)
{
if(usuario.Item3)
{
clienteBusinessModels iCliente = new clienteBusinessModels(bd);
session.idConta = usuario.Item1.id;
var cliente = iCliente.ObterPerfilPorConta(session.idConta);
session.isCliente = true;
session.idCliente = cliente.id;
session.idConta = cliente.idUsername;
session.meuPerfil = "Cliente/Perfil/" + cliente.idUsername;
session.idBairro = cliente.idBairro;
session.nome = cliente.nome;
session.email = cliente.usuario.email;
Session["UserSession"] = session;
return RedirectToAction("Perfil", "Cliente", new { idConta = usuario.Item1.id });
}
else
{
var iLoja = new lojaBusinessModels(bd);
session.idConta = usuario.Item1.id;
session.isCliente = false;
var loja = iLoja.ObterPerfilPorConta(session.idConta);
session.idConta = loja.idUsername;
session.idCliente = 0;
session.meuPerfil = "Loja/Perfil/" + loja.idUsername;
session.idBairro = loja.idBairro;
session.nome = loja.nome;
session.email = loja.usuario.email;
Session["UserSession"] = session;
return RedirectToAction("Perfil", "Loja", new { idConta = usuario.Item1.id });
}
}
else
{
ViewBag.Login = usuario.Item4;
return View("Entrar");
}
}
public static bool ResetPassword(int usuarioId, string password)
{
try
{
var usuarioRepository = new UsuarioRepository();
var encondedPassword = EncodePassword(password);
usuarioRepository.CambiarPassword(usuarioId, encondedPassword, DateTime.Now);
return true;
}
catch (Exception)
{
return false;
}
}
public void InserirItemNaColecaoDoUsuario(String titulo, String descricao,
Int32 ano, String nomeAutor, Int32 tpItem, Int32 idUser)
{
String[] _nomeAutor = nomeAutor.Split(new char[] { ' ' });
Item item = new ItemFactory().createItem(null, titulo, descricao, ano, _nomeAutor, tpItem);
IItemRepository repository = new ItemRepository();
IUsuarioRepository usrRepository = new UsuarioRepository();
//buscar o usuário para setar no item
Usuario usr = usrRepository.FindById(idUser);
//setando o usuário no item para a referencia da fk.
item._Usuario = usr;
repository.Create(item);
repository.Save();
}
public static bool Login(string username, string password, bool loginTemporal, out string error)
{
error = string.Empty;
var repo = new UsuarioRepository();
var usuario = repo.Obtener(u => u.NombreUsuario == username,
u => u.Roles);
//Verifico que el usuario existe
if (usuario == null)
{
error = "El nombre de usuario es inválido";
return false;
}
//Verifico que la contraseña sea correcta
var membresia = repo.ObtenerMembresia(usuario.UsuarioId);
var valido = Crypto.VerifyHashedPassword(membresia.Password, password);
if (!valido)
{
error = "La contraseña ingresada es inválida";
return false;
}
//var rolesAceptados = new []{ "Administrador","Encargado","SuperAdministrador"};
//var esAdminOEncargado = usuario.Roles.Any(r => rolesAceptados.Contains(r.RoleName));
//if (esAdminOEncargado || usuario.UsuarioMaxiKioscos.Any(m => m.MaxiKiosco.Identifier == AppSettings.MaxiKioscoIdentifier))
//{
// if (loginTemporal)
// UsuarioActual.UsuarioTemporal = usuario;
// else
// UsuarioActual.Usuario = usuario;
// return true;
//}
//error = "El usuario ingresado no puede loguearse en este maxikiosco";
//return false;
if (loginTemporal)
UsuarioActual.UsuarioTemporal = usuario;
else
UsuarioActual.Usuario = usuario;
return true;
}
public void Setup()
{
//Arrange
var optionsSqlite = new DbContextOptionsBuilder <AppACContext>()
.UseSqlite(@"Data Source=C:\sqlite\AppACDataBaseTest.db")
.Options;
_dbContext = new AppACContext(optionsSqlite);
_dbContext.Database.EnsureDeleted();
_dbContext.Database.EnsureCreated();
_usuarioRepository = new UsuarioRepository(_dbContext);
_tipoActividadRepository = new TipoActividadRepository(_dbContext);
_asignarActividadService = new AsignarActividadService(
new UnitOfWork(_dbContext),
new ActividadRepository(_dbContext),
_usuarioRepository,
_tipoActividadRepository,
new MailServerFake()
);
}
public ActionResult Create([Bind(Include = "DetalheId,Usuarioid,Telefone,Endereco")] DetalheUsuario detalheUsuario)
{
if (ModelState.IsValid)
{
_repDet.Add(detalheUsuario);
_repDet.Commit();
return(RedirectToAction("Index"));
}
List <Usuario> lst = new List <Usuario>();
using (var rep = new UsuarioRepository())
{
lst = rep.GetAll().ToList();
}
ViewBag.Usuarioid = new SelectList(lst, "UsuarioId", "Nome", detalheUsuario.Usuarioid);
return(View(detalheUsuario));
}
public LoginResult FazerLogin([FromBody] LoginModel loginModel)
{
var result = new LoginResult();
if (!result.ValidarModel(loginModel))
{
return(result);
}
var repository = new UsuarioRepository();
result.IdUsuario = repository.ValidarLogin(loginModel);
if (result.IdUsuario == 0)
{
result.Mensagem.Add("Não foi possível localizar o usuário informado. Verifique as credenciais de acesso");
}
return(result);
}
public AlterarDadosUsuarioResult AlterarUsuario([FromBody] UsuarioModel usuario)
{
var result = new AlterarDadosUsuarioResult();
if (!result.ValidarModel(usuario))
{
return(result);
}
var repository = new UsuarioRepository();
var sucesso = repository.AtualizarDadosUsuario(usuario);
if (!sucesso)
{
result.Mensagem.Add("Não foi possível atualizar os dados do usuário. Houve um ou mais erros ao realizar a operação.");
}
return(result);
}
public static bool ValidarLogado(string cookie, out int codigo, out string nome, out string login)
{
codigo = 0;
nome = null;
login = null;
if (cookie == null || cookie.Length != 72)
{
return(false);
}
if (int.TryParse(cookie.Substring(0, 8), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out codigo) == false)
{
return(false);
}
codigo ^= CodigoHash;
return(UsuarioRepository.ValidarToken(codigo, cookie.Substring(8), out nome, out login));
}
public void BuscarClientePorId()
{
//Arrange
_mock = new Mock <IDbConnection>();
_transaction = new Mock <IDbTransaction>();
_target = new UsuarioRepository(_mock.Object);
//Act
var cliente = new Usuario("General Motors", "general_motors");
_mock.Setup(x => x.BeginTransaction());
_mock.Setup()
.Returns(cliente);
//Assert
var esperado = _target.IncluirUsuario(cliente);
var atual = new Usuario(1, "General Motors", "general_motors", new List <Perfil>());
Assert.AreEqual(esperado.Login, atual.Login);
}
// DELETE: api/Usuarios/5
//[BasicAuhtentication]
public IHttpActionResult DeleteUsuarios(long id)
{
if (id <= 0)
{
return(BadRequest("O id informado na URL deve ser maior que zero."));
}
UsuarioRepository userRepository = new UsuarioRepository();
Usuario usuario = userRepository.RetornarPorId(id);
if (usuario == null)
{
return(NotFound());
}
// if (/*empRepository.vagaCount(id) > 0*/ empresa.Vagas.Count > 0)
//return Content(HttpStatusCode.Forbidden, "Essa empresa não pode ser excluída, pois há vagas ativas relacionadas a ela.");
userRepository.Excluir(usuario);
return(StatusCode(HttpStatusCode.NoContent));
}
public IActionResult Login(Usuario u)
{
UsuarioRepository ur = new UsuarioRepository();
Usuario usuario = ur.Login(u);
//Session - Variaveis
if (usuario != null)
{
HttpContext.Session.SetInt32("id", usuario.Id);
HttpContext.Session.SetString("nome", usuario.Nome);
HttpContext.Session.SetInt32("tipo", usuario.Tipo);
ViewBag.Mensagem = "Usuário logado com sucesso!";
return(Redirect("Conectado"));
}
else
{
ViewBag.Mensagem = "Erro, usuário ou senha invalidos!";
return(View());
}
}
public ClientController(UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager,
ItlaBankingContext context, IMapper mapper, UsuarioRepository usuarioRepository, CuentaRepository cuentaRepository,
TarjetaCreditoRepository tarjetasRepository, PrestamosRepository prestamosRepository, BeneficiarioRepository beneficiarioRepository,
TransaccionesRepository transaccionesRepository
)
{
_userManager = userManager;
_signinManager = signInManager;
_context = context;
_mapper = mapper;
///repositorios
_usuarioRepository = usuarioRepository;
_cuentaRepository = cuentaRepository;
_prestamosRepository = prestamosRepository;
_tarjetasRepository = tarjetasRepository;
_beneficiarioRepository = beneficiarioRepository;
_transaccionesRepository = transaccionesRepository;
}
public string ObterNomeResponsavelTarefa()
{
// Resumo: Retorna o nome do criador da tarefa selecionada.
if (dadosTarefa == null)
{
dadosTarefa = new TarefaRepository();
}
IdResponsavelServ = dadosTarefa.ConsultarTarefa(IdTarefaSelecionada).IdResponsavel;
if (IdResponsavelServ == 0)
{
return("N/A");
}
dadosUsuario = new UsuarioRepository();
return(dadosUsuario.ConsultarUsuarioPorId(IdResponsavelServ).NomeUsuario);
}
public ActionResult Cadastro()
{
if (LoginController.retorno == true)
{
CategoriaRepository categoriaRepository = new CategoriaRepository();
ViewBag.Categorias = categoriaRepository.ObterTodos();
UsuarioRepository usuarioRepository = new UsuarioRepository();
ViewBag.Usuarios = usuarioRepository.ObterTodos();
ProjetoRepository projetoRepository = new ProjetoRepository();
ViewBag.Projetos = projetoRepository.ObterTodos();
return(View());
}
else
{
return(Redirect("/login"));
}
}
static void Main(string[] args)
{
AssociadosAsserti_AssociadosDataContext context = new AssociadosAsserti_AssociadosDataContext();
EmpresaRepository empresaRepository = new EmpresaRepository(context);
GerarEmpresa(empresaRepository);
ProfissionalRepository profissionalRepository = new ProfissionalRepository(context);
GerarProfissional(profissionalRepository);
SocioRepository socioRepository = new SocioRepository(context);
GerarSocio(socioRepository);
UsuarioRepository usuarioRepository = new UsuarioRepository(context);
GerarUsuario(usuarioRepository);
}
public void LoginIncorreto(string nome, string email, string senha)
{
IUsuarioRepository uRepo = new UsuarioRepository(context);
IUsuarioService uService = new UsuarioService(uRepo);
var controller = new AccountController(uService);
//Faz o registro do usuário
var user = new Usuario {
nome = nome, email = email, senha = senha
};
var usuario = controller.SignUp(user) as OkNegotiatedContentResult <Usuario>;
//verifica o login
var login = new Login {
email = email, senha = "1234"
};
var usuarioLogin = controller.Login(login) as OkNegotiatedContentResult <ResultError>;
Assert.AreEqual(usuarioLogin.Content.statusCode, 401);
}
public IHttpActionResult UltimasAlertasUsuario()
{
var alertasUsuario = AlertaRepository.ObtenerAlertasDeUsuario(IdUsuarioExec, 5);
var alertas = CopiadoUtil.Copia(alertasUsuario);
foreach (var alerta in alertas)
{
alerta.NombreUsuario = UsuarioRepository.ObtenerUsuarioPorId(alerta.IdUsuario).NombreCompleto();
}
var resultado = new ResultadoOperacionDto()
{
Mensaje = "OK",
Resultado = true,
InformacionExtra = alertas
};
Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
return(Ok(resultado));;
}
protected void registrarse_Click(object sender, EventArgs e)
{
try
{
if (ValidaForm())
{
DataBase.usuario u = MapeaFormUsuario();
UsuarioRepository ur = new UsuarioRepository();
ur.Insertar(u);
Sesion(u);
Response.Redirect("~/Pages/Perfil.aspx", false);
}
}
catch (Exception)
{
Response.Redirect("~/Error.aspx");
}
}
public async Task TestLogin()
{
ConnectionStrings.BancoDadosConnection = bancoDadosConnection;
_repository = new UsuarioRepository();
_service = new UsuarioService(_repository);
_appService = new UsuarioAppService(AutoMapperConfiguration.RegisterMappings().CreateMapper(), _service, _jswtService);
_controller = new UsuarioController(_appService);
var credencial = new CredencialCommand()
{
Email = "*****@*****.**",
Senha = "bwdesouza"
};
var result = await _controller.Login(credencial);
Assert.IsNotNull(result);
Assert.IsTrue(true);
}
public bool AutenticarUsuario()
{
#region Resumo
// Consulta no banco de dados se os dados informados correspondem aos de alguma conta do usuário.
// Retorna Verdadeiro se os dados equivalem aos dados de alguma conta. Caso contrário retorna Falso.
#endregion Resumo
UsuarioRepository dados = new UsuarioRepository();
Usuario usuario = dados.AutenticarContaDeUsuario(EmailBus, SenhaBus);
if (usuario == null)
{
// Mensagem: Usuário e/ou senha inválidos.
AlertaForm = Mensagem.MENS_FORM_07;
return(false);
}
Application.Current.Properties["id"] = usuario.Id;
return(true);
}
public KadastroServiceHost()
{
//context
var unit = new MainUnitOfWork();
//repositories
var usuarioRepository = new UsuarioRepository(unit);
var pontoRepository = new PontoRepository(unit);
var intervaloRepository = new IntervaloRepository(unit);
var tarefaRepository = new TarefaRepository(unit);
//services
var usuarioService = new UsuarioService(usuarioRepository);
var tarefaService = new TarefaService(tarefaRepository);
//var pontoRepository = new PontoService(pontoRepository, intervaloRepository);
//applications
_usuarioAppService = new UsuarioAppService(usuarioRepository, usuarioService);
_tarefaAppService = new TarefaAppService(tarefaRepository, tarefaService);
}
public IActionResult CadastrarUsuario(IFormCollection form)
{
Usuario usuario = new Usuario();
usuario.Nome = form["nome"];
usuario.Email = form["email"];
usuario.Senha = form["senha"];
UsuarioRepository repository = new UsuarioRepository();
if (usuario.Email != "" && usuario.Nome != "" && usuario.Senha != "")
{
repository.Cadastro(usuario);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Cadastro", "Usuario"));
}
}
public void Create(UsuarioDTO usuario)
{
try
{
using (ModelosDBContainer context = new ModelosDBContainer())
{
UsuarioRepository repositorio = new UsuarioRepository(context);
if (repositorio.Any(usuario.Username))
{
throw new Exception("El usuario ya existe.");
}
repositorio.Create(this._mapper.Map <Usuario>(usuario));
context.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void ShouldCallCreateUsuarioFromPrestaSysDbContext()
{
// Arrange
const int expectedResult = 1;
var usuarioEntity = new Usuario();
var dbContextMock = new DbContextMock <PrestaSysDbContext>(DummyOptions);
dbContextMock.Setup(s => s.Add(usuarioEntity)).Returns(It.IsAny <EntityEntry <Usuario> >());
dbContextMock.Setup(s => s.SaveChanges()).Returns(expectedResult);
var usuarioRepository = new UsuarioRepository(dbContextMock.Object);
// Act
var result = usuarioRepository.Create(usuarioEntity);
// Assert
dbContextMock.Verify(m => m.Add(usuarioEntity), Times.Once());
dbContextMock.Verify(m => m.SaveChanges(), Times.Once());
result.Should().Be(expectedResult);
}
public IActionResult Listar()
{
if (HttpContext.Session.GetInt32("idUsuario") == null)
{
return(RedirectToAction("Login"));
}
else
{
if (HttpContext.Session.GetInt32("tipoUsuario") == 1)
{
UsuarioRepository user = new UsuarioRepository();
List <Usuario> usuario = user.Lista();
return(View(usuario));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
}
public static Usuario GetUsuarioByName(string nome)
{
try
{
UsuarioRepository usuarioRepository = new UsuarioRepository();
Usuario usuario = usuarioRepository.getUsuarioByName(nome);
if (usuario != null)
{
return(usuario);
}
else
{
throw new Exception("Usuario não localizado - Nome: " + nome);
}
}
catch (Exception e)
{
throw e;
}
}
public IActionResult Conta(Usuario u)
{
try
{
UsuarioRepository ur = new UsuarioRepository();
u.tipo = 0;
if (u.avatar == null)
{
u.avatar = "/imagens/user1.png";
}
ur.insert(u);
return(RedirectToAction("Login", "Usuario"));
}
catch (Exception e)
{
ViewBag.mensagem = e.Message;
ViewBag.processo = "processo de criação de usuário";
return(View("../Home/Erro"));
}
}
public void ObterUsuarioPeloLogin()
{
var unit = new MainUnitOfWork();
var usuarioRepository = new UsuarioRepository(unit);
var usuario = new Usuario();
usuario.Login = "******";
usuario.Nome = "teste";
usuario.PerfilAcesso = PerfilAcesso.Desenvolvedor;
usuario.GenerateNewIdentity();
usuarioRepository.Add(usuario);
unit.CommitAndRefreshChanges();
var usuarioCadastrado = usuarioRepository.GetByLogin(usuario.Login).FirstOrDefault();
Assert.IsNotNull(usuarioCadastrado);
Assert.IsTrue(usuarioCadastrado.Login == usuario.Login, "Não foi encontrado dados na tabela projeto do zimmer, talvez o método Seed não esteja funcional");
}
/// <summary>
/// Salva ou atualiza um usuario
/// </summary>
/// <param name="usuarioNovo">dados do usuario</param>
/// <param name="usuarioId">codigo do usuario autenticado</param>
/// <returns></returns>
public Usuario Save(Usuario usuarioNovo, int usuarioId = 0)
{
try
{
if (usuarioNovo.Id > 0)
{
if (usuarioNovo.Id != usuarioId)
{
throw new Exception("Acesso negado!");
}
var usuario = UsuarioRepository.GetById(usuarioNovo.Id);
usuario.Nome = usuarioNovo.Nome;
usuario.Email = usuarioNovo.Email;
usuario.Telefone = usuarioNovo.Telefone;
UsuarioRepository.Update(usuario);
}
else
{
if (UsuarioRepository.FindFirstBy(x => x.Email == usuarioNovo.Email) != null)
{
throw new ValidationException("E-mail já cadastrado!");
}
usuarioNovo.DataCadastro = DateTime.Now;
usuarioNovo.Senha = usuarioNovo.Senha.Md5Hash();
UsuarioRepository.Add(usuarioNovo);
}
UsuarioRepository.SaveChanges();
return(UsuarioRepository.GetFullByEmail(usuarioNovo.Email));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw;
}
}
public IActionResult EditarRifa()
{
RifaRepository rifas = new RifaRepository();
UsuarioRepository usuarios = new UsuarioRepository();
var listarRifas = rifas.GetAll();
var listarUsuarios = usuarios.GetAll();
List <Usuarios> listUsers = new List <Usuarios>();
foreach (var usuario in listarUsuarios)
{
List <int> listaPago = new List <int>();
List <int> listaNaoPago = new List <int>();
foreach (var rifa in listarRifas)
{
if (usuario.Id == rifa.NomeId)
{
if (rifa.Pago == true)
{
listaPago.Add(rifa.Numero);
}
else
{
listaNaoPago.Add(rifa.Numero);
}
}
}
usuario.Pagos = String.Join("-", listaPago.ToArray());
usuario.NaoPagos = String.Join("-", listaNaoPago.ToArray());
listUsers.Add(usuario);
}
ViewBag.listaUsuarios = listUsers;
return(View());
}
public Usuario AutenticarUsuario(Usuario usuario)
{
string password = string.Empty;
if (string.IsNullOrEmpty(usuario.Email))
{
throw new Exception("Email não pode ser em branco");
}
if (string.IsNullOrEmpty(usuario.Password))
{
throw new Exception("Senha não pode ser em branco");
}
else
{
password = criptografiaService.RetornarMD5(usuario.Password);
}
UsuarioRepository usuarioRepository = new UsuarioRepository();
try
{
usuario = usuarioRepository.RetornarUsuarioPorEmail(usuario.Email, false);
}
catch (Exception ex)
{
throw ex;
}
if (usuario.Password == password)
{
usuario.Password = null;
return(usuario);
}
else
{
throw new Exception("Senha inválida");
}
}
public void Relatorio()
{
StringBuilder conteudo = new StringBuilder();
conteudo.Append("<h1>Relatório de Recebimentos</h1>");
conteudo.Append($"<p>Relatório gerado em: {DateTime.Now}</p>");
conteudo.Append("<br/>");
conteudo.Append("<table border='1' style='width: 100%'>");
conteudo.Append("<tr>");
conteudo.Append("<td>Origem do Recebimento</td>");
conteudo.Append("<td>Valor</td>");
conteudo.Append("<td>Data de Entrada</td>");
conteudo.Append("</tr>");
UsuarioRepository repUsuario = new UsuarioRepository();
Usuario usuario = repUsuario.Find(User.Identity.Name);
ReceberRepository rep = new ReceberRepository();
foreach (ContasReceber r in rep.FindAll(usuario.IdUsuario))
{
conteudo.Append("<tr>");
conteudo.Append($"<td>{r.Titulo}</td>");
conteudo.Append($"<td>{r.Valor}</td>");
conteudo.Append($"<td>{r.DataCadastro}</td>");
conteudo.Append("</tr>");
}
conteudo.Append("</table>");
ReportsUtil util = new ReportsUtil();
byte[] pdf = util.GetPDF(conteudo.ToString());
//Download..
Response.Clear();
Response.ContentType = "application/pdf";
Response.AddHeader("content-disposition", "attachment; filename=relatorio.pdf");
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.BinaryWrite(pdf);
Response.End();
}
public async Task <IActionResult> IniciarSesion(Usuario usuario, bool recordar)
{
ctrlusersContext context = new ctrlusersContext();
UsuarioRepository <Usuario> repos = new UsuarioRepository <Usuario>(context);
var datos = repos.GetUsuarioCorreo(usuario.Correo);
if (datos != null && HashHelper.GetHash(usuario.Contra) == datos.Contra)
{
if (datos.Activo == 1)
{
List <Claim> info = new List <Claim>();
info.Add(new Claim(ClaimTypes.Name, datos.NomUsuario));
info.Add(new Claim(ClaimTypes.Role, "Seguidor"));
info.Add(new Claim("Correo", datos.Correo));
info.Add(new Claim("Nombre", datos.NomUsuario));
var claimsIdentity = new ClaimsIdentity(info, CookieAuthenticationDefaults.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
if (recordar == true)
{
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, new AuthenticationProperties { IsPersistent = true });
}
else
{
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, new AuthenticationProperties { IsPersistent = false });
}
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Tu cuenta no ha sido activada, dirígete al correo para activarla");
return(View(usuario));
}
}
else
{
ModelState.AddModelError("", "El correo electrónico o la contraseña son incorrectos");
return(View(usuario));
}
}
public ActionResult Favoritar(int idLoja)
{
try
{
var iConta = new UsuarioRepository(bd);
var session = Session["UserSession"] as UserSession;
var conta = iConta.Obter(session.idConta);
var dadosFavoritar = new lojafavorita();
if (conta == null || !conta.IsCliente)
{
return Json("Erro ao favoritar!");
}
else
{
var iLojaFavorita = new lojaFavoritaBusinessModels(bd);
dadosFavoritar.idCliente = session.idCliente;
dadosFavoritar.idLoja = idLoja;
var evento = iLojaFavorita.CriarFavorito(dadosFavoritar);
if (evento.Item2)
{
return Json(evento.Item1);
}
else
{
return Json(evento.Item1);
}
}
}
catch
{
return Json(null, "Erro ao favoritar!");
}
}
private int InserirUsuario()
{
using (UsuarioRepository repo = new UsuarioRepository())
{
var usuario = new Usuario
{
Nome = "Demo teste 1",
Email = "*****@*****.**",
Senha = "123456",
Ativo = true,
Perfil = new Perfil {
Id = 2, Nome = "Usuário"
}
};
int id = repo.Inserir(usuario).Id;
Assert.IsTrue(id > 0);
return(id);
}
}
public void SetUp()
{
_dbContext = new CrudAppContext();
_transaction = _dbContext.Database.BeginTransaction();
var config = new MapperConfiguration(cfg => {
cfg.AddProfile(new DomainToViewModelMappingProfile());
cfg.AddProfile(new ViewModelToDomainMappingProfile());
});
var usuarioRepository = new UsuarioRepository(_dbContext);
var unitOfWork = new UnitOfWork(_dbContext);
var domainNotification = new DomainNotification();
_mapper = config.CreateMapper();
_usuarioService = new UsuarioService(usuarioRepository, unitOfWork, domainNotification);
_usuarioAppService = new UsuarioAppService(_mapper, _usuarioService);
_usuarioViewModel = new UsuarioViewModel {
Nome = "Adler Pagliarini do Nascimento", Email = "*****@*****.**", Telefone = "15981312383"
};
}
public Usuario Login(string username, string password)
{
var usuariosRepository = new UsuarioRepository();
return usuariosRepository.GetByUsernameAndPassword(username, this.HashPassword(password));
}
public ActionResult Register(UsuarioDto usuarioDto)
{
IUsuarioRepository usuarioRepository = new UsuarioRepository();
Usuario usuario = new Usuario();
usuario = usuarioDto.getUsuario();
if (ModelState.IsValid)
{
if (!WebSecurity.UserExists(usuario.Login))
WebSecurity.CreateUserAndAccount(
usuario.Login,
usuario.Password,
new
{
Nombre = usuario.Nombre,
Apellido = usuario.Apellido,
Codigo = usuario.Codigo,
Password = usuario.Password,
});
if (!Roles.GetRolesForUser(usuario.Login).Contains(usuario.RolAcademico))
Roles.AddUsersToRoles(new[] { usuario.Login }, new[] { usuario.RolAcademico });
return this.RedirectToAction("Index", "Home");
}
return View(usuarioDto);
}
public static bool VerificarPassword(string username, string password)
{
var repo = new UsuarioRepository();
var usuario = repo.Obtener(u => u.NombreUsuario == username,
u => u.Roles);
//Verifico que la contraseña sea correcta
var membresia = repo.ObtenerMembresia(usuario.UsuarioId);
var valido = Crypto.VerifyHashedPassword(membresia.Password, password);
return valido;
}
public bool existeUsername(string username)
{
UsuarioRepository usrRep = new UsuarioRepository();
return usrRep.existeUsername(username);
}
public byte[] getPasswordHashedByUsername(string username)
{
UsuarioRepository usrRep = new UsuarioRepository();
return usrRep.getPasswordHashedByUsername(username);
}
public int insertRolesUsuario(Usuario usuario)
{
UsuarioRepository usrRep = new UsuarioRepository();
return usrRep.InsertRolesUsuario(usuario);
}
public void Initializer()
{
unit = new MainUnitOfWork();
usuarioRepository = new UsuarioRepository(unit);
}
public void updatePassword(String username, byte[] hashedPassword)
{
UsuarioRepository usrRep = new UsuarioRepository();
usrRep.updatePassword(username, hashedPassword);
}
/// <summary>
/// Trae los permisos que tiene un usuario por cada seccion
/// <param name="sectionId">El ID de la Seccion</param>
/// <returns>Una coleccion de Permission</returns>
public IQueryable<Permiso> Permisos(int sectionId)
{
UsuarioRepository _RepUser = new UsuarioRepository();
return _RepUser.GetPermisosBySectionAndUser(this.Id, sectionId);
}
public IQueryable<Permiso> Permisos()
{
UsuarioRepository _RepUser = new UsuarioRepository();
return _RepUser.GetPermisos(this.Id);
}
/// <summary>
/// Trae las secciones a las que tiene permiso el usuario
/// </summary>
/// <returns>Una coleccion de Section</returns>
public IQueryable<Seccion> Secciones()
{
UsuarioRepository _RepUser = new UsuarioRepository();
return _RepUser.GetSeccionesByUserName(this.Id);
}
private void btnIngresar_Click(object sender, EventArgs e)
{
bool result = true;
if (string.IsNullOrEmpty(this.txtUsuario.Text))
{
this.errorValidator.SetError(this.txtUsuario, "Ingresar Nombre Usuario.");
result = false;
}
else
{
this.errorValidator.SetError(this.txtUsuario, string.Empty);
}
if (string.IsNullOrEmpty(this.txtClave.Text))
{
this.errorValidator.SetError(this.txtClave, "Ingresar Contraseña.");
result = false;
}
else
{
this.errorValidator.SetError(this.txtClave, string.Empty);
}
if (result)
{
string userDomain = FindName(txtUsuario.Text);
if (string.IsNullOrEmpty(userDomain))
{
MessageBox.Show(this.ParentForm, "Usted No tiene acceso al Sistema", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
bool existeUsuario = UserExists(txtUsuario.Text);
if (existeUsuario)
{
if (AutenticarEnDominio(userDomain, txtUsuario.Text, txtClave.Text))
{
UsuarioRepository usuarioRepository = new UsuarioRepository();
if (usuarioRepository.GetByUsername(txtUsuario.Text) == null)
{
MessageBox.Show(this.ParentForm, "Este Usuario de Dominio " + txtUsuario.Text + " no pertenece al Sistema", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
UsuarioSession.UserName = this.txtUsuario.Text;
UsuarioSession.Clave = txtClave.Text;
this.DialogResult = DialogResult.OK;
this.Close();
}
}
else
{
MessageBox.Show(this.ParentForm, "Password incorrecto para AD", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
else
{
MessageBox.Show(this.ParentForm, "Este usuario no se encuentra en AD", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
}
public Usuario BuscaPorUsuario(String login, String senha)
{
IUsuarioRepository repository = new UsuarioRepository();
return repository.findByLoginAndSenha(login, senha);
}
protected override void Dispose(bool disposing)
{
_Rep = null;
base.Dispose(disposing);
}
