public async Task <List <Curso> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
//throw new System.NotImplementedException();
var cursos = await _context.Curso.ToListAsync();
return(cursos);
}
public async Task <List <Cursos> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await _context.Cursos
.Include(valor => valor.InstructorLink)
.ThenInclude(valor => valor.Instructor).ToListAsync();
return(cursos);
}
private async System.Threading.Tasks.Task AtualizarTela()
{
ListaCursos.Clear();
Curso = new Model.Curso();
var response = await CursoDao.Buscar();
foreach (Model.Curso item in response)
{
ListaCursos.Add(item);
}
}
public async Task <List <CursoDTO> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await _context.Curso
.Include(x => x.ComentarioLista)
.Include(x => x.PrecioPromocion)
.Include(x => x.InstructoresLink)
.ThenInclude(x => x.Instructor).ToListAsync();
var cursosdto = _mapper.Map <List <Curso>, List <CursoDTO> >(cursos);
return(cursosdto);
}
public async Task <List <CursoDTO> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await _context.Cursos
.Include(x => x.Comentarios)
.Include(x => x.PrecioPromocion)
.Include(x => x.InstructoresLink)
.ThenInclude(x => x.Instructor).ToListAsync();
//primer parametro -> origen, segundo -> destino, cursos -> data a mapear
var cursosDto = _mapper.Map <List <Curso>, List <CursoDTO> >(cursos);
return(cursosDto);
}
public async Task <List <CursoDto> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await _context.Curso
.Include(x => x.CometarioLista)
.Include(x => x.PrecioPromocion)
.Include(x => x.InstructoresLink)
.ThenInclude(x => x.Instructor).ToListAsync();
//mapear clases
var cursosDto = _mapper.Map <List <Curso>, List <CursoDto> >(cursos);
//Siempre que se inyecte algo se tiene que inicializar en webapi
return(cursosDto);
}
public async Task <List <CursoDto> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await Context.curso
.Include(x => x.ComentarioCurso)
.Include(x => x.PrecioPromocion)
.Include(x => x.InstructoresLink)
.ThenInclude(x => x.Instructor)
.ToListAsync();
if (cursos == null)
{
throw new ManejadorExcepcion(HttpStatusCode.NoContent, new { cursos = "Error al listar los cursos, contacte al administrador del sistema" });
}
return(_mapper.Map <List <Curso>, List <CursoDto> >(cursos));
}
public async Task <List <CursoDto> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
//Devolver la data al cliente usando un DTO
var cursos = await _context.Curso
.Include(x => x.ComentarioLista)
.Include(X => X.PrecioPromocion)
.Include(x => x.InstructoresLink)
.ThenInclude(x => x.Instructor)
.ToListAsync();
// Map recibe dos parámetos, el tipo de dato origen y al que se transformará, después el
// objeto, finalmente la data que se transformará
var cursosDto = _mapper.Map <List <Curso>, List <CursoDto> >(cursos);
return(cursosDto);
}
//Metodo que proviene de la interfaz IRequestHandler
public async Task <List <CursoDto> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
//Normalmente las transaciones en los servidores son de ida y vuelta por eso se trabaja con procesos asincronos
//De esta forma podemos devolver la data de los cursos y de los instructores relacionado a este curso
var cursos = await _context.Curso
.Include(x => x.ComentarioLista)
.Include(x => x.PrecioPromocion)
.Include(x => x.InstructoresLink) //Incluye a InstructorLink proviene de Dominio/Curso, esto representa la tabla CursoInstructor
//Lo que acabo de hacer es vincular Curso con CursoInstructor
.ThenInclude(x => x.Instructor) //este meto me pregunta a quien quieres incluiir, incluire a Instructor
.ToListAsync();
//Este resultado(cursos) es de formato Entity Core y necesitaba pasarlo a un
//formato dto
//Metodo Map(de la libreria AutorMapper) pedira 2 parametros
//1 Tipo de dato origen
//2 tipo de datos destino(en lo que quieres que se convierta)
//en este caso dto, y luego la data que convertiras en este caso cursos
var cursosDto = _mapper.Map <List <Curso>, List <CursoDto> >(cursos);
return(cursosDto);
}
public async Task <List <Curso> > Handle(ListaCursos request, CancellationToken cancellationToken)
{
var cursos = await _context.Curso.ToListAsync();
return(cursos);
}
public async void Execute(object control)
{
if (control.Equals("Nuevo"))
{
LimpiarCampos();
ActivarControles();
this._accion = ACCION.NUEVO;
}
else if (control.Equals("Eliminar"))
{
if (Elemento != null)
{
MessageDialogResult resultado = await this._dialogCoordinator.ShowMessageAsync(
this,
"Eliminar Curso",
"Esta seguro de eliminar el registro?",
MessageDialogStyle.AffirmativeAndNegative);
if (resultado == MessageDialogResult.Affirmative)
{
try
{
_db.Cursos.Remove(Elemento);
_db.SaveChanges();
this.ListaCursos.Remove(Elemento);
LimpiarCampos();
}
catch (Exception ex)
{
await this._dialogCoordinator.ShowMessageAsync(
this,
"Eliminar Curso",
ex.Message);
}
}
}
else
{
await this._dialogCoordinator.ShowMessageAsync(
this,
"Eliminar Curso",
"Debe seleccionar un elemento");
}
}
else if (control.Equals("Guardar"))
{
switch (this._accion)
{
case ACCION.NINGUNO:
break;
case ACCION.NUEVO:
try
{
var registro = new Curso
{
Descripcion = this.Descripcion
};
_db.Cursos.Add(registro);
_db.SaveChanges();
this.ListaCursos.Add(registro);
}
catch (Exception ex)
{
await this._dialogCoordinator.ShowMessageAsync(
this,
"Guardar Curso",
ex.Message);
}
finally
{
DesactivarControles();
this._accion = ACCION.NINGUNO;
}
break;
case ACCION.GUARDAR:
try
{
int posicion = ListaCursos.IndexOf(Elemento);
var registro = _db.Cursos.Find(Elemento.CursoId);
if (registro != null)
{
registro.Descripcion = this.Descripcion;
_db.Entry(registro).State = EntityState.Modified;
_db.SaveChanges();
ListaCursos.RemoveAt(posicion);
ListaCursos.Insert(posicion, registro);
}
}
catch (Exception ex)
{
await this._dialogCoordinator.ShowMessageAsync(
this,
"Editar Curso",
ex.Message);
}
finally
{
DesactivarControles();
this._accion = ACCION.NINGUNO;
}
break;
default:
break;
}
}
else if (control.Equals("Editar"))
{
if (Elemento != null)
{
ActivarControles();
this._accion = ACCION.GUARDAR;
}
else
{
await this._dialogCoordinator.ShowMessageAsync(
this,
"Editar Curso",
"Debe seleccionar un elemento");
}
}
else if (control.Equals("Cancelar"))
{
DesactivarControles();
this._accion = ACCION.NINGUNO;
}
}