public async Task CrearActorSinImagen()
{
var nombreBD = Guid.NewGuid().ToString();
var contexto = ConstruirContext(nombreBD);
var mapper = ConfigurarAutoMapper();
var actor = new ActorCreacionDTO()
{
Nombre = "Ricardo", FechaNacimiento = DateTime.Now
};
var mock = new Mock <IAlmacenadorArchivos>();
mock.Setup(x => x.GuardarArchivo(null, null, null, null)).Returns(Task.FromResult("url"));
var controller = new ActoresController(contexto, mapper, mock.Object);
var respuesta = await controller.Post(actor);
var resultado = respuesta as CreatedAtRouteResult;
Assert.AreEqual(201, resultado.StatusCode);
var contexto2 = ConstruirContext(nombreBD);
var listado = await contexto2.Actores.ToListAsync();
Assert.AreEqual(1, listado.Count);
Assert.IsNull(listado[0].Foto);
Assert.AreEqual(0, mock.Invocations.Count);
}
public async Task <ActionResult> Creacion([FromForm] ActorCreacionDTO actorCreacion)
{
var entidad = _mapper.Map <Actor>(actorCreacion);
if (actorCreacion.Foto != null)
{
using (var memoryString = new MemoryStream())
{
await actorCreacion.Foto.CopyToAsync(memoryString);
var contenido = memoryString.ToArray();
var extension = Path.GetExtension(actorCreacion.Foto.FileName);
entidad.Foto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, actorCreacion.Foto.ContentType);
}
}
_context.Add(entidad);
await _context.SaveChangesAsync();
var dto = _mapper.Map <ActorDTO>(entidad);
return(new CreatedAtRouteResult("obtenerActor", new { id = entidad.Id }, dto));
}
//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 actorCreacion)
{
return(await Put <ActorCreacionDTO, Actor>(id, actorCreacion));
//solo se actualiza lo necesario
//var actorDB = await _context.Actores.FirstOrDefaultAsync(x => x.Id == id);
//if (actorDB == null)
//{
// return NotFound();
//}
//actorDB = _mapper.Map(actorCreacion,actorDB);
//if (actorCreacion.Foto != null)
//{
// using (var memoryString = new MemoryStream())
// {
// await actorCreacion.Foto.CopyToAsync(memoryString);
// var contenido = memoryString.ToArray();
// var extension = Path.GetExtension(actorCreacion.Foto.FileName);
// actorDB.Foto = await almacenadorArchivos.EditarArchivo(contenido, extension, contenedor,actorDB.Foto, actorCreacion.Foto.ContentType);
// }
//}
//await _context.SaveChangesAsync();
//return NoContent();
}
public async Task <ActionResult> Put(int id, [FromForm] ActorCreacionDTO actorCreacionDTO)
{
//actualizar solo campos que han sido modificados
var actorDB = await this.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 this.almacenardorArchivos.EditarArchivo(contenido, extension, contenedor,
actorDB.foto, actorCreacionDTO.foto.ContentType);
}
}
//this.context.Entry(entidad).State = EntityState.Modified;
await this.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> 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> Post([FromBody] ActorCreacionDTO actorCreacionDTO)
{
var actor = _mapper.Map <Actor>(actorCreacionDTO);
_dbContext.Add(actor);
await _dbContext.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;
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO actorCreacionDTO)
{
var entidad = mapper.Map <Actor>(actorCreacionDTO);
context.Add(entidad);
await context.SaveChangesAsync();
var dto = mapper.Map <ActorDTO>(entidad);
return(new CreatedAtRouteResult("obtenerActor", new { id = entidad.Id }, dto));
}
[HttpPost] //aquí utilizamos FromForm para poder enviar la foto del actor
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO actorCreacionDTO)
{
var actor = _mapper.Map <Actor>(actorCreacionDTO);
if (actorCreacionDTO.Foto != null)
{
actor.Foto = await _almacenadorArchivos.GuardarArchivo(contenedor, actorCreacionDTO.Foto);
}
_context.Add(actor);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO actorCreacionDTO) // cambiamos FromBody por FromForm para enviar la foto
{
var actor = mapper.Map <Actor>(actorCreacionDTO);
if (actorCreacionDTO.Foto != null)
{
actor.Foto = await almacenadorArchivos.GuardarArchivo(contenedor, actorCreacionDTO.Foto); // guardar goto
}
context.Add(actor);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO actorCreacionDTO) //Usamos [FromForm] para poder enviar la foto
{
var actor = mapper.Map <Actor>(actorCreacionDTO);
if (actorCreacionDTO.Foto != null)
{
// Guardamos la foto en la nube y guardamos la url devuelta por el metodo en actor.Foto
actor.Foto = await almacenadorArchivos.GuardarArchivo(contenedor, actorCreacionDTO.Foto);
}
context.Add(actor);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO nuevoActor)
{
Actor actor;
actor = mapper.Map <Actor>(nuevoActor);
if (nuevoActor.Foto != null)
{
actor.Foto = await almacenadorArchivos.GuardarArchivo(CONTENEDOR, nuevoActor.Foto);
}
context.Actores.Add(actor);
await context.SaveChangesAsync();
return(NoContent());
}
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(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> Post([FromForm] ActorCreacionDTO actorCreacionDTO)
{
var actor = mapper.Map <Actor>(actorCreacionDTO);
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);
actor.Foto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor,
actorCreacionDTO.Foto.ContentType);
}
context.Add(actor);
await context.SaveChangesAsync();
var dto = mapper.Map <ActorDTO>(actor);
return(new CreatedAtRouteResult("obtenerActor", new { id = actor.Id }, dto));
}
public async Task CrearActorConImagen()
{
var nombreBD = Guid.NewGuid().ToString();
var contexto = ConstruirContext(nombreBD);
var mapper = ConfigurarAutoMapper();
var content = Encoding.UTF8.GetBytes("imagen de prueba");
var archivo = new FormFile(new MemoryStream(content), 0, content.Length, "Data", "imagen.jpg");
archivo.Headers = new HeaderDictionary();
archivo.ContentType = "image/jpg";
var actor = new ActorCreacionDTO()
{
Nombre = "Nuevo actor",
FechaNacimiento = DateTime.Now,
Foto = archivo
};
var mock = new Mock <IAlmacenadorArchivos>();
mock.Setup(x => x.GuardarArchivo(content, ".jpg", "actores", archivo.ContentType))
.Returns(Task.FromResult("url"));
var controller = new ActoresController(contexto, mapper, mock.Object);
var respuesta = await controller.Post(actor);
var resultado = respuesta as CreatedAtRouteResult;
Assert.AreEqual(201, resultado.StatusCode);
var contexto2 = ConstruirContext(nombreBD);
var listado = await contexto2.Actores.ToListAsync();
Assert.AreEqual(1, listado.Count);
Assert.AreEqual("url", listado[0].Foto);
Assert.AreEqual(1, mock.Invocations.Count);
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDTO actorCreacionDTO)
{
var entidad = this.mapper.Map <Actor>(actorCreacionDTO);
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);
entidad.foto = await this.almacenardorArchivos.GuardarArchivo(contenido, extension, contenedor,
actorCreacionDTO.foto.ContentType);
}
}
this.context.Add(entidad);
await this.context.SaveChangesAsync();
var actorDTO = this.mapper.Map <ActorDTO>(entidad);
return(new CreatedAtRouteResult("obtenerActor", new { id = actorDTO.id }, actorDTO));
}