Esempio n. 1
0
            public async Task <List <Curso> > Handle(ListaCursos request, CancellationToken cancellationToken)
            {
                //throw new System.NotImplementedException();
                var cursos = await _context.Curso.ToListAsync();

                return(cursos);
            }
Esempio n. 2
0
            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);
            }
Esempio n. 3
0
        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);
            }
        }
Esempio n. 4
0
            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);
            }
Esempio n. 5
0
            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);
            }
Esempio n. 6
0
            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);
            }
Esempio n. 7
0
            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));
            }
Esempio n. 8
0
            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);
            }
Esempio n. 10
0
            public async Task <List <Curso> > Handle(ListaCursos request, CancellationToken cancellationToken)
            {
                var cursos = await _context.Curso.ToListAsync();

                return(cursos);
            }
Esempio n. 11
0
        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;
            }
        }