public async Task <GetUsuarioLoginResponse> Handle(GetUsuarioLoginQuery request, CancellationToken cancellationToken)
{
var entity = await db
.Usuario
.SingleOrDefaultAsync(el => el.NombreUsuario == request.NombreUsuario || el.Email == request.NombreUsuario);
if (entity == null)
{
throw new NotFoundException(nameof(Usuario), request.NombreUsuario);
}
if (PasswordStorage.VerifyPassword(request.Password, entity.HashedPassword))
{
if (!entity.Confirmado)
{
throw new ForbiddenException("La cuenta no ha sido aprobada por el administrador");
}
string randomToken = randomGenerator.SecureRandomString(32);
db.UsuarioToken.Add(new UsuarioToken
{
IdUsuario = entity.Id,
RefreshToken = randomToken
});
entity.AccessFailedCount = 0;
await db.SaveChangesAsync(cancellationToken);
return(new GetUsuarioLoginResponse
{
Email = entity.Email,
NombreUsuario = entity.NombreUsuario,
IdUsuario = entity.Id,
TipoUsuario = entity.TipoUsuario,
RefreshToken = randomToken
});
}
else
{
entity.AccessFailedCount++;
if (entity.AccessFailedCount >= 5)
{
entity.LockoutEnd = dateTime.Now.AddMinutes(1);
}
await db.SaveChangesAsync(cancellationToken);
throw new NotFoundException(nameof(Usuario), request.NombreUsuario);
}
}
public async Task <AddEtapaFenologicaResponse> Handle(AddEtapaFenologicaCommand request, CancellationToken cancellationToken)
{
//Search if exist a Etapa with equals or similar name
string nombre = request.Nombre.ToLower().Trim();
EtapaFenologica oldEtapa = await
db.EtapaFenologica.Where(el =>
el.Nombre.ToLower().Trim().Equals(nombre))
.FirstOrDefaultAsync();
if (oldEtapa == null)
{
EtapaFenologica newEtapa = new EtapaFenologica
{
Nombre = request.Nombre
};
db.EtapaFenologica.Add(newEtapa);
}
else
{
oldEtapa.IsDeleted = false;
oldEtapa.DeletedDate = null;
}
await db.SaveChangesAsync(cancellationToken);
return(new AddEtapaFenologicaResponse());
}
public async Task <AgregarEnfermedadResponse> Handle(AgregarEnfermedadCommand request, CancellationToken cancellationToken)
{
//Search if exist a Enfermedad with equals or similar name
string nombre = NormalizeString(request.Nombre);
Enfermedad oldEnfermedad = await
db.Enfermedad.Where(el =>
el.Nombre.Replace(" ", "").ToLower().Equals(nombre))
.FirstOrDefaultAsync();
if (oldEnfermedad == null)
{
Enfermedad newEnfermedad = new Enfermedad
{
Nombre = request.Nombre
};
db.Enfermedad.Add(newEnfermedad);
}
else
{
oldEnfermedad.IsDeleted = false;
oldEnfermedad.DeletedDate = null;
}
await db.SaveChangesAsync(cancellationToken);
return(new AgregarEnfermedadResponse());
}
public async Task <ConfirmarEmailResponse> Handle(ConfirmarEmailCommand request, CancellationToken cancellationToken)
{
var user = await db
.Usuario
.SingleOrDefaultAsync(el => el.TokenConfirmacion == request.Token, cancellationToken);
if (user == null)
{
throw new NotFoundException(nameof(Usuario), request.Token);
}
if (user.Confirmado)
{
throw new BadRequestException("El usuario se confirmo previamente");
}
user.Confirmado = true;
user.TokenConfirmacion = null;
await db.SaveChangesAsync(cancellationToken);
return(new ConfirmarEmailResponse
{
});
}
public async Task <RefreshCredentialsResponse> Handle(RefreshCredentialsCommand request, CancellationToken cancellationToken)
{
var token = await db
.UsuarioToken
.Include(el => el.UsuarioNavigation)
.SingleOrDefaultAsync(el => el.RefreshToken == request.RefreshToken);
if (token == null)
{
throw new NotAuthorizedException("No se puede comprobar tu informacion");
}
string randomToken = randomGenerator.SecureRandomString(32);
token.RefreshToken = randomToken;
await db.SaveChangesAsync(cancellationToken);
return(new RefreshCredentialsResponse
{
Email = token.UsuarioNavigation.Email,
IdUsuario = token.IdUsuario,
NombreUsuario = token.UsuarioNavigation.NombreUsuario,
RefreshToken = token.RefreshToken,
TipoUsuario = token.UsuarioNavigation.TipoUsuario
});
}
public async Task <ModificarEmailResponse> Handle(ModificarEmailCommand request, CancellationToken cancellationToken)
{
var entity = await db
.Usuario
.SingleOrDefaultAsync(el => el.Id == currentUser.UserId);
if (entity == null)
{
throw new NotFoundException(nameof(Usuario), currentUser.UserId);
}
if (PasswordStorage.VerifyPassword(request.Password, entity.HashedPassword))
{
entity.Email = request.NuevoEmail;
entity.NormalizedEmail = request.NuevoEmail.ToUpper();
await db.SaveChangesAsync(cancellationToken);
return(new ModificarEmailResponse
{
Email = entity.Email
});
}
else
{
throw new BadRequestException("La contrase�a es Incorrecta");
}
}
public async Task <RecuperaPasswordGeneraTokenResponse> Handle(RecuperaPasswordGeneraTokenCommand request, CancellationToken cancellationToken)
{
var usuario = await db
.Usuario
.SingleOrDefaultAsync(el => el.Email == request.Email);
if (usuario != null)
{
string token = random.Guid();
usuario.TokenConfirmacion = token;
await mediator.Publish(new RecuperaPasswordGeneraTokenNotificate
{
Email = request.Email,
Token = token
}, cancellationToken);
await db.SaveChangesAsync(cancellationToken);
}
else
{
// Delay de 200ms a 1000
await Task.Delay(random.Next(200, 1000));
}
return(new RecuperaPasswordGeneraTokenResponse());
}
public async Task <DescargarArchivoResponse> Handle(DescargarArchivoQuery request, CancellationToken cancellationToken)
{
var token = await db
.TokenDescargaArchivo
.SingleOrDefaultAsync(el => el.Token == request.TokenDescarga && el.HashArchivo == request.Hash);
if (token == null)
{
throw new NotAuthorizedException("No autorizado");
}
db.TokenDescargaArchivo.Remove(token);
await db.SaveChangesAsync(cancellationToken);
bool fileExists = await db.ArchivoUsuario.AnyAsync(el => el.Hash == request.Hash);
if (!fileExists)
{
throw new NotFoundException("Archivo", request.Hash);
}
var file = await db
.ArchivoUsuario
.SingleOrDefaultAsync(el => el.Hash == request.Hash);
var stream = fileService.GetStreamFile(request.Hash);
return(new DescargarArchivoResponse
{
Archivo = stream,
ContentType = file.ContentType,
Nombre = file.Nombre
});
}
public async Task <AgregarPlagaResponse> Handle(AgregarPlagaCommand request, CancellationToken cancellationToken)
{
//Search if exist a Plaga with equals or similar name
string nombre = NormalizeString(request.Nombre);
Plaga oldPlaga = await
db.Plaga.Where(el =>
el.Nombre.Replace(" ", "").ToLower().Equals(nombre))
.FirstOrDefaultAsync();
if (oldPlaga == null)
{
Plaga newPlaga = new Plaga
{
Nombre = request.Nombre
};
db.Plaga.Add(newPlaga);
}
else
{
oldPlaga.IsDeleted = false;
oldPlaga.DeletedDate = null;
}
await db.SaveChangesAsync(cancellationToken);
return(new AgregarPlagaResponse());
}
public async Task <DeleteEnfermedadResponse> Handle(DeleteEnfermedadCommand request, CancellationToken cancellationToken)
{
Enfermedad entity = await db.Enfermedad.FindAsync(request.IdEnferemedad);
db.Enfermedad.Remove(entity);
await db.SaveChangesAsync(cancellationToken);
return(new DeleteEnfermedadResponse());
}
public async Task <DeleteEtapaFenologicaResponse> Handle(DeleteEtapaFenologicaCommand request, CancellationToken cancellationToken)
{
EtapaFenologica entity = await db.EtapaFenologica.FindAsync(request.IdEtapa);
db.EtapaFenologica.Remove(entity);
await db.SaveChangesAsync(cancellationToken);
return(new DeleteEtapaFenologicaResponse());
}
public async Task <DeletePlagaResponse> Handle(DeletePlagaCommand request, CancellationToken cancellationToken)
{
Plaga entity = await db.Plaga.FindAsync(request.IdPlaga);
db.Plaga.Remove(entity);
await db.SaveChangesAsync(cancellationToken);
return(new DeletePlagaResponse());
}
public async Task <InvalidaTokenResponse> Handle(InvalidaTokenCommand request, CancellationToken cancellationToken)
{
var token = await db.UsuarioToken.SingleOrDefaultAsync(el => el.RefreshToken == request.RefreshToken);
if (token != null)
{
db.UsuarioToken.Remove(token);
await db.SaveChangesAsync(cancellationToken);
}
return(new InvalidaTokenResponse {
});
}
public async Task <AgregarImagenPerfilResponse> Handle(AgregarImagenPerfilCommand request, CancellationToken cancellationToken)
{
var usuario = await db
.Usuario
.SingleOrDefaultAsync(el => el.Id == currentUser.UserId);
usuario.ImagenPerfil = request.Imagen;
await db.SaveChangesAsync(cancellationToken);
return(new AgregarImagenPerfilResponse
{
});
}
public async Task <AproveUsuarioResponse> Handle(AproveUsuarioCommand request, CancellationToken cancellationToken)
{
var user = await db
.Usuario
.SingleOrDefaultAsync(el => el.NombreUsuario == request.NombreUsuario || el.Email == request.NombreUsuario);
if (user != null)
{
db.Usuario.Attach(user);
user.Confirmado = true;
await db.SaveChangesAsync(cancellationToken);
}
return(new AproveUsuarioResponse());
}
public async Task <TokenDescargaResponse> Handle(TokenDescargaQuery request, CancellationToken cancellationToken)
{
var tokenNuevo = new TokenDescargaArchivo
{
HashArchivo = request.HashArchivo,
Token = random.Guid()
};
db.TokenDescargaArchivo.Add(tokenNuevo);
await db.SaveChangesAsync(cancellationToken);
return(new TokenDescargaResponse
{
TokenDescarga = tokenNuevo.Token
});
}
public async Task <CreateUsuarioResponse> Handle(CreateUsuarioCommand request, CancellationToken cancellationToken)
{
string pass = PasswordStorage.CreateHash(request.Password);
var user = new Usuario
{
Email = request.Email,
NombreUsuario = request.NombreUsuario,
HashedPassword = pass,
TipoUsuario = (TiposUsuario)request.TipoUsuario,
Confirmado = false,
FechaRegistro = dateTime.Now,
TokenConfirmacion = randomGenerator.Guid(),
ApellidoMaterno = request.ApellidoMaterno,
ApellidoPaterno = request.ApellidoPaterno,
Nombre = request.Nombre,
NormalizedEmail = request.Email.ToUpper(),
NormalizedUserName = request.NombreUsuario.ToUpper()
};
db.Usuario.Add(user);
await db.SaveChangesAsync(cancellationToken);
string mensaje = "Usuario Creado, espere a que el Administrador Confirme su Cuenta";
//if (user.TipoUsuario == Domain.Enums.TiposUsuario.Alumno)
//{
// mensaje = "Usuario Creado, revise su correo para poder Acceder por primera vez";
// await mediator.Publish(new CreateUsuarioNotificate { IdUsuario = user.Id }, cancellationToken);
//}
return(new CreateUsuarioResponse
{
Id = user.Id,
Email = user.Email,
NombreUsuario = user.NombreUsuario,
NotificationMessage = mensaje,
ApellidoMaterno = user.ApellidoMaterno,
ApellidoPaterno = user.ApellidoPaterno,
Nombre = user.Nombre
});
}
public async Task <RecuperaPasswordResponse> Handle(RecuperaPasswordCommand request, CancellationToken cancellationToken)
{
var usuario = await db
.Usuario
.SingleOrDefaultAsync(el => el.TokenConfirmacion == request.Token);
if (usuario == null)
{
throw new NotFoundException(nameof(Usuario), new { });
}
string pass = PasswordStorage.CreateHash(request.Password);
usuario.HashedPassword = pass;
usuario.TokenConfirmacion = null;
await db.SaveChangesAsync(cancellationToken);
return(new RecuperaPasswordResponse());
}
public async Task <DeleteUsuarioResponse> Handle(DeleteUsuarioCommand request, CancellationToken cancellationToken)
{
var user = await db
.Usuario
.SingleOrDefaultAsync(el => el.NombreUsuario == request.NombreUsuario || el.Email == request.NombreUsuario);
if (user != null)
{
var archivos = await db.ArchivoUsuario.Where(el => el.IdUsuario == user.Id).ToListAsync();
var tokens = await db.UsuarioToken.Where(el => el.IdUsuario == user.Id).ToListAsync();
db.ArchivoUsuario.RemoveRange(archivos); //TODO delete files from server
db.UsuarioToken.RemoveRange(tokens);
db.Usuario.Remove(user);
await db.SaveChangesAsync(cancellationToken);
}
return(new DeleteUsuarioResponse());
}
public async Task <AgregarArchivoResponse> Handle(AgregarArchivoCommand request, CancellationToken cancellationToken)
{
string hash = await fileService.SaveFile(request.Archivo);
var nuevoArchivo = new Archivo
{
ContentType = request.ContentType,
Hash = hash,
Nombre = request.Nombre,
IdUsuario = currentUser.UserId,
IdReporte = request.IdReporte
};
db.ArchivoUsuario.Add(nuevoArchivo);
await db.SaveChangesAsync(cancellationToken);
return(new AgregarArchivoResponse
{
Hash = hash
});
}
public async Task <ModificarDatosUsuarioResponse> Handle(ModificarDatosUsuarioCommand request, CancellationToken cancellationToken)
{
Usuario entity = await db.Usuario.FindAsync(request.IdUsuario);
if (entity == null)
{
throw new NotFoundException(nameof(Usuario), request.IdUsuario);
}
entity.Nombre = request.Nombre;
entity.ApellidoPaterno = request.ApellidoPaterno;
entity.ApellidoMaterno = request.ApellidoMaterno;
await db.SaveChangesAsync(cancellationToken);
return(new ModificarDatosUsuarioResponse
{
IdUsuario = entity.Id,
Nombre = entity.Nombre,
ApellidoPaterno = entity.ApellidoPaterno,
ApellidoMaterno = entity.ApellidoMaterno
});
}
public async Task <ModificarPasswordResponse> Handle(ModificarPasswordCommand request, CancellationToken cancellationToken)
{
var entity = await db
.Usuario
.SingleOrDefaultAsync(el => el.Id == currentUser.UserId);
if (entity == null)
{
throw new NotFoundException(nameof(Usuario), currentUser.UserId);
}
if (PasswordStorage.VerifyPassword(request.PasswordActual, entity.HashedPassword))
{
string pass = PasswordStorage.CreateHash(request.PasswordNuevo);
entity.HashedPassword = pass;
var tokens = await db
.UsuarioToken
.Where(el => el.IdUsuario == currentUser.UserId).
ToListAsync();
db.UsuarioToken.RemoveRange(tokens);
await db.SaveChangesAsync(cancellationToken);
return(new ModificarPasswordResponse
{
Email = entity.Email
});
}
else
{
throw new BadRequestException("La contrase�a es Incorrecta");
}
}
public async Task <AgregarReporteResponse> Handle(AgregarReporteCommand request, CancellationToken cancellationToken)
{
for (int count = 0; count < request.Reportes.Count; count++)
{
ReporteDTO item = request.Reportes[count];
Reporte entity = new Reporte
{
Lugar = item.Lugar,
Productor = item.Productor,
Latitude = item.Latitude,
Longitud = item.Longitud,
Ubicacion = item.Ubicacion,
Predio = item.Predio,
Cultivo = item.Cultivo,
Observaciones = item.Observaciones,
Litros = item.Litros,
};
db.Reporte.Add(entity);
await db.SaveChangesAsync(cancellationToken);
foreach (ProductoDTO p in item.Productos)
{
entity.Productos.Add(new Producto
{
IdReport = entity.Id,
Cantidad = p.Cantidad,
Unidad = p.Unidad,
Concentracion = p.Concentracion,
IngredienteActivo = p.IngredienteActivo,
IntervaloSeguridad = p.IntervaloSeguridad,
NombreProducto = p.Nombre,
Reporte = entity
});
}
foreach (PlagaDTO plaga in item.Plagas)
{
//Search if exist a Plaga with equals or similar name
string nombre = NormalizeString(plaga.Nombre);
Plaga oldPlaga = await
db.Plaga.Where(el =>
el.Nombre.Replace(" ", "").ToLower().Equals(nombre))
.FirstOrDefaultAsync();
if (oldPlaga == null)
{
Plaga newPlaga = new Plaga
{
Nombre = plaga.Nombre
};
db.Plaga.Add(newPlaga);
await db.SaveChangesAsync(cancellationToken);
entity.ReportePlaga.Add(new ReportePlaga {
Plaga = newPlaga
});
}
else
{
oldPlaga.IsDeleted = false;
oldPlaga.DeletedDate = null;
db.Plaga.Update(oldPlaga);
entity.ReportePlaga.Add(new ReportePlaga {
Plaga = oldPlaga
});
}
}
foreach (EtapaFenogolicaDTO etapa in item.EtapaFenologica)
{
//Search if exist a Etapa with equals or similar name
string nombre = NormalizeString(etapa.Nombre);
EtapaFenologica oldEtapaF = await
db.EtapaFenologica.Where(el =>
el.Nombre.Replace(" ", "").ToLower().Equals(nombre))
.FirstOrDefaultAsync();
if (oldEtapaF == null)
{
var newEtapa = new EtapaFenologica
{
Nombre = etapa.Nombre
};
db.EtapaFenologica.Add(newEtapa);
await db.SaveChangesAsync(cancellationToken);
entity.ReporteEtapaFenologica.Add(new ReporteEtapaFenologica {
EtapaFenologica = newEtapa
});
}
else
{
oldEtapaF.IsDeleted = false;
oldEtapaF.DeletedDate = null;
db.EtapaFenologica.Update(oldEtapaF);
entity.ReporteEtapaFenologica.Add(new ReporteEtapaFenologica {
EtapaFenologica = oldEtapaF
});
}
}
foreach (EnfermedadDTO enfermedad in item.Enfermedades)
{
//Search if exist a Enfermedad with equals or similar name
string nombre = NormalizeString(enfermedad.Nombre);
Enfermedad oldEnfermedad = await
db.Enfermedad.Where(el =>
el.Nombre.Replace(" ", "").ToLower().Equals(nombre))
.FirstOrDefaultAsync();
if (oldEnfermedad == null)
{
Enfermedad newEnfermedad = new Enfermedad
{
Nombre = enfermedad.Nombre
};
db.Enfermedad.Add(newEnfermedad);
await db.SaveChangesAsync(cancellationToken);
entity.ReporteEnfermedad.Add(new ReporteEnfermedad {
Enfermedad = newEnfermedad
});
}
else
{
oldEnfermedad.IsDeleted = false;
oldEnfermedad.DeletedDate = null;
db.Enfermedad.Update(oldEnfermedad);
entity.ReporteEnfermedad.Add(new ReporteEnfermedad {
Enfermedad = oldEnfermedad
});
}
}
await db.SaveChangesAsync(cancellationToken);
request.Reportes[count].Id = entity.Id;
}
return(new AgregarReporteResponse
{
Id = request.Reportes.Select(el => el.Id).ToList()
});
}