public GetPersonDTO CreatePerson(CreatePersonDTO createPersonDTO) { var person = _mapper.Map <Person>(createPersonDTO); _personService.CreatePerson(person); return(_mapper.Map <GetPersonDTO>(person)); }
public Person Create(CreatePersonDTO createModel) { var sql = @" INSERT INTO Person(FirstName, LastName, DateOfBirth, ImageFileName) VALUES(@FirstName, @LastName, @DateOfBirth, @ImageFileName); SELECT @@IDENTITY"; using (var sqlConnection = new SqlConnection(this.connectionString)) { sqlConnection.Open(); using (var sqlCmd = new SqlCommand(sql, sqlConnection)) { sqlCmd.Parameters.AddWithValue("FirstName", createModel.FirstName); sqlCmd.Parameters.AddWithValue("LastName", createModel.LastName); sqlCmd.Parameters.AddWithValue("DateOfBirth", createModel.DateOfBirth); sqlCmd.Parameters.AddWithValue("ImageFileName", createModel.ImageFileName); var nextID = Convert.ToInt32(sqlCmd.ExecuteScalar()); return(new Person() { Id = nextID, FirstName = createModel.FirstName, LastName = createModel.LastName, DateOfBirth = createModel.DateOfBirth, ImageFileName = createModel.ImageFileName }); } } }
public ActionResult CreatePerson(CreatePersonDTO createPersonDTO) { var personFromDTO = _mapper.Map <Person>(createPersonDTO); _PersonService.CreatePerson(personFromDTO); return(Ok()); }
public async Task CreateNewPerson_WithoutPicture_ShouldCreateDBEntry() { // Arrange var databaseName = Guid.NewGuid().ToString(); var testContext = BuildContext(databaseName); var verifyContext = BuildContext(databaseName); var mapper = BuildMapper(); var newPerson = new CreatePersonDTO() { Name = "New Genre", Biography = "abc", DateOfBirth = DateTime.Now }; var fileStorageServiceMock = new Mock <IFileStorageService>(); fileStorageServiceMock .Setup(x => x.SaveFile(It.IsAny <byte[]>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult("url")); var controller = new PeopleController(testContext, mapper, fileStorageServiceMock.Object); // Act var response = await controller.Post(newPerson); var result = response.Result as CreatedAtRouteResult; var dbEntry = verifyContext.Person.Find(1); // Assert Assert.AreEqual(StatusCodes.Status201Created, result.StatusCode); Assert.AreEqual(1, verifyContext.Person.ToList().Count); Assert.IsNull(dbEntry.Picture); }
public async Task <ActionResult> Put(int id, [FromForm] CreatePersonDTO createPersonDTO) { var personDBEntry = await _context.Person.FirstOrDefaultAsync(x => x.Id == id); if (personDBEntry == null) { return(NotFound()); } personDBEntry = _mapper.Map(createPersonDTO, personDBEntry); if (createPersonDTO.Picture != null) { using (var memoryStream = new MemoryStream()) { await createPersonDTO.Picture.CopyToAsync(memoryStream); var content = memoryStream.ToArray(); var extension = Path.GetExtension(createPersonDTO.Picture.FileName); personDBEntry.Picture = await _fileStorageService.EditFile(content, extension, "people", personDBEntry.Picture, createPersonDTO.Picture.ContentType); } } await _context.SaveChangesAsync(); return(NoContent()); }
public DomainStatusCodes UpdatePerson(int personId, CreatePersonDTO personData) { if (!CheckIfPersonExists(personId, out var existingPerson)) { return(DomainStatusCodes.RecordNotFound); } if (CheckIfPersonExistsByPersonalNumber(personData.PersonalNumber, out var existingPerson2) && existingPerson2.Id != personId) { return(DomainStatusCodes.UniqueViolation); } existingPerson.LastName = personData.LastName; existingPerson.PersonalNumber = personData.PersonalNumber; existingPerson.CityId = personData.CityId; existingPerson.Gender = personData.Gender; existingPerson.DateOfBirth = personData.DateOfBirth; existingPerson.FirstName = personData.FirstName; _phoneNumberRepository.RemovePersonsPhoneNumbers(personId); existingPerson.PhoneNumbers = Mapper.Map <ICollection <PhoneNumberEntity> >(personData.PhoneNumbers); _personRepository.Update(existingPerson); Commit(); return(DomainStatusCodes.Success); }
public Person CreatePerson(CreatePersonDTO createPerson) { var person = new Person() { FirstName = createPerson.FirstName, LastName = createPerson.LastName, Sex = createPerson.SexType }; Create(person); return(person); }
public ActionResult CreateNewPerson(CreatePersonDTO newPerson) { var person = new Person { FirstName = newPerson.FirstName, LastName = newPerson.LastName, Password = newPerson.Password, Email = newPerson.Email, DateOfBirth = newPerson.DateOfBirth }; personService.CreatePerson(person); return(Ok()); }
public Person AddPerson(CreatePersonDTO CreateModel) { if (CreateModel == null) { throw new Exception(); } return(this.personsRepository.Add( new Person { FirstName = CreateModel.FirstName, LastName = CreateModel.LastName, DateOfBirth = CreateModel.DateOfBirth })); }
public async Task <IActionResult> PostPerson(CreatePersonDTO person) { var user = _mapper.Map <Person>(person); var result = await _userManager.CreateAsync(user, person.Password); if (result.Succeeded) { var newUser = await _userManager.FindByNameAsync(person.UserName); return(CreatedAtAction("GetPerson", new { id = newUser.Id }, person)); } return(BadRequest("One or more fields invalid")); }
public async Task <ActionResult <Person> > PostPerson(string id, CreatePersonDTO model) { var person = await personRepository.Create(model.Adapt <Person>()); var dynasty = await dynastyRepository.GetById(new Guid(id)); var ageComparison = dynasty.Head.BirthDate.CompareTo(person.BirthDate); if (ageComparison > 0) { dynasty.Head = person; } await dynastyRepository.Update(dynasty); return(CreatedAtAction(nameof(GetTree), new { id = person.Id }, person)); }
public ActionResult Post([FromBody] CreatePersonDTO createPersonDTO) { try { _service.Save(createPersonDTO); return(Ok()); } catch (Exception e) { string errors = e.Message; return(ValidationProblem(new ValidationProblemDetails() { Type = "Model Validation Error", Detail = errors })); } }
public async Task <ActionResult <PersonDTO> > Post(CreatePersonDTO model) { try { Person person = await personService.InsertAsync(_mapper.Map <Person>(model)); if (person is null) { return(BadRequest()); } return(CreatedAtAction(nameof(Get), new { Id = person.Id }, _mapper.Map <PersonDTO>(person))); } catch (Exception ex) { return(BadRequest(_logger.ToLogError(ex))); } }
public Person Create(CreatePersonDTO createModel) { int nextID = InMemoryPersonRepository.personsCollection .Max(p => p.Id) + 1; var newPerson = new Person { Id = nextID, FirstName = createModel.FirstName, LastName = createModel.LastName, DateOfBirth = createModel.DateOfBirth, ImageFileName = createModel.ImageFileName }; InMemoryPersonRepository.personsCollection.Add(newPerson); return(newPerson); }
public async Task CreateNewPerson_WithPicture_ShouldCreateDBEntry() { // Arrange var databaseName = Guid.NewGuid().ToString(); var testContext = BuildContext(databaseName); var verifyContext = BuildContext(databaseName); var mapper = BuildMapper(); var pictureContent = Encoding.UTF8.GetBytes("This is a dummy image"); var file = new FormFile(new MemoryStream(pictureContent), 0, pictureContent.Length, "Data", "test.jpg"); file.Headers = new HeaderDictionary(); file.ContentType = "image/jpg"; var newPerson = new CreatePersonDTO() { Name = "New Genre", Biography = "abc", DateOfBirth = DateTime.Now, Picture = file }; var fileStorageServiceMock = new Mock <IFileStorageService>(); fileStorageServiceMock .Setup(x => x.SaveFile(It.IsAny <byte[]>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult("url")); var controller = new PeopleController(testContext, mapper, fileStorageServiceMock.Object); // Act var response = await controller.Post(newPerson); var result = response.Result as CreatedAtRouteResult; var dbEntry = verifyContext.Person.Find(1); // Assert Assert.AreEqual(StatusCodes.Status201Created, result.StatusCode); Assert.AreEqual(1, verifyContext.Person.ToList().Count); Assert.AreEqual("url", dbEntry.Picture); Assert.AreEqual(1, fileStorageServiceMock.Invocations.Count); }
public async Task <ActionResult> Put(int id, [FromForm] CreatePersonDTO createPersonDTO) { var exists = await context.People.AnyAsync(person => person.Id == id); if (exists) { var updatedDetails = mapper.Map <Person>(createPersonDTO); updatedDetails.Id = id; context.Entry(updatedDetails).State = EntityState.Modified; await context.SaveChangesAsync(); var updatedPerson = mapper.Map <PersonDTO>(updatedDetails); return(new CreatedAtRouteResult("getPerson", new { updatedPerson.Id }, updatedPerson)); } else { return(NoContent()); } }
public Person Create(CreatePersonDTO createModel) { if (createModel == null) { throw new ArgumentNullException(nameof(createModel)); } var newPerson = this.personsRepository.Create(createModel); if (createModel.ImageData != null) { var fileName = this.fileNameGenerator.GetImageFileName(newPerson); var fileExtension = Path.GetExtension(createModel.ImageFileName); this.fileManager.SaveFile(fileName + "." + fileExtension, createModel.ImageData); } return(newPerson); }
public DomainStatusCodes CreatePeron(CreatePersonDTO personData) { if (CheckIfPersonExistsByPersonalNumber(personData.PersonalNumber, out _)) { return(DomainStatusCodes.UniqueViolation); } if (!_cityService.CheckIfCityExists(personData.CityId, out var _)) { return(DomainStatusCodes.RecordNotFound); } var person = Mapper.Map <PersonEntity>(personData); _personRepository.Add(person); Commit(); return(DomainStatusCodes.Success); }
public async Task <ActionResult <PersonDTO> > Add([FromForm] CreatePersonDTO createPerson) { var person = mapper.Map <Person>(createPerson); if (createPerson.Picture != null) { using (var memoryStream = new MemoryStream()) { await createPerson.Picture.CopyToAsync(memoryStream); var content = memoryStream.ToArray(); var extention = Path.GetExtension(createPerson.Picture.FileName); person.Picture = await filesStorageService.SaveFile(content, extention, containerName, createPerson.Picture.ContentType); } } await context.AddAsync(person); await context.SaveChangesAsync(); var personDTO = mapper.Map <PersonDTO>(person); return(new CreatedAtRouteResult("getPerson", new { personDTO.Id }, personDTO)); }
public async Task <IActionResult> Crear([FromBody] CreatePersonDTO model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var email = model.email.ToLower(); if (await _context.Persons.AnyAsync(p => p.email == email)) { return(BadRequest("El email ya existe")); } Person persona = new Person { tipo_persona = model.tipo_persona, nombre = model.nombre, tipo_documento = model.tipo_documento, num_documento = model.num_documento, direccion = model.direccion, telefono = model.telefono, email = model.email.ToLower() }; _context.Persons.Add(persona); try { await _context.SaveChangesAsync(); } catch (Exception ex) { return(BadRequest()); } return(Ok()); }
public Person Create(CreatePersonDTO createModel) { var nextID = this.xmlDocument.Descendants("Person") .Select(xmlElem => int.Parse(xmlElem.Attribute("id").Value)) .Max() + 1; var newPerson = new Person { Id = nextID, FirstName = createModel.FirstName, LastName = createModel.LastName, DateOfBirth = createModel.DateOfBirth, ImageFileName = createModel.ImageFileName }; var personElement = new XElement( "Person", new XAttribute("id", nextID), new XElement("FirstName", newPerson.FirstName), new XElement("LastName", newPerson.LastName), new XElement( "DateOfBirth", new XAttribute("format", "dd-MM-yyyy"), newPerson.DateOfBirth.ToString("dd-MM-yyyy")), new XElement("ImageFileName", newPerson.ImageFileName) ); this.xmlDocument.Root.Add(personElement); using (var stream = new FileStream(this.xmlPath, FileMode.Create)) { this.xmlDocument.Save(stream); } return(newPerson); }
public IActionResult CreatePerson([FromBody] CreatePersonDTO person) { var statusCode = _personService.CreatePeron(person); return(Response(statusCode)); }
public async Task <IActionResult> CreatePerson(CreatePersonDTO request) { var result = await _contactService.CreatePerson(request).ConfigureAwait(false); return(Ok(result)); }
public PersonDTO RegisterPerson(CreatePersonDTO createPerson) { var person = PersonService.CreatePerson(createPerson); return(new PersonDTO(person)); }
public IActionResult UpdatePerson(int personId, [FromBody] CreatePersonDTO person) { var statusCode = _personService.UpdatePerson(personId, person); return(Response(statusCode)); }
public void Save(CreatePersonDTO model) { var person = _mapper.Map <CreateMovieCommand>(model); _bus.SendCommand(person); }