public async Task <ActionResult> Put(int id, [FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
/* Necesitamos hacer los Include() porque vamos a editar en memoria una pelicula y esa actualizacion nesecitamos que agarre
* los cambios realizados en la entidades relacionadas, para así, realizar las actualizaciones adecuadas en dichas tablas relacionadas.
* Ej: si borramos un genero, queremos que efectivamente se borre ese genero de la relacion pelicula-generos.
*/
var pelicula = await context.Peliculas
.Include(x => x.PeliculasActores)
.Include(x => x.PeliculasGeneros)
.Include(x => x.PeliculasCines)
.FirstOrDefaultAsync(x => x.Id == id);
if (pelicula == null)
{
return(NotFound());
}
pelicula = mapper.Map(peliculaCreacionDTO, pelicula);
if (peliculaCreacionDTO.Poster != null)
{
// carpeta IFormFile Ruta: string
pelicula.Poster = await almacenadorArchivos.EditarArchivo(contenedor, peliculaCreacionDTO.Poster, pelicula.Poster);
}
EscribirOrdenActores(pelicula);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
//Porque viene de forma hacemos esto otro para actualizar los datos
var peliculaDB = await context.Peliculas
.Include(x => x.PeliculasActores)
.Include(x => x.PeliculasGeneros)
.FirstOrDefaultAsync(x => x.Id == id);
if (peliculaDB == null)
{
return(NotFound());
}
//Solo los campos que son diferenten entre actorDB y actorCreacionDTO se actualizaran -
//En las configuraciones de mapeo se va ignorar el campo foto, para que no se mapee automaticamente, ya en en actor.Foto es string y actorCreacionDTO.Foto es un IFormFile
peliculaDB = mapper.Map(peliculaCreacionDTO, peliculaDB);
if (peliculaCreacionDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await peliculaCreacionDTO.Poster.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(peliculaCreacionDTO.Poster.FileName);
peliculaDB.Poster = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor, peliculaDB.Poster, peliculaCreacionDTO.Poster.ContentType);
}
}
AsignarOrdenActores(peliculaDB);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
var pelicula = await context.Peliculas
.Include(x => x.PeliculasActores)
.Include(x => x.PeliculasGeneros)
.Include(x => x.PeliculasCines)
.FirstOrDefaultAsync(x => x.Id == id);
if (pelicula == null)
{
return(NotFound());
}
pelicula = mapper.Map(peliculaCreacionDTO, pelicula);
if (peliculaCreacionDTO.Poster != null)
{
pelicula.Poster = await almacenadorArchivos.EditarArchivo(contenedor, peliculaCreacionDTO.Poster, pelicula.Poster);
}
EscribirOrdenActores(pelicula);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(Pelicula pelicula)
{
var peliculaDB = await context.Peliculas.FirstOrDefaultAsync(x => x.Id == pelicula.Id);
if (peliculaDB == null)
{
return(NotFound());
}
peliculaDB = mapper.Map(pelicula, peliculaDB);
if (!string.IsNullOrWhiteSpace(pelicula.Poster))
{
var posterImagen = Convert.FromBase64String(pelicula.Poster);
peliculaDB.Poster = await almacenadorDeArchivos.EditarArchivo(posterImagen,
"jpg", "peliculas", peliculaDB.Poster);
}
await context.Database.ExecuteSqlInterpolatedAsync($"delete from GenerosPeliculas WHERE PeliculaId = {pelicula.Id}; delete from PeliculasActores where PeliculaId = {pelicula.Id}");
if (pelicula.PeliculasActor != null)
{
for (int i = 0; i < pelicula.PeliculasActor.Count; i++)
{
pelicula.PeliculasActor[i].Orden = i + 1;
}
}
peliculaDB.PeliculasActor = pelicula.PeliculasActor;
peliculaDB.GenerosPelicula = pelicula.GenerosPelicula;
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromBody] LibroCreacionDTO libroCreacionDTO)
{
Libro libroBD = await context.Libros.FirstOrDefaultAsync(x => x.Id == id && x.Activo);
if (libroBD == null)
{
return(NotFound());
}
libroBD = mapper.Map <Libro>(libroCreacionDTO);
if (libroCreacionDTO.RutaLibro != null)
{
using (MemoryStream memoryStream = new MemoryStream())
{
await libroCreacionDTO.RutaLibro.CopyToAsync(memoryStream);
byte[] contenido = memoryStream.ToArray();
string extencion = Path.GetExtension(libroCreacionDTO.RutaLibro.FileName);
libroBD.Ruta = await almacenador.EditarArchivo(contenido, extencion, contenedor, libroBD.Ruta, libroCreacionDTO.RutaLibro.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
var peliculaDB = await context.Peliculas
.Include(x => x.PeliculasActores)
.Include(x => x.PeliculasGeneros)
.FirstOrDefaultAsync(x => x.Id == id);
if (peliculaDB == null)
{
return(NotFound());
}
peliculaDB = mapper.Map(peliculaCreacionDTO, peliculaDB);
if (peliculaCreacionDTO.Poster != null)
{
using (var memorystream = new MemoryStream())
{
await peliculaCreacionDTO.Poster.CopyToAsync(memorystream);
var contenido = memorystream.ToArray();
var extension = Path.GetExtension(peliculaCreacionDTO.Poster.FileName);
peliculaDB.Poster = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor,
peliculaDB.Poster, peliculaCreacionDTO.Poster.ContentType);
}
}
AsignarOrdenActores(peliculaDB);
await context.SaveChangesAsync();
return(NoContent());
}
//public async Task<ActionResult> Put(int id, [FromBody] ActorCreacionDTO actorCreacionDTO)
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
//var entidad = mapper.Map<Actor>(actorCreacionDTO);
//entidad.Id = id;
//context.Entry(entidad).State = EntityState.Modified;
var actorDB = await context.Actores.FirstOrDefaultAsync(x => x.Id == id);
if (actorDB == null)
{
return(NotFound());
}
actorDB = mapper.Map(actorCreacionDTO, actorDB);
if (actorCreacionDTO.Foto != null)
{
using (var memoryStream = new MemoryStream())
{
await actorCreacionDTO.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorCreacionDTO.Foto.FileName);
actorDB.Foto = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor, actorDB.Foto, actorCreacionDTO.Foto.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
//var entidad = mapper.Map<Actor>(actorCreacionDTO);
//entidad.Id = id;
//context.Entry(entidad).State = EntityState.Modified;
//Porque viene de forma hacemos esto otro para actualizar los datos
var actorDB = await context.Actores.FirstOrDefaultAsync(x => x.Id == id);
if (actorDB == null)
{
return(NotFound());
}
//Solo los campos que son diferenten entre actorDB y actorCreacionDTO se actualizaran -
//En las configuraciones de mapeo se va ignorar el campo foto, para que no se mapee automaticamente, ya en en actor.Foto es string y actorCreacionDTO.Foto es un IFormFile
actorDB = mapper.Map(actorCreacionDTO, actorDB);
if (actorCreacionDTO.Foto != null)
{
using (var memoryStream = new MemoryStream())
{
await actorCreacionDTO.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorCreacionDTO.Foto.FileName);
actorDB.Foto = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor, actorDB.Foto, actorCreacionDTO.Foto.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> PutAsync(int id, [FromForm] ActorCreateDto actorUpdateDto)
{
var actorUpdateDb = await context.Actores.FindAsync(id);
if (actorUpdateDb == null)
{
return(NotFound());
}
mapper.Map(actorUpdateDto, actorUpdateDb);
if (actorUpdateDto.Foto != null)
{
using (var memoryStream = new MemoryStream())
{
await actorUpdateDto.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorUpdateDto.Foto.FileName);
actorUpdateDb.Foto = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor, actorUpdateDb.Foto, actorUpdateDto.Foto.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
var actorDb = await _applicationDbContext.Actores.FirstOrDefaultAsync(x => x.Id == id);
if (actorDb == null)
{
return(NotFound());
}
actorDb = _mapper.Map(actorCreacionDTO, actorDb);
if (actorCreacionDTO.Foto != null)
{
using (var memoryStream = new MemoryStream())
{
await actorCreacionDTO.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorCreacionDTO.Foto.FileName);
actorDb.Foto = await _almacenadorArchivos.EditarArchivo(contenido,
extension,
_contenedor,
actorDb.Foto,
actorCreacionDTO.Foto.ContentType);
}
}
await _applicationDbContext.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] SerieCreacionDTO serieCreacionDTO)
{
var serie = await context.Series
.Include(x => x.SeriesActores)
.Include(x => x.SeriesGeneros)
.FirstOrDefaultAsync(x => x.Id == id);
if (serie is null)
{
return(NotFound());
}
serie = mapper.Map(serieCreacionDTO, serie);
if (serieCreacionDTO.Imagen != null)
{
serie.Imagen = await almacenadorArchivos.EditarArchivo(contenedor, serieCreacionDTO.Imagen, serie.Imagen);
}
EscribirOrdenActores(serie);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] AddingUserFoto addingUserFoto)
{
var img = Request.Form.Files.First();
var token = Request.Headers["Authorization"].ToString();
var user = new JwtSecurityTokenHandler().ReadJwtToken(token);
var userId = new Guid(user.Claims.ToArray()[0].Value.ToString());
AppUser userWithFoto = await _userManager.Users.SingleOrDefaultAsync(m => m.Id == userId);
if (userWithFoto.Image == null)
{
using (var memoryStream = new MemoryStream())
{
await img.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(img.FileName);
userWithFoto.Image = await _almacenadorArchivos.GuardarArchivo(content, extension,
container, img.ContentType);
}
await _context.SaveChangesAsync();
if (userWithFoto.Image != null)
{
userWithFoto.PasswordHash = null;
return(Ok(userWithFoto));
}
return(BadRequest());
}
else
{
using (var memoryStream = new MemoryStream())
{
await img.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(img.FileName);
userWithFoto.Image = await _almacenadorArchivos.EditarArchivo(content, extension,
container, userWithFoto.Image, img.ContentType);
}
await _context.SaveChangesAsync();
if (userWithFoto.Image != null)
{
userWithFoto.PasswordHash = null;
return(Ok(userWithFoto));
}
return(BadRequest());
}
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
var actor = await context.Actores.FirstOrDefaultAsync(x => x.Id == id);
if (actor == null)
{
return(NotFound());
}
actor = mapper.Map(actorCreacionDTO, actor);
if (actorCreacionDTO.Foto != null)
{
actor.Foto = await almacenadorArchivos.EditarArchivo(contenedor, actorCreacionDTO.Foto, actor.Foto);
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(Persona persona)
{
var personaDB = await context.Personas.FirstOrDefaultAsync(x => x.Id == persona.Id);
if (personaDB == null)
{
return(NotFound());
}
personaDB = mapper.Map(persona, personaDB);
if (!string.IsNullOrWhiteSpace(persona.Foto))
{
var fotoImagen = Convert.FromBase64String(persona.Foto);
personaDB.Foto = await almacenadorArchivos.EditarArchivo(fotoImagen, "jpg", "personas", personaDB.Foto);
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task Put(Persona persona)
{
var personaDB = await context.Personas.FirstOrDefaultAsync(x => x.Id == persona.Id);
if (personaDB == null)
{
throw new ApplicationException($"Persona {persona.Id} no encontrada");
}
personaDB = mapper.Map(persona, personaDB);
if (!string.IsNullOrWhiteSpace(persona.Foto))
{
var fotoImagen = Convert.FromBase64String(persona.Foto);
personaDB.Foto = await almacenadorDeArchivos.EditarArchivo(fotoImagen,
"jpg", "personas", personaDB.Foto);
}
await context.SaveChangesAsync();
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
/* Esto se comenta, porque el usuario no siempre va a actualizar la foto,
* sino que podria actualizar otros campos
*
*
* var entidad = _mapper.Map<Actor>(actorCreacionDTO);
* entidad.Id = id;
*
* //modificar ese objeto
* _context.Entry(entidad).State = EntityState.Modified;
*/
var actorDB = _context.Actores.FirstOrDefault(x => x.Id == id);
if (actorDB == null)
{
return(NotFound());
}
//vamos a mapear lo que nos mando el usuario con lo que tenemos en la base
//entity framework, solo va a guardar los campos que son distintos
// los campos que son distintos en el mapeo entre los del objeto de la base
//y el dto correspondiente van a ser actualizados
actorDB = _mapper.Map(actorCreacionDTO, actorDB);
using (var memoryStream = new MemoryStream())
{
await actorCreacionDTO.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorCreacionDTO.Foto.FileName);
actorDB.Foto = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor,
actorDB.Foto, actorCreacionDTO.Foto.ContentType);
}
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorModificar)
{
Actor actorEncontrado;
actorEncontrado = await context.Actores.FirstOrDefaultAsync(x => x.Id == id);
if (actorEncontrado == null)
{
return(NotFound());
}
if (actorModificar.Foto != null)
{
actorEncontrado.Foto = await almacenadorArchivos.EditarArchivo(CONTENEDOR, actorModificar.Foto, actorEncontrado.Foto);
}
actorEncontrado = mapper.Map(actorModificar, actorEncontrado);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromBody] EmpresaCreacionDTO empresaActualizacion)
{
var empresaDb = await context.Empresas.FirstOrDefaultAsync(x => x.Id == id);
if (empresaDb == null)
{
return(NotFound());
}
empresaDb = mapper.Map(empresaActualizacion, empresaDb);
if (empresaActualizacion.Logo != null)
{
using (var memoryStream = new MemoryStream()){
await empresaActualizacion.Logo.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(empresaActualizacion.Logo.FileName);
empresaDb.Logo = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor, empresaDb.Logo, empresaActualizacion.Logo.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
