public async Task <IActionResult> Post([FromBody] PersonCreateDto item, CancellationToken ct)
{
try
{
// map dto to model
var toAdd = Mapper.Map <Person>(item);
// create self link
toAdd.SelfLink = $"{Request.Path}";
// add new person to the repository
var data = await _personRepository.AddPerson(toAdd, ct);
// map model to response dto
var result = Mapper.Map <PersonDto>(toAdd);
// return created response
return(Created($"/api/people/{data}", new SuccessResult {
Results = new[] { result }, Status = "Successful"
}));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult <PersonReadDto> CreatePerson(PersonCreateDto newPerson)
{
var personModel = _mapper.Map <Person>(newPerson);
_repository.CreatePerson(personModel);
var personReadDto = _mapper.Map <PersonReadDto>(personModel);
return(Ok(personReadDto));
}
public IActionResult Create([FromBody] PersonCreateDto dto)
{
try
{
return(Create(_service.Create(dto)));
}
catch (Exception)
{
throw;
}
}
public ActionResult <PersonReadDto> CreatePerson(PersonCreateDto personCreateDto)
{
var personModel = _mapper.Map <Person>(personCreateDto);
_repository.CreatePerson(personModel);
_repository.SaveChanges();
var personReadDto = _mapper.Map <PersonReadDto>(personModel);
return(CreatedAtRoute(nameof(GetPersonById), new { Id = personReadDto.Id }, personReadDto));
}
public ActionResult <PersonReadDto> CreatePerson(PersonCreateDto personCreateDto)
{
var personModel = _mapper.Map <Person>(personCreateDto);
_personRepository.CreatePerson(personModel);
_personRepository.SaveChanges();
var personReadDto = _mapper.Map <PersonReadDto>(personModel);
//Look at Microsoft documentation on CreatedAtRoute method
return(CreatedAtRoute(nameof(GetPersonById), new { Id = personReadDto.Personid }, personReadDto));
}
public ActionResult <PersonDto> create(PersonCreateDto person)
{
var model = new Person
{
name = person.name,
dad = _repo.getById(person.dadId),
mom = _repo.getById(person.momId)
};
_repo.create(model);
return(Ok(_mapper.Map <PersonDto>(model)));
}
public Person CreatePerson(PersonCreateDto personCreate)
{
if (personCreate == null)
{
throw new ArgumentNullException(nameof(personCreate));
}
var person = _mapper.Map <Person>(personCreate);
_context.People.Add(person);
_context.SaveChanges();
return(person);
}
public void Chech_Valid_Return_OkResult_CreatePerson()
{
//Arrange
var controller = new PersonsController(_mockRepo.Object, _mapper, _mockLogger.Object);
var person = new PersonCreateDto()
{
Name = "Peter"
};
//Act
var data = controller.CreatePerson(person);
//Assert
Assert.IsInstanceOf <CreatedAtRouteResult>(data.Result);
}
public ActionResult <PersonReadDto> CreatePerson(PersonCreateDto personCreateDto)
{
if (personCreateDto == null)
{
_logger.LogError("Owner object sent from client is null.");
return(BadRequest("Owner object is null"));
}
var parsonModel = _mapper.Map <Person>(personCreateDto);
_repository.CreatePerson(parsonModel);
_repository.SaveChanges();
var personReadDto = _mapper.Map <PersonReadDto>(parsonModel);
return(CreatedAtRoute(nameof(GetPersonById), new { personReadDto.Id }, personReadDto));
}
/// <inheritdoc/>
public Person CreatePerson(PersonCreateDto dto)
{
var now = DateUtil.Now;
var entity = new PersonTableEntity
{
PersonId = Guid.NewGuid(),
PersonCode = dto.PersonCode,
LoginId = dto.LoginId,
Name = dto.Name,
Title = dto.Title,
Description = dto.Description,
Status = dto.Status,
SortNo = dto.SortNo,
CreateTime = now,
UpdateTime = now,
};
using (var tran = new TransactionScope())
{
_personRepository.Create(entity);
foreach (var tag in dto.Tags)
{
_tagRepository.Create(new TagTableEntity
{
TagId = Guid.NewGuid(),
TargetId = entity.PersonId,
Value = tag,
TargetTable = "Person",
CreateTime = now,
});
}
tran.Complete();
}
return(_personQueryService.GetPerson(entity.PersonId));
}
public async Task Should_Create()
{
// Arrange
var createDto = new PersonCreateDto
{
GivenName = "Per",
Surname = "Son",
AboutMe = "This is about me"
};
var expectedDto = new PersonDto
{
GivenName = createDto.GivenName,
Surname = createDto.Surname,
AboutMe = createDto.AboutMe,
CreatedBy = _staff.DisplayName,
CreatedAt = FakeDateTime.UtcNow,
ModifiedAt = null,
ModifiedBy = null,
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.PersonsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.Created);
PersonDto result = await DeserializeResponseMessageAsync <PersonDto>(responseMessage);
result.Should().BeEquivalentTo(expectedDto, opt => opt
.Excluding(dto => dto.Id));
result.Id.Should().NotBeEmpty();
responseMessage.Headers.Location.AbsolutePath.Should().Be($"/{ApiEndpoints.PersonsController.Get(result.Id)}");
}
public async Task <ActionResult <PersonDto> > Post([FromBody] PersonCreateDto createDto)
{
PersonDto createdDto = await _personService.CreateAsync(createDto);
return(CreatedAtAction(nameof(GetById), new { id = createdDto.Id }, createdDto));
}
public ActionResult <Person> CreatePerson(PersonCreateDto personCreate)
{
var person = _repository.CreatePerson(personCreate);
return(CreatedAtRoute(nameof(GetPersonById), new { Id = person.Id }, person));
}
public async Task <ActionResult> RegisterUserAsync(PersonCreateDto userDto)
{
var user = await _authenticationService.RegisterUserAsync(userDto.Login, userDto.Password, userDto.Email);
return(Ok());
}
public Task <int> Create(PersonCreateDto createDto) => _repository.CreateAsync(_mapper.Map <Person>(createDto));
public Task PersonCreatedAsync(PersonCreateDto request)
{
cacheStore.Clear();
return(Task.CompletedTask);
}
public Task PersonCreatedAsync(PersonCreateDto personCreateDto)
{
return(GetAsync("/api/lifeevent/personcreated", personCreateDto));
}
public PersonCreateDto Create(PersonCreateDto dto)
{
_generic.Create(dto.Adapt <Person>());
return(dto);
}
protected override void OnInitialized()
{
createDto = new PersonCreateDto(PersonService);
editContext = new EditContext(createDto);
base.OnInitialized();
}
public Task PersonCreatedAsync([FromQuery] PersonCreateDto request)
{
return(lifeEventService.PersonCreatedAsync(request));
}
