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);
}
