Esempio n. 1
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                Guid cursoId = Guid.NewGuid();

                var curso = new Curso
                {
                    CursoId          = cursoId,
                    Titulo           = request.Titulo,
                    Descripcion      = request.Descripcion,
                    FechaPublicacion = request.FechaPublicacion,
                    FechaCreacion    = DateTime.UtcNow
                };

                context.Curso.Add(curso);

                if (request.ListaInstructor != null)
                {
                    foreach (var id in request.ListaInstructor)
                    {
                        var cursoInstructor = new CursoInstructor
                        {
                            CursoId      = cursoId,
                            InstructorId = id
                        };
                        this.context.CursoInstructor.Add(cursoInstructor);
                    }
                }

                var precio = new Precio
                {
                    CursoId      = cursoId,
                    PrecioId     = Guid.NewGuid(),
                    PrecioActual = request.Precio.PrecioActual,
                    Promocion    = request.Precio.Promocion
                };

                this.context.Precio.Add(precio);

                var valor = await context.SaveChangesAsync();

                if (valor > 0)
                {
                    return(Unit.Value);
                }

                throw new ManejadorExepcion(HttpStatusCode.InternalServerError, new { mensaje = "No se pudo Agregar el Curso" });
            }
Esempio n. 2
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                Guid _cursoId = Guid.NewGuid();
                var  curso    = new Curso {
                    CursoId          = _cursoId,
                    Titulo           = request.Titulo,
                    Descripcion      = request.Descripcion,
                    FechaPublicacion = request.FechaPublicacion,
                    FechaCreacion    = DateTime.UtcNow
                };

                _context.Curso.Add(curso);

                // Graba los instructores del curso
                if (request.ListaInstructor != null)
                {
                    foreach (var id in request.ListaInstructor)
                    {
                        var cursoInstructor = new CursoInstructor {
                            CursoId      = _cursoId,
                            InstructorId = id
                        };
                        _context.CursoInstructor.Add(cursoInstructor);
                    }
                }

                // Insertar precio del curso nuevo
                var precioEntidad = new Precio {
                    CursoId      = _cursoId,
                    PrecioActual = request.Precio,
                    Promocion    = request.Promocion,
                    PrecioId     = Guid.NewGuid()
                };

                _context.Precio.Add(precioEntidad);

                var valor = await _context.SaveChangesAsync();

                // valor = 0 es que no hubo transacción
                if (valor > 0)
                {
                    return(Unit.Value);  // y se termina la transacción
                }

                // Si se produce error, o sea, valor = 0
                throw new Exception("No se pudo insertar el curso.");
            }
Esempio n. 3
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                /* para eliminar un curso primero hay que eliminar sus instructores de CursoInstructor */
                var instructoresBD = _context.CursoInstructor.Where(x => x.CursoId == request.Id);

                foreach (var instructor in instructoresBD)
                {
                    _context.CursoInstructor.Remove(instructor);
                }

                // Obtener comentarios y eliminar los comentarios del curso
                var comentariosDB = _context.Comentario.Where(x => x.CursoId == request.Id);

                foreach (var cmt in comentariosDB)
                {
                    _context.Comentario.Remove(cmt);
                }

                // Eliminar precios del curso
                var precioDB = _context.Precio.Where(x => x.CursoId == request.Id).FirstOrDefault();

                if (precioDB != null)
                {
                    _context.Precio.Remove(precioDB);
                }

                var curso = await _context.Curso.FindAsync(request.Id);

                if (curso == null)
                {
                    // throw new Exception("No se puede eliminar el curso.");
                    throw new ManejadorExcepcion(HttpStatusCode.NotFound, new { mensaje = "No se encontró el curso" });
                }

                _context.Remove(curso);

                var resultado = await _context.SaveChangesAsync();

                if (resultado > 0)
                {
                    return(Unit.Value);
                }

                throw new Exception("No se pudieron guardar los cambios.");
            }
Esempio n. 4
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var comentario = await _context.Comentario.FindAsync(request.Id);

                if (comentario == null)
                {
                    throw new ManejadorExcepcion(HttpStatusCode.NotFound, new { mensaje = "No se ha encontrado el comentario" });
                }

                _context.Remove(comentario);
                var resultado = await _context.SaveChangesAsync();

                if (resultado > 0)
                {
                    return(Unit.Value);
                }

                throw new Exception("No se ha podido eliminar el comentario");
            }
Esempio n. 5
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var comentarios = this.context.Comentario.Where(x => x.CursoId == request.Id);

                foreach (var comentario in comentarios)
                {
                    this.context.Comentario.Remove(comentario);
                }

                var precio = this.context.Precio.Where(x => x.CursoId == request.Id).FirstOrDefault();

                if (precio != null)
                {
                    this.context.Remove(precio);
                }


                var instructoresDB = this.context.CursoInstructor.Where(x => x.CursoId == request.Id).ToList();

                foreach (var instructorEliminar in instructoresDB)
                {
                    this.context.CursoInstructor.Remove(instructorEliminar);
                }

                var curso = await context.Curso.FindAsync(request.Id);

                if (curso == null)
                {
                    //throw new Exception("El Curso no existe");
                    throw new ManejadorExepcion(HttpStatusCode.NotFound, new  { mensaje = "No se encontro el curso" });
                }

                context.Remove(curso);
                var valor = await context.SaveChangesAsync();

                if (valor > 0)
                {
                    return(Unit.Value);
                }

                throw new ManejadorExepcion(HttpStatusCode.InternalServerError, new { mensaje = "No se pudo eliminar el curso" });
            }
Esempio n. 6
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var comentario = this.context.Comentario.FindAsync(request.Id);

                if (comentario == null)
                {
                    throw new ManejadorExepcion(HttpStatusCode.NotFound, new { mensaje = "Comentario no encontrado" });
                }

                this.context.Remove(comentario);

                var valor = await context.SaveChangesAsync();

                if (valor > 0)
                {
                    return(Unit.Value);
                }

                throw new ManejadorExepcion(HttpStatusCode.InternalServerError, new { mensaje = "No se pudo eliminar el comentario" });
            }
Esempio n. 7
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var comentario = new Comentario {
                    ComentarioId    = Guid.NewGuid(),
                    Alumno          = request.Alumno,
                    Puntaje         = request.Puntaje,
                    ComentarioTexto = request.Comentario,
                    CursoId         = request.CursoId,
                    FechaCreacion   = DateTime.UtcNow
                };

                _context.Comentario.Add(comentario);
                var resultado = await _context.SaveChangesAsync();

                if (resultado > 0)
                {
                    return(Unit.Value);
                }

                throw new Exception("No se ha podido insertar el comentario");
            }
Esempio n. 8
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var comentario = new Comentario
                {
                    ComentarioId    = Guid.NewGuid(),
                    Alumno          = request.Alumno,
                    ComentarioTexto = request.ComentarioTexto,
                    Puntaje         = request.Puntaje,
                    CursoId         = request.CursoId,
                    FechaCreacion   = DateTime.UtcNow
                };

                context.Comentario.Add(comentario);

                var valor = await context.SaveChangesAsync();

                if (valor > 0)
                {
                    return(Unit.Value);
                }

                throw new ManejadorExepcion(HttpStatusCode.InternalServerError, new { mensaje = "No se pudo Agregar el Comentario" });
            }
Esempio n. 9
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var curso = await context.Curso.FindAsync(request.CursoId);

                if (curso == null)
                {
                    throw new ManejadorExepcion(HttpStatusCode.NotFound, new { mensaje = "No se encontro el curso" });
                }


                curso.Titulo           = request.Titulo ?? curso.Titulo;
                curso.Descripcion      = request.Descripcion ?? curso.Descripcion;
                curso.FechaPublicacion = request.FechaPublicacion ?? curso.FechaPublicacion;

                var precio = this.context.Precio.Where(x => x.CursoId == curso.CursoId).FirstOrDefault();

                if (precio != null)
                {
                    precio.PrecioActual = request.Precio ?? precio.PrecioActual;
                    precio.Promocion    = request.PrecioPromocion ?? precio.Promocion;
                }
                else
                {
                    precio = new Precio
                    {
                        PrecioId     = Guid.NewGuid(),
                        PrecioActual = request.Precio ?? 0,
                        Promocion    = request.PrecioPromocion ?? 0,
                        CursoId      = curso.CursoId
                    };
                    this.context.Precio.Add(precio);
                }

                if (request.ListaInstructor != null)
                {
                    if (request.ListaInstructor.Count > 0)
                    {
                        // Eliminar de la base de datos
                        var instructoresDB = this.context.CursoInstructor.Where(x => x.CursoId == request.CursoId).ToList();
                        foreach (var instructorEliminar in instructoresDB)
                        {
                            this.context.CursoInstructor.Remove(instructorEliminar);
                        }

                        // Agregar los que vienen del cliente
                        foreach (var id in request.ListaInstructor)
                        {
                            var cursoInstructor = new CursoInstructor
                            {
                                CursoId      = request.CursoId,
                                InstructorId = id
                            };
                            this.context.CursoInstructor.Add(cursoInstructor);
                        }
                    }
                }

                //context.Curso.Update(curso);
                var valor = await context.SaveChangesAsync();

                if (valor > 0)
                {
                    return(Unit.Value);
                }

                throw new ManejadorExepcion(HttpStatusCode.InternalServerError, new { mensaje = "No se pudo Editar el Curso" });
            }
Esempio n. 10
0
            public async Task <Unit> Handle(Ejecuta request, CancellationToken cancellationToken)
            {
                var curso = await _context.Curso.FindAsync(request.CursoId);

                if (curso == null)
                {
                    // throw new Exception("No se puede eliminar el curso.");
                    throw new ManejadorExcepcion(HttpStatusCode.NotFound, new { mensaje = "No se encontró el curso" });
                }

                // el operador ?? evalúa el valor de la variable, si NO ha cambiado no se actualiza, se mantiene curso.Titulo
                // vendría siendo algo así, si request.Titulo es nulo mantén el valor que tenía en la tabla
                curso.Titulo           = request.Titulo ?? curso.Titulo;
                curso.Descripcion      = request.Descripcion ?? curso.Descripcion;
                curso.FechaPublicacion = request.FechaPublicacion ?? curso.FechaPublicacion;
                curso.FechaCreacion    = DateTime.UtcNow;

                /* Actualizar precio curso */
                // Encuentra el primer valor que cumple la condición Where con CursoId
                var precioEntidad = _context.Precio.Where(x => x.CursoId == curso.CursoId).FirstOrDefault();

                if (precioEntidad != null)
                {
                    precioEntidad.Promocion    = request.Promocion ?? precioEntidad.Promocion;
                    precioEntidad.PrecioActual = request.Precio ?? precioEntidad.Promocion;
                }
                else
                {
                    precioEntidad = new Precio {
                        PrecioId     = Guid.NewGuid(),
                        PrecioActual = request.Precio ?? 0,
                        Promocion    = request.Promocion ?? 0,
                        CursoId      = curso.CursoId
                    };
                    await _context.Precio.AddAsync(precioEntidad);
                }

                if (request.ListaInstructor != null)
                {
                    if (request.ListaInstructor.Count > 0)
                    {
                        /* 1º eliminar instructores actuales del curso en la BD*/
                        var InstructoresBD = _context.CursoInstructor.Where(x => x.CursoId == request.CursoId).ToList();
                        foreach (var instructorEliminar in InstructoresBD)
                        {
                            _context.CursoInstructor.Remove(instructorEliminar);
                        }
                        /* fin proc. eliminar instructores*/

                        /* 2º adjuntar los instructores que provienen del cliente*/
                        foreach (var ids in request.ListaInstructor)
                        {
                            var nuevoInstructor = new CursoInstructor {
                                CursoId      = request.CursoId,
                                InstructorId = ids
                            };
                            _context.CursoInstructor.Add(nuevoInstructor);
                        }
                        /* Fin del proc. 2º */
                    }
                }

                var resultado = await _context.SaveChangesAsync();

                if (resultado > 0)
                {
                    return(Unit.Value);
                }

                throw new Exception("No se guardaron los cambio en el curso.");
            }