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];
}
