public async Task <AutenticarUsuarioResponse> Handle(AutenticarUsuarioRequest request, CancellationToken cancellationToken) { //Valida se o objeto request esta nulo if (request == null) { AddNotification("Request", "Request é obrigatório"); return(null); } request.Email = request.Email.ToLower(); request.Senha = request.Senha.ConvertToMD5(); //Entities.Usuario usuario = _repositoryUsuario.ObterPor(x => x.Email == request.Email); Entities.Usuario usuario = _repositoryUsuario.ObterPor(x => x.Email == request.Email && x.Senha == request.Senha); if (usuario == null) { AddNotification("Usuario", "Usuário não encontrado."); return(new AutenticarUsuarioResponse() { Autenticado = false }); } //Cria objeto de resposta var response = (AutenticarUsuarioResponse)usuario; ////Retorna o resultado return(await Task.FromResult(response)); }
public AdicionarUsuarioResponse AdicionarUsuario(AdicionarUsuarioRequest request) { if (request == null) { AddNotification("AdicionarUsuarioRequest", "Invalido"); return(null); } var nome = new Nome(request.RazaoSocial, request.NomeFantasia); var email = new Email(request.Email); Entities.Usuario usuario = new Entities.Usuario(nome, email, request.Senha, request.CnpjCpf, request.ClienteOuFornecedor); AddNotifications(usuario, nome, email); if (_repositoryUsuario.Existe(x => x.CnpjCpf == usuario.CnpjCpf)) { AddNotification("CnpjCpf", "Já cadastrado"); } if (_repositoryUsuario.Existe(x => x.Email.Endereco == usuario.Email.Endereco)) { AddNotification("Email", "Já cadastrado"); } if (this.IsInvalid()) { return(null); } //Persiste no banco de dados _repositoryUsuario.Adicionar(usuario); return(new AdicionarUsuarioResponse(usuario.Id)); }
public async Task <Response> Handle(AdicionarUsuarioRequest request, CancellationToken cancellationToken) { //Validar se o requeste veio preenchido if (request == null) { AddNotification("Resquest", "informe os dados do usuario"); return(new Response(this)); } //Verificar se o usuário já existe if (_repositoryUsuario.Existe(x => x.Email == request.Email)) { AddNotification("Email", "email ja cadastrado"); return(new Response(this)); } Entities.Usuario usuario = new Entities.Usuario(request.PrimeiroNome, request.UltimoNome, request.Email, request.Senha); AddNotifications(usuario); if (IsInvalid()) { return(new Response(this)); } usuario = _repositoryUsuario.Adicionar(usuario); //criar meu usuario de resposta var response = new Response(this, usuario); AdicionarUsuarioNotification adicionarUsuarioNotification = new AdicionarUsuarioNotification(usuario); await _mediator.Publish(adicionarUsuarioNotification); return(await Task.FromResult(response)); }
public async Task <AutenticarUsuarioResponse> Handle(AutenticarUsuarioResquest request, CancellationToken cancellationToken) { //Valida se o objeto request esta nulo if (request == null) { AddNotification("Request", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("Request")); return(null); } request.Senha = request.Senha.ConvertToMD5(); Entities.Usuario usuario = _repositoryUsuario.ObterPor(x => x.Email == request.Email && x.Senha == request.Senha); if (usuario == null) { AddNotification("Usuario", MSG.X0_NAO_INFORMADO.ToFormat("Request")); return(new AutenticarUsuarioResponse() { Autenticado = false }); } //Cria objeto de resposta var response = (AutenticarUsuarioResponse)usuario; ////Retorna o resultado return(await Task.FromResult(response)); }
public async Task <Response> Handle(AdicionarUsuarioRequest request, CancellationToken cancellationToken) { if (request == null) { AddNotification("Request", "Informe os dados do usuário!"); return(new Response(this)); } if (_repositoryUsuario.Existe(x => x.Email == request.Email)) { AddNotification("Email", "E-mail já cadastrado no sistema!"); return(new Response(this)); } Entities.Usuario usuario = new Entities.Usuario(request.PrimeiroNome, request.UltimoNome, request.Email, request.Senha); AddNotifications(usuario); if (IsInvalid()) { return(new Response(this)); } usuario = _repositoryUsuario.Adicionar(usuario); var response = new Response(this, usuario); AdicionaUsuarioNotification adicionaUsuarioNotification = new AdicionaUsuarioNotification(usuario); await _mediator.Publish(adicionaUsuarioNotification); return(await Task.FromResult(response)); }
public async Task <Response> Handle(AdicionarUsuarioRequest request, CancellationToken cancellationToken) { //Validar se o requeste veio preenchido if (request == null) { AddNotification("Resquest", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("Usuário")); return(new Response(this)); } //Verificar se o usuário já existe if (_repositoryUsuario.Existe(x => x.Email == request.Email)) { AddNotification("Email", MSG.ESTE_X0_JA_EXISTE.ToFormat("E-mail")); return(new Response(this)); } Entities.Usuario usuario = new Entities.Usuario(request.PrimeiroNome, request.UltimoNome, request.Email, request.Senha); AddNotifications(usuario); if (IsInvalid()) { return(new Response(this)); } usuario = _repositoryUsuario.Adicionar(usuario); //Criar meu objeto de resposta var response = new Response(this, usuario); AdicionarUsuarioNotification adicionarUsuarioNotification = new AdicionarUsuarioNotification(usuario); await _mediator.Publish(adicionarUsuarioNotification); return(await Task.FromResult(response)); }
protected void Page_Load(object sender, EventArgs e) { Bussiness.ControlUsuarios user = new Bussiness.ControlUsuarios(); Entities.Usuario usuario = new Entities.Usuario(); usuario.Documento = Request.QueryString["documento"]; user.eliminar(usuario); Response.Redirect("UserLista.aspx"); }
public IHttpActionResult ActualizarUsuario([FromBody] Entities.Usuario usuario) { usuario.usuario = Security.GetUser(); usuario.ts = DateTime.Now; var result = _usuarioBiz.Update(usuario); return(Ok(result)); }
public static List <Entities.Usuario> GetUsuarios(Entities.Usuario u) { try { using (ISession session = NHibernateHelper.OpenSession()) { //Option ICriteria crit = session.CreateCriteria(typeof(Entities.Usuario)); if (u.PkUsuario != 0 && u.PkUsuario.ToString() != "") { crit.Add(Restrictions.Like("PkUsuario", u.PkUsuario)); } if (!string.IsNullOrEmpty(u.Alias)) { crit.Add(Restrictions.Like("Alias", u.Alias)); } if (!string.IsNullOrEmpty(u.Clave)) { crit.Add(Restrictions.Like("Clave", u.Clave)); } if (u.Activo != null) { crit.Add(Restrictions.Eq("Activo", u.Activo)); } if (u.FchRegistro != null) { crit.Add(Restrictions.Between("FchRegistro", u.FchRegIni, u.FchRegFin)); } if (u.IdUsuarioReg != 0 && u.IdUsuarioReg.ToString() != "") { crit.Add(Restrictions.Like("IdUsuarioReg", u.IdUsuarioReg)); } if (u.FchActualizacion != null) { crit.Add(Restrictions.Between("FchActualizacion", u.FchActIni, u.FchActFin)); } if (u.IdUsuarioAct != 0 && u.IdUsuarioAct.ToString() != "") { crit.Add(Restrictions.Like("IdUsuarioAct", u.IdUsuarioAct)); } if (u.FchSession != null) { crit.Add(Restrictions.Like("FchSession", u.FchSession)); } if (!string.IsNullOrEmpty(u.TokenSession)) { crit.Add(Restrictions.Like("TokenSession", u.TokenSession)); } return((List <Entities.Usuario>)crit.List <Entities.Usuario>()); } } catch (Exception err) { return(new List <Entities.Usuario>()); } }
public async Task <bool> RemoveRoleOfUser(Entities.Role role, Entities.Usuario user) { Entities.RolesUsuario rolesUsuario = new RolesUsuario() { Role = role, Usuario = user }; _userRepository.RemoveRoleOfUser(rolesUsuario); var result = await _unitOfWork.CompleteAsync(); return(result); }
public async Task <Response> Handle(Request request, CancellationToken cancellationToken) { var novoUsuario = new Entities.Usuario(request.Nome, request.Email, request.Senha.Encrypt(), request.Roles); _usuarioWriteRepository.Add(novoUsuario); await _uow.CommitAsync(); await Mediator.Publish(new Notification { Id = novoUsuario.Id, Nome = novoUsuario.Nome, Email = novoUsuario.Email }); return(new Response(novoUsuario)); }
public bool agregarUsuario(int DNI, string nombre, string mail, string pass, bool esAdmin, bool bloqueado) { try { Entities.Usuario usuario = new Entities.Usuario(DNI, nombre, mail, pass, esAdmin, bloqueado); misUsuarios.Add(usuario); contexto.SaveChanges(); return(true); } catch (Exception) { return(false); } }
public static List <Entities.Usuario> Select(Entities.Usuario usuario) { using (var db = GetInstance()) { var datos = db.Table <Entities.Usuario>(); var listaDatos = new List <Entities.Usuario>(); foreach (var dato in datos.Where(x => x.IdUsuario == usuario.IdUsuario)) { listaDatos.Add(dato); } return(listaDatos); } }
public Entities.Usuario buscarUsuarioxDNI(int dni) { var query = from usuarioDB in misUsuarios where usuarioDB.DNI == dni select usuarioDB; Entities.Usuario usuario = null; if (query != null) { usuario = query.FirstOrDefault(); } return(usuario); }
public string autenticar(string nombre, string password) { contexto.Dispose(); inicializarAtributos(); string respuesta = ""; var query = from usuarioDB in contexto.Usuario where usuarioDB.nombre == nombre select usuarioDB; Entities.Usuario usuario = query.FirstOrDefault(); if (usuario != null) { if (usuario.bloqueado == false) { if (password == usuario.pass) { respuesta = "OK"; } else { usuario.intentosLogueo++; if (usuario.intentosLogueo >= 3) { usuario.bloqueado = true; usuario.intentosLogueo = 0; respuesta = "USUARIO BLOQUEADO"; } else { respuesta = "TE QUEDAN " + (3 - usuario.intentosLogueo) + " INTENTOS"; } contexto.Usuario.Update(usuario); contexto.SaveChanges(); } } else { respuesta = "USUARIO BLOQUEADO"; } } return(respuesta); }
public static bool Actualizar(Entities.Usuario us) { try { using (ISession session = NHibernateHelper.OpenSession()) { session.Update(us); session.Flush(); session.Close(); } } catch { return(false); } return(true); }
private void NotifyResetUser(Entities.Usuario usuario, string password) { var body = new StringBuilder(); var subject = Resource.NewPasswordSubject; body.Append("Su contraseña ha sido reseteada. Su nueva contraseña es: "); body.Append(Environment.NewLine); body.Append(string.Format("contraseña: {0}", password)); body.Append(Environment.NewLine); body.Append("Recuerde que usted podrá cambiar su contraseña una vez que acceda a su cuenta."); body.Append(Environment.NewLine); body.Append(Environment.NewLine); body.Append("Cordialmente,"); body.Append(Environment.NewLine); body.Append("Administración SGS"); Mail.SendEmail(usuario.Email, subject, body.ToString()); }
public IHttpActionResult CrearUsuario([FromBody] UsuarioRequestVM usuario) { var user = new Entities.Usuario() { nombre = usuario.nombre, apellido = usuario.apellido, legajo = usuario.legajo, usuarioAD = usuario.usuarioAD, usuario = Security.GetUser(), Estado = Estado.A.ToString(), fhAlta = DateTime.Now, ts = DateTime.Now, email = usuario.email }; var result = _usuarioBiz.Create(user); return(Created($"Usuario/" + result.id, result)); }
private void button1_Click(object sender, EventArgs e) { //BOTON COMFIRMAR var recuperoDni = Ag.recuperoDni(Global.GlobalSessionNombre, Global.GlobalSessionPass); Entities.Usuario usuario = Ag.buscarUsuarioxDNI(recuperoDni); if (Ag.reservar(int.Parse(Id_text.Text), recuperoDni.ToString(), desdeFecha.Value, hastaFecha.Value)) { MessageBox.Show("Reservó con éxito"); this.Close(); this.Dispose(); } else { MessageBox.Show("Error al insertar"); } }
public bool Cadastrar(string email, string senha) { if (ModelState.IsValid) { Entities.Usuario usuario = new Entities.Usuario(); usuario.Email = email; usuario.Senha = GetHash(senha); _usuarioRepository.Add(usuario); return(true); } else { return(false); } }
public async Task <Models.UsuarioRolesDto> GetRolesForUser(Entities.Usuario user) { // Get all related roles to a specific user var userRoleEntityList = await _userRepository.GetRolesForUserAsync(user.Id); Models.UsuarioRolesDto userRoleDto = _mapper.Map <Models.UsuarioRolesDto>(user); var roleListDto = new List <Models.RoleDtoModels.RoleDto>(); foreach (var item in userRoleEntityList) { var map = _mapper.Map <Models.RoleDtoModels.RoleDto>(item.Role); roleListDto.Add(map); } userRoleDto.Roles = roleListDto; return(userRoleDto); }
private void NotifyNewUser(Entities.Usuario usuario, string password) { var body = new StringBuilder(); var subject = Resource.NewUserSubject; body.Append("Ud. ya posee una cuenta para acceder al sistema. Sus credenciales son: "); body.Append(Environment.NewLine); body.Append(string.Format("Usuario: {0}", usuario.Nick)); body.Append(Environment.NewLine); body.Append(string.Format("contraseña: {0}", password)); body.Append(Environment.NewLine); body.Append("Recuerde que usted podrá cambiar su contraseña una vez que acceda a su cuenta."); body.Append(Environment.NewLine); body.Append(Environment.NewLine); body.Append("Cordialmente,"); body.Append(Environment.NewLine); body.Append("Administración SGS"); Mail.SendEmail(usuario.Email, subject, body.ToString()); }
public async Task <Communication.UserResponse> DeleteAsync(Entities.Usuario user) { // For demo purposes we'll use a simple try catch try { _userRepository.Remove(user); var result = await _unitOfWork.CompleteAsync(); if (!result) { return(new Communication.UserResponse($"An error occurred when saving")); } return(new Communication.UserResponse(user)); } catch (Exception ex) { return(new Communication.UserResponse($"An error occurred when saving the category: {ex.Message}")); } }
public bool desbloquearUsuario(int id) { bool desbloqueado = false; var query = from usuarioDB in misUsuarios where usuarioDB.id == id select usuarioDB; Entities.Usuario usuario = query.FirstOrDefault(); if (usuario != null) { usuario.bloqueado = false; contexto.Usuario.Update(usuario); contexto.SaveChanges(); desbloqueado = true; } return(desbloqueado); }
public async Task <Response> Handle(AdicionarUsuarioRequest request, CancellationToken cancellationToken) { var response = new Response(); bool emailExistente = EmailExistente(request); if (emailExistente) { response.AdicionarNotificacao("E-mail cadastrado", "O e-mail informado já está sendo utilizado"); } var usuario = new Entities.Usuario( primeiroNome: request.PrimeiroNome, ultimoNome: request.UltimoNome, email: request.Email, senha: request.Senha); _usuarioRepository.Adicionar(usuario); await _mediator.Publish(new AdicionarUsuarioNotification(usuario)).ConfigureAwait(false); return(await Task.FromResult(new Response("Usuário adicionado com sucesso")).ConfigureAwait(false)); }
public static List <Entities.Usuario> SelectAllUsuario() { var conn = GetConnection(); try { var usuarios = new List <Entities.Usuario>(); SqlCommand command = new SqlCommand("SELECT ID_USUARIO,NOMBRE,APELLIDO,CONTRASENA,FECHA_BAJA,FECHA_ALTA FROM USUARIO", conn); command.CommandType = CommandType.Text; var reader = command.ExecuteReader(); if (reader.HasRows) { while (reader.Read()) { var usuario = new Entities.Usuario(); usuario.IdUsuario = reader["ID_USUARIO"].ToString(); usuario.Nombre = reader["NOMBRE"].ToString(); usuario.Apellido = reader["APELLIDO"].ToString(); usuario.Contrasena = reader["CONTRASENA"].ToString(); usuario.FechaBaja = reader.IsDBNull(4) ? (DateTime?)null : Convert.ToDateTime(reader["FECHA_BAJA"].ToString()); usuario.FechaAlta = reader.IsDBNull(5) ? (DateTime?)null : Convert.ToDateTime(reader["FECHA_ALTA"].ToString()); usuarios.Add(usuario); } } return(usuarios); } catch (Exception exception) { throw; } finally { conn.Close(); } }
public async Task <Response> Handle(CadastrarUsuarioRequest request, CancellationToken cancellationToken) { if (_repositoryUsuario.Existe(x => x.Email == request.Email)) { AddNotification("Email", "O email já está cadastrado"); return(new Response(this)); } Entities.Usuario usuario = new Entities.Usuario(request.Nome, request.Email, request.Senha, request.Celular, request.DataAniversario); if (IsInvalid()) { return(new Response(this)); } AddNotifications(usuario); usuario = _repositoryUsuario.Adicionar(usuario); var response = new Response(this, usuario); CadastrarUsuarioNotification cadastrarUsuarioNotification = new CadastrarUsuarioNotification(usuario); await _mediator.Publish(cadastrarUsuarioNotification); return(await Task.FromResult(response)); }
public List <Entities.Persona> GetPersonas(Entities.Usuario u, Entities.Persona p) { Entities.Error _e; Acceso access = new Acceso(); _e = access.ValidarSesion(u); if (_e.IdError == 0) { _Persona = new Data.Seguridad.Personas(); return(_Persona.GetPersonas(p)); } return(new List <Entities.Persona>() { new Entities.Persona() { error = _e } }); }
public async Task <Response> Handle(Request request, CancellationToken cancellationToken) { bool credenciaisValidas = false; Entities.Usuario userData = null; switch (request.GrantType) { case "password": userData = await _usuarioReadRepository.GetByEmailAsync(request.Email); credenciaisValidas = (userData != null && request.Password.Encrypt() == userData.Senha); break; case "refresh_token": userData = await _usuarioReadRepository.GetByRefreshTokenAsync(request.RefreshToken); credenciaisValidas = (userData?.RefreshToken != null && userData.RefreshTokenIsValid && request.RefreshToken == userData.RefreshToken); break; default: credenciaisValidas = false; break; } if (!credenciaisValidas) { return(new Response().AddError("Dados Inválidos")); } // Gerar RefreshToken userData.RefreshTokenGenerate(_securitySettings.RefreshTokenExpires); _usuarioWriteRepository.Update(userData); await _uow.CommitAsync(); return(new Response(userData)); }
//public List<List<string>> getReservasPorCliente(String dni) //{ // List<List<string>> resultado = new List<List<string>>(); // var query = from reservaDB in reservas // where reservaDB.usuario.DNI == dni // select reservaDB; // foreach (Entities.Reserva reservas in query) // { // resultado.Add(new List<string> { reservas.FDesde.ToString(), reservas.FHasta.ToString(), // reservas.tipoAlojamiento.nombre, reservas.usuario.DNI.ToString(), reservas.precio.ToString()}); // } // return resultado; //} public bool reservar(int codAloj, string dniUsuario, DateTime Fdesde, DateTime Fhasta) { Entities.Usuario usuario = new Entities.Usuario(); usuario = buscarUsuarioxDNI(int.Parse(dniUsuario)); bool result = false; var queryAlojamiento = from alojamientoDB in alojamientos where alojamientoDB.id == codAloj select alojamientoDB; if (queryAlojamiento != null) { Entities.Alojamiento alojamiento = queryAlojamiento.FirstOrDefault(); if (alojamiento != null) { Entities.Reserva reservita = new Entities.Reserva(); reservita.FDesde = Fdesde; reservita.FHasta = Fhasta; reservita.id_usuario = usuario; reservita.id_alojamiento = alojamiento; contexto.Reserva.Add(reservita); contexto.SaveChanges(); result = true; } else { result = false; } } return(result); }
public Entities.Usuario LoadByPk(int kID) { var usuario = new Entities.Usuario{ID = kID}; var usuarios = ListaUsuario(usuario); if (usuarios.Count == 0) return null; return ListaUsuario(usuario)[0]; }