// Beacuse we wil receive an IFoormFile for the picture
// we change [FromBody] binding to [FromForm]
public async Task <ActionResult> Post([FromForm] PersonCreationDTO personCreation)
{
var person = mapper.Map <Person>(personCreation);
if (personCreation.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await personCreation.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(personCreation.Picture.FileName);
person.Picture =
await fileStorageService.SaveFile(content, extension,
containerName, personCreation.Picture.ContentType);
}
}
context.Add(person);
await context.SaveChangesAsync();
var personDTO = mapper.Map <PersonDTO>(person);
return(new CreatedAtRouteResult("GetPersonById", new { personDTO.Id }, personDTO));
}
public async Task <ActionResult> Put(int Id, [FromForm] PersonCreationDTO personCreation)
{
var personFromDb = await context.Persons.FirstOrDefaultAsync(x => x.Id == Id);
if (personFromDb == null)
{
return(NotFound());
}
personFromDb = mapper.Map(personCreation, personFromDb);
if (personCreation.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await personCreation.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(personCreation.Picture.FileName);
personFromDb.Picture =
await fileStorageService.EditFile(content, extension, containerName,
personFromDb.Picture,
personCreation.Picture.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] PersonCreationDTO personCreationDTO)
{
var personDB = await _context.People.FirstOrDefaultAsync(x => x.Id == id);
if (personDB == null)
{
return(NotFound());
}
personDB = _mapper.Map(personCreationDTO, personDB);
if (personCreationDTO.Picture != null)
{
using (var memeoryStream = new MemoryStream())
{
await personCreationDTO.Picture.CopyToAsync(memeoryStream);
var content = memeoryStream.ToArray();
var extention = Path.GetExtension(personCreationDTO.Picture.FileName); //.Split(".")[1];
personDB.Picture =
await _fileStorageService.EditFile(content,
extention,
containerName,
personDB.Picture,
personCreationDTO.Picture.ContentType);
}
}
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task CreatePersonWithoutImage()
{
var databaseName = Guid.NewGuid().ToString();
var context = BuildContext(databaseName);
var mapper = BuildMap();
var newPerson = new PersonCreationDTO()
{
Name = "New Genre", Biography = "abc", DateOfBirth = DateTime.Now
};
var mock = new Mock <IFileStorageService>();
mock.Setup(x => x.SaveFile(null, null, null, null))
.Returns(Task.FromResult("url"));
var controller = new PeopleController(context, mapper, mock.Object);
var response = await controller.Post(newPerson);
var result = response as CreatedAtRouteResult;
Assert.AreEqual(201, result.StatusCode);
var context2 = BuildContext(databaseName);
var list = await context2.People.ToListAsync();
Assert.AreEqual(1, list.Count);
Assert.IsNull(list[0].Picture);
Assert.AreEqual(0, mock.Invocations.Count);
}
public async Task <ActionResult <PersonDTO> > Put(int id, [FromForm] PersonCreationDTO personCreationDTO)
{
var personDB = await context.Persons.FirstOrDefaultAsync(x => x.Id == id);
if (personDB == null)
{
return(NoContent());
}
personDB = mapper.Map(personCreationDTO, personDB); //So only updated properties in will be updated inside personDB
if (personCreationDTO.Picture != null)
{
using (var memorystream = new MemoryStream())
{
await personCreationDTO.Picture.CopyToAsync(memorystream);
var content = memorystream.ToArray();
var extension = Path.GetExtension(personCreationDTO.Picture.FileName);
personDB.Picture =
await fileStorageService.EditFile(content, extension, containerName, personDB.Picture, personCreationDTO.Picture.ContentType);
}
}
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] PersonCreationDTO personCreation)
{
var person = mapper.Map <Person>(personCreation);
if (personCreation.Picture != null)
{
//Representing file as byte array
using (var memoryStream = new MemoryStream())
{
await personCreation.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
//var extension = personCreation.Picture.FileName.Split(".")[1];
var extension = Path.GetExtension(personCreation.Picture.FileName);
person.Picture =
await fileStorageService.SaveFile(content, extension, containerName, personCreation.Picture.ContentType);
}
}
context.Add(person);
await context.SaveChangesAsync();
var personDTO = mapper.Map <PersonDTO>(person);
//Return location of created resource: route name to access tne newly created resource,
//route values of action with such route name and created object itself
return(new CreatedAtRouteResult("getPerson", new { person.Id }, personDTO));
}
public async Task <ActionResult> Post([FromBody] PersonCreationDTO personCreationDTO)
{
var person = mapper.Map <Person>(personCreationDTO);
context.Add(person);
await context.SaveChangesAsync();
var personDTO = mapper.Map <PersonDTO>(person);
return(CreatedAtRoute("GetPerson", new { id = person.Id }, personDTO));
}
public async Task <ActionResult> Post([FromForm] PersonCreationDTO personCreation)
{
var person = _mapper.Map <Person>(personCreation);
_db.Add(person);
await _db.SaveChangesAsync();
var persondto = _mapper.Map <PersonDTO>(person);
return(new CreatedAtRouteResult("GetPerson", new { Id = person.Id }, persondto));
}
public async Task <ActionResult> Put(int id, [FromForm] PersonCreationDTO personCreationDTO)
{
var result = await _peopleService.UpdatePersonAsync(id, personCreationDTO);
if (result == -1)
{
return(NotFound());
}
else if (result == 0)
{
return(BadRequest("Failed to save changes."));
}
return(NoContent());
}
private async Task <List <Category> > ListCategories(PersonCreationDTO personCreationDTO)
{
if (personCreationDTO.CategoriesId == null)
{
return(null);
}
var result = new List <Category>();
var categories = await _dbContext.Categories.ToListAsync();
foreach (var id in personCreationDTO.CategoriesId)
{
result.Add(categories.FirstOrDefault(x => x.Id == id));
}
return(result);
}
public async Task <int> UpdatePersonAsync(int id, PersonCreationDTO personCreationDTO)
{
var personDb = await _dbContext.People.Include(x => x.Categories)
.Include(x => x.Country)
.FirstOrDefaultAsync(p => p.Id == id);
if (personDb == null)
{
_logger.LogWarn($"Person with ID {id} was not found");
return(-1);
}
personDb = _mapper.Map(personCreationDTO, personDb);
personDb.Categories = await ListCategories(personCreationDTO);
if (personCreationDTO.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await personCreationDTO.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(personCreationDTO.Picture.FileName);
personDb.Picture = await _fileStorageService.EditFile(content,
extension,
_containerName,
personDb.Picture,
personCreationDTO.Picture.ContentType);
}
}
try
{
await this.SaveChangesAsync();
_logger.LogInfo($"Person with ID {id} was updated successfully");
return(1);
}
catch (Exception ex)
{
_logger.LogWarn($"Failed to update person with ID {id}. Exception: {ex}");
return(0);
}
}
public async Task CreatePersonWithImage()
{
var databaseName = Guid.NewGuid().ToString();
var context = BuildContext(databaseName);
var mapper = BuildMap();
var content = Encoding.UTF8.GetBytes("This is a dummy image");
var file = new FormFile(new MemoryStream(content), 0, content.Length, "Data", "dummy.jpg");
file.Headers = new HeaderDictionary();
file.ContentType = "image/jpg";
var newPerson = new PersonCreationDTO()
{
Name = "New Person",
Biography = "abc",
DateOfBirth = DateTime.Now,
Picture = file
};
var mock = new Mock <IFileStorageService>();
mock.Setup(x => x.SaveFile(content, ".jpg", "people", file.ContentType))
.Returns(Task.FromResult("url"));
var controller = new PeopleController(context, mapper, mock.Object);
var response = await controller.Post(newPerson);
var result = response as CreatedAtRouteResult;
Assert.AreEqual(201, result.StatusCode);
var context2 = BuildContext(databaseName);
var list = await context2.People.ToListAsync();
Assert.AreEqual(1, list.Count);
Assert.AreEqual("url", list[0].Picture);
Assert.AreEqual(1, mock.Invocations.Count);
}
public async Task <PersonDTO> AddPersonAsync(PersonCreationDTO personCreationDTO)
{
var person = _mapper.Map <Person>(personCreationDTO);
person.Categories = await ListCategories(personCreationDTO);
if (personCreationDTO.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await personCreationDTO.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(personCreationDTO.Picture.FileName);
person.Picture = await _fileStorageService.SaveFile(content,
extension,
_containerName,
personCreationDTO.Picture.ContentType);
}
}
_dbContext.Add(person);
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInfo($"Person \"{personCreationDTO.Name}\" was added successfully.");
}
catch (Exception ex)
{
_logger.LogWarn($"Failed to add person \"{personCreationDTO.Name}\". Exception: {ex}");
}
return(_mapper.Map <PersonDTO>(person));
}
public async Task <ActionResult> Put(int id, [FromBody] PersonCreationDTO personCreationDTO)
{
var personDB = await repository.GetPersonById(id);
if (personDB == null)
{
return(NotFound());
}
personDB = mapper.Map(personCreationDTO, personDB);
if (personCreationDTO.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await personCreationDTO.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(personCreationDTO.Picture.FileName);
personDB.Picture = await fileStorageService.EditFile(content, extension, containterName, personDB.Picture, personCreationDTO.Picture.ContentType);
}
}
await repository.UpdatePerson(personDB);
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] PersonCreationDTO personCreationDTO)
{
var personDTO = await _peopleService.AddPersonAsync(personCreationDTO);
return(new CreatedAtRouteResult("getPerson", new { id = personDTO.Id }, personDTO));
}
