public async Task <ActionResult> AddPersonToTree(Guid id, [FromBody] PersonCreationDto person)
        {
            var tree = await _ctx.Trees.FindAsync(id);

            if (tree == null)
            {
                return(BadRequest());
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            var mappedPerson = _mapper.Map <Person>(person);

            mappedPerson.Tree = tree;
            await _ctx.Persons.AddAsync(mappedPerson);

            await _ctx.SaveChangesAsync();

            var creationResult = _mapper.Map <PersonDto>(mappedPerson);

            return(Ok(new { Id = creationResult.Id }));
        }
        public async Task <ActionResult> Post([FromForm] PersonCreationDto personCreationDto)
        {
            Person person = _mapper.Map <Person>(personCreationDto);
            string dbpath = "";

            if (personCreationDto.Picture != null)
            {
                if (FileHelper.CheckIfImageFile(personCreationDto.Picture))
                {
                    dbpath = await FileHelper.WriteFile(personCreationDto.Picture);
                }
                else
                {
                    return(BadRequest(new { message = "Invalid file extension" }));
                }
            }
            person.Name        = personCreationDto.Name;
            person.Biography   = personCreationDto.Biography;
            person.DateOfBirth = personCreationDto.DateOfBirth;
            person.Picture     = dbpath;
            _context.Persons.Add(person);
            await _context.SaveChangesAsync();

            PersonDto personDto = _mapper.Map <PersonDto>(person);

            return(new CreatedAtRouteResult("GetPerson", new Person {
                Id = person.Id
            }, personDto));
        }
        public async Task <ActionResult> UpdatePerson(int id, [FromForm] PersonCreationDto personCreationDto)
        {
            var personDb = await _context.Persons.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id);

            if (personDb == null)
            {
                return(NotFound());
            }
            else
            {
                if (personCreationDto.Picture != null)
                {
                    FileHelper.DeleteFile(personDb.Picture);
                    personDb.Picture = await FileHelper.WriteFile(personCreationDto.Picture);
                }
                Person person = _mapper.Map <Person>(personCreationDto);
                person.Id      = id;
                person.Picture = personDb.Picture;
                _context.Entry(person).State = EntityState.Modified;
                await _context.SaveChangesAsync();

                PersonDto personDto = _mapper.Map <PersonDto>(person);
                return(new CreatedAtRouteResult("GetPerson", new Person {
                    Id = person.Id
                }, personDto));
            }
        }
        public async Task <ActionResult> UpdatePerson(Guid id, [FromBody] PersonCreationDto personUpdated)
        {
            var person = await _ctx.Persons.Where(p => p.Id == id).Include(d => d.Details).SingleOrDefaultAsync();

            if (person == null)
            {
                return(NotFound());
            }

            if (!personUpdated.Name.IsNullOrEmpty())
            {
                person.Details.Name = personUpdated.Name;
            }
            if (!personUpdated.Surname.IsNullOrEmpty())
            {
                person.Details.Surname = personUpdated.Name;
            }

            _ctx.Update(person);
            await _ctx.SaveChangesAsync();

            return(Ok(_mapper.Map <PersonDto>(person)));
        }