Пример #1
0
        public async Task <ActionResult <PersonDto> > AddDirector([FromBody] AddPersonDto dto)
        {
            var director = Mapper.Map <AddPersonDto, Person>(dto);

            director.KnownFor = DepartmentEnums.Directing;

            Context.People.Add(director);

            await Context.SaveChangesAsync();

            Logger.LogInformation(LogTemplates.CreatedEntity, nameof(Person), director);

            return(CreatedAtAction(nameof(GetDirector), new { id = director.Id }, Mapper.Map <Person, PersonDto>(director)));
        }
Пример #2
0
        public async Task <ActionResult <PersonDto> > AddActor([FromBody] AddPersonDto dto, CancellationToken token = default)
        {
            var actor = Mapper.Map <AddPersonDto, Person>(dto);

            actor.KnownFor = DepartmentEnums.Acting;

            Context.People.Add(actor);

            await Context.SaveChangesAsync(token);

            Logger.LogInformation(LogTemplates.CreatedEntity, nameof(Person), actor);

            return(CreatedAtAction(nameof(GetActor), new { id = actor.Id }, Mapper.Map <Person, PersonDto>(actor)));
        }
Пример #3
0
        public async Task <ActionResult <Person> > PostPerson([FromBody] AddPersonDto addPersonDto)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var prePerson = _mapper.Map <Person>(addPersonDto);

            _repo.Add(prePerson);
            var savePerson = await _repo.SaveAsync(prePerson);

            var personResponse = _mapper.Map <PersonDto>(savePerson);

            return(StatusCode(201, new { personResponse }));
        }
        public AddUserDto(AddPersonDto dto)
        {
            if (dto == null)
            {
                return;
            }

            var type       = typeof(AddPersonDto);
            var properties = type.GetTypeInfo().DeclaredProperties;

            foreach (var property in properties)
            {
                var value = property.GetValue(dto);
                property.SetValue(this, value);
            }
        }
Пример #5
0
        public async Task <ActionResult <PersonDto> > UpdateDirector(int id, AddPersonDto dto, CancellationToken token = default)
        {
            var director = await Context.People.Where(p => p.KnownFor == DepartmentEnums.Directing).Where(x => x.Id == id).Project <Person, PersonDto>(Mapper).SingleOrDefaultAsync(token);

            if (director == null)
            {
                Logger.LogWarning(LogTemplates.NotFound, nameof(Person), id);
                return(NotFound($"No {nameof(Person)} with Id {id} found in database"));
            }

            director.FullName = dto.FullName;
            director.Bio      = dto.Bio;
            director.BirthDay = dto.BirthDate;
            director.DeathDay = dto.DeathDate;
            director.Image    = dto.Image;

            await Context.SaveChangesAsync(token);

            Logger.LogInformation(LogTemplates.Updated, nameof(Person), director);

            return(Ok(director));
        }
        public Person AddPerson(AddPersonDto addPersonDto)
        {
            var person = _mapper.Map <Person>(addPersonDto);

            return(_personRepository.AddPerson(person));
        }
Пример #7
0
        public IActionResult AddPerson(AddPersonDto addPersonDto)
        {
            var person = _personApplicationService.AddPerson(addPersonDto);

            return(Ok(person));
        }