public async Task <IActionResult> Create(ActorCreacionDto actorCreacionDTO)
{
var entidad = 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.UrlFoto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor,
actorCreacionDTO.Foto.ContentType);
}
}
if (ModelState.IsValid)
{
context.Add(entidad);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(actorCreacionDTO));
}
public async Task <ActionResult> Post([FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
var pelicula = mapper.Map <Pelicula>(peliculaCreacionDTO);
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);
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, peliculaCreacionDTO.Poster.ContentType);
}
}
AsignarOrdenActores(pelicula);
context.Add(pelicula);
await context.SaveChangesAsync();
var peliculaDTO = mapper.Map <PeliculaDTO>(pelicula);
return(new CreatedAtRouteResult("obtenerPelicula", new { id = pelicula.Id }, peliculaDTO));
}
public async Task <ActionResult <int> > Post(Pelicula pelicula)
{
if (!string.IsNullOrWhiteSpace(pelicula.Poster))
{
var fotoPersona = Convert.FromBase64String(pelicula.Poster);
pelicula.Poster = await almacenadorDeArchivos.GuardarArchivo(fotoPersona, "jpg", "peliculas");
}
if (pelicula.PeliculasActor != null)
{
for (int i = 0; i < pelicula.PeliculasActor.Count; i++)
{
pelicula.PeliculasActor[i].Orden = i + 1;
}
}
context.Add(pelicula);
await context.SaveChangesAsync();
if (pelicula.EnCartelera)
{
await notificacionesService.EnviarNotificacionPeliculaEnCartelera(pelicula);
}
return(pelicula.Id);
}
public async Task <ActionResult> Post([FromForm] ArchivoCreacionDTO archivoCreacionDTO)
{
var archivo = mapper.Map <Archivo>(archivoCreacionDTO);
var nombreArchivo = "";
if (archivoCreacionDTO.Ruta != null)
{
using (var memoryStream = new MemoryStream())
{
await archivoCreacionDTO.Ruta.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(archivoCreacionDTO.Ruta.FileName);
nombreArchivo = $"{Guid.NewGuid()}{extension}";
archivo.Ruta = almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, archivoCreacionDTO.Ruta.ContentType, nombreArchivo).Result;
}
}
context.Add(archivo);
await context.SaveChangesAsync();
var archivoDTO = mapper.Map <ArchivoDTO>(archivo);
if (archivoCreacionDTO.SCADA == true)
{
await procesarExcel(archivo.Id, nombreArchivo, archivo.Fecha);
}
else
{
await procesarExcelComercial(archivo.Id, nombreArchivo, archivo.Fecha);
}
return(new CreatedAtRouteResult("obtenerArchivo", new { id = archivo.Id }, archivoDTO));
}
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> Post([FromForm] ActorCrearDTO actorDto)
{
var entidad = mapper.Map <Actor>(actorDto);
if (actorDto.Foto != null)
{
using (var memoryStream = new MemoryStream())
{
await actorDto.Foto.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(actorDto.Foto.FileName);
entidad.Foto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, actorDto.Foto.ContentType);
}
}
await context.AddAsync(entidad);
await context.SaveChangesAsync();
var actor = mapper.Map <ActorDTO>(entidad);
return(new CreatedAtRouteResult("ObtenerActor", new { id = actor.Id }, actor));
}
public async Task <ActionResult> Post([FromForm] PeliculaCreacionDTO peliculaDto)
{
var entidad = mapper.Map <Pelicula>(peliculaDto);
if (peliculaDto.Poster != null)
{
using (var memmoryStream = new MemoryStream())
{
await peliculaDto.Poster.CopyToAsync(memmoryStream);
var contenido = memmoryStream.ToArray();
var Extension = Path.GetExtension(peliculaDto.Poster.FileName);
entidad.Poster = await almacenador.GuardarArchivo(contenido, Extension, contenedor, peliculaDto.Poster.ContentType);
}
}
AsignarOrdenActor(entidad);
await context.AddAsync(entidad);
await context.SaveChangesAsync();
var pelicula = mapper.Map <PeliculaDetallesDTO>(entidad);
return(new CreatedAtRouteResult("GetPelicula", new { id = entidad.Id }, pelicula));
}
public async Task <ActionResult <int> > Post(Persona persona)
{
if (!string.IsNullOrEmpty(persona.Foto))
{
var fotoPersona = Convert.FromBase64String(persona.Foto);
persona.Foto = await almacenadorArchivos.GuardarArchivo(fotoPersona, ".jpg", contenedor);
}
context.Add(persona);
await context.SaveChangesAsync();
return(persona.Id);
}
public async Task <int> Post(Persona persona)
{
if (!string.IsNullOrWhiteSpace(persona.Foto))
{
var fotoPersona = Convert.FromBase64String(persona.Foto);
persona.Foto = await almacenadorDeArchivos.GuardarArchivo(fotoPersona, "jpg", "personas");
}
context.Add(persona);
await context.SaveChangesAsync();
return(persona.Id);
}
[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 <int> > Post([FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
var pelicula = mapper.Map <Pelicula>(peliculaCreacionDTO);
if (peliculaCreacionDTO.Poster != null)
{
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(contenedor, peliculaCreacionDTO.Poster); // guardar poster
}
EscribirOrdebdeActores(pelicula);
context.Add(pelicula);
await context.SaveChangesAsync();
return(pelicula.Id); //para retornar
}
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> 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 <IActionResult> Edit(int id, PeliculaEdicionDto peliculaEdicionDto)
{
var actor = mapper.Map <Pelicula>(peliculaEdicionDto);
if (id != peliculaEdicionDto.Id)
{
return(NotFound());
}
if (peliculaEdicionDto.FotoFile != null)
{
using (var memoryStream = new MemoryStream())
{
await peliculaEdicionDto.FotoFile.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(peliculaEdicionDto.FotoFile.FileName);
actor.UrlFoto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor,
peliculaEdicionDto.FotoFile.ContentType);
}
}
else
{
actor.UrlFoto = peliculaEdicionDto.UrlFoto;
}
if (ModelState.IsValid)
{
try
{
context.Update(actor);
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PeliculaExists(actor.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(peliculaEdicionDto));
}
public async Task <ActionResult <int> > Post([FromForm] SerieCreacionDTO serieCreacionDTO)
{
var serie = mapper.Map <Serie>(serieCreacionDTO);
if (serieCreacionDTO.Imagen != null)
{
serie.Imagen = await almacenadorArchivos.GuardarArchivo(contenedor, serieCreacionDTO.Imagen);
}
EscribirOrdenActores(serie);
context.Add(serie);
await context.SaveChangesAsync();
return(serie.Id);
}
public async Task <ActionResult> Post([FromForm] PeliculaCreacionDTO peliculaCreacionDTO)
{
var pelicula = mapper.Map <Pelicula>(peliculaCreacionDTO);
if (peliculaCreacionDTO.Poster != null)
{
// Guardamos la foto en la nube y guardamos la url devuelta por el metodo en pelicula.Poster
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(contenedor, peliculaCreacionDTO.Poster);
}
EscribirOrdenActores(pelicula);
context.Add(pelicula);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] PeliculaCreacionDTO peliculaCreacion)
{
Pelicula pelicula;
pelicula = mapper.Map <Pelicula>(peliculaCreacion);
if (peliculaCreacion.Poster != null)
{
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(CONTENEDOR, peliculaCreacion.Poster);
}
OrdenActores(pelicula);
context.Add(pelicula);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <int> > Post(Pelicula pelicula)
{
if (!string.IsNullOrEmpty(pelicula.Poster))
{
var posterPelicula = Convert.FromBase64String(pelicula.Poster);
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(posterPelicula, ".jpg", contenedor);
}
if (pelicula.PeliculaActor != null)
{
for (int i = 0; i < pelicula.PeliculaActor.Count; i++)
{
pelicula.PeliculaActor[i].Orden = i + 1;
}
}
context.Add(pelicula);
await context.SaveChangesAsync();
return(pelicula.Id);
}
public async Task <int> Post(Pelicula pelicula)
{
if (!string.IsNullOrWhiteSpace(pelicula.Poster))
{
var fotoPersona = Convert.FromBase64String(pelicula.Poster);
pelicula.Poster = await almacenadorDeArchivos.GuardarArchivo(fotoPersona, "jpg", "peliculas");
}
if (pelicula.PeliculasActor != null)
{
for (int i = 0; i < pelicula.PeliculasActor.Count; i++)
{
pelicula.PeliculasActor[i].Orden = i + 1;
}
}
context.Add(pelicula);
await context.SaveChangesAsync();
return(pelicula.Id);
}
public async Task <ActionResult> Post([FromForm] LibroCreacionDTO libroCreacionDTO)
{
Libro libro = 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);
libro.Ruta = await almacenador.GuardarArchivo(contenido, extencion, contenedor, libroCreacionDTO.RutaLibro.ContentType);
}
}
context.Add(libro);
await context.SaveChangesAsync();
LibroDTO libroDTO = mapper.Map <LibroDTO>(libro);
return(new CreatedAtRouteResult("obtenerLibro", new { id = libroDTO.Id }, libroDTO));
}
public async Task <ActionResult> Post([FromForm] ActorCreacionDto actorCreacionDTO)
{
var entitie = 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);
entitie.Foto = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, actorCreacionDTO.Foto.ContentType);
}
}
context.Add(entitie);
await context.SaveChangesAsync();
var dto = mapper.Map <ActorDto>(entitie);
return(new CreatedAtRouteResult("getActor", new { id = entitie.Id }, dto));
}
public async Task <ActionResult> Post([FromForm] EmpresaCreacionDTO empresaCreacion)
{
if (User.Identity.IsAuthenticated)
{
var carteraCreacion = new CarteraCreacionDTO();
var cartera = mapper.Map <Cartera>(carteraCreacion);
context.Add(cartera);
await context.SaveChangesAsync();
var empresa = mapper.Map <Empresa>(empresaCreacion);
string email = User.FindFirst(ClaimTypes.Email)?.Value;
var user = await userManager.FindByEmailAsync(email);
empresa.UsuarioId = user.Id.ToString();
if (empresaCreacion.Logo != null)
{
using (var memoryStream = new MemoryStream()){
await empresaCreacion.Logo.CopyToAsync(memoryStream);
var contenido = memoryStream.ToArray();
var extension = Path.GetExtension(empresaCreacion.Logo.FileName);
empresa.Logo = await almacenadorArchivos.GuardarArchivo(contenido, extension, contenedor, empresaCreacion.Logo.ContentType);
}
}
empresa.CarteraId = cartera.Id;
context.Add(empresa);
await context.SaveChangesAsync();
var empresaDTO = mapper.Map <EmpresaDTO>(empresa);
return(new CreatedAtRouteResult("ObtenerEmpresas", new { id = empresa.Id }, empresaDTO));
}
else
{
return(BadRequest("El inicio de sesión expiró"));
}
}
