public async Task Should_Create_New_Person_Async()
{
var johnNash = new CreatePersonDto
{
FirstName = "John",
LastName = "Nash",
Gender = Gender.Male,
BirthDate = new DateTime(1980, 2, 28),
BirthPlace = "USA",
OtherDetails = "Nothing"
};
await _personAppService.CreateAsync(johnNash);
await UsingDbContextAsync(async context =>
{
var foundJohnNash = await context.People.FirstOrDefaultAsync
(
p => p.FirstName == johnNash.FirstName &&
p.LastName == johnNash.LastName &&
p.Gender == johnNash.Gender &&
p.BirthDate == johnNash.BirthDate
);
foundJohnNash.ShouldNotBeNull();
});
}
// Create a Person in db
public void Create(CreatePersonDto model)
{
string sqlInsertPerson = @"INSERT INTO Person (FirstName, LastName, EGN, Height, Weight)
VALUES (@FirstName, @LastName, @EGN, @Height, @Weight)
SELECT CAST(SCOPE_IDENTITY() as int)";
string sqlInsertPersonsCountries = @"INSERT INTO PersonsCountries VALUES(@PersonId,@CountryId)";
Country[] countries = null;
// If Model's countries are not null we deserialize them to an Array of Countries
if (model.Countries != null)
{
countries = JsonConvert.DeserializeObject <Country[]>(model.Countries);
}
using (var connection = new SqlConnection(connectionString))
{
var createdUserId = connection.Query <int>(sqlInsertPerson, new { FirstName = model.FirstName, LastName = model.LastName,
EGN = model.EGN, Height = model.Height, Weight = model.Weight }).Single();
// If countries are not null we add them to the DB
if (countries != null)
{
for (int i = 0; i < countries.Length; i++)
{
connection.Execute(sqlInsertPersonsCountries, new{ PersonId = createdUserId, CountryId = countries[i].Id });
}
}
}
}
public ActionResult <PersonDto> CreatePerson([FromBody] CreatePersonDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userId = HttpContext.User.FindFirst(ClaimTypes.Sid).Value;
var person = _mapper.Map <Person>(dto);
var user = _db.User.GetById(new Guid(userId));
person.UserId = new Guid(userId);
person.CongregationId = null;
person.Assignment = "publisher";
person.Privilege = "publisher";
person.Language = user.Language;
_db.Person.Create(person);
_db.Save();
return(base.Ok(_mapper.Map <PersonDto>(person)));
}
catch (Exception e)
{
_logger.LogError($"ERROR in CreatePerson: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public ActionResult Post([FromBody] CreatePersonDto personDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var personWithoutAddress = _mapper.Map <PersonWithoutAddressDto>(personDto);
var personEntity = _mapper.Map <Person>(personWithoutAddress);
_personRepository.Add(personEntity);
if (!_personRepository.Save())
{
return(StatusCode(500, "An error occured while making the change"));
}
foreach (var address in personDto.Addresses)
{
address.PersonID = personEntity.ID;
var addressEntity = _mapper.Map <Address>(address);
_addressRepository.Create(addressEntity);
if (!_addressRepository.Save())
{
return(StatusCode(500, "An error occured while making the change"));
}
}
return(CreatedAtAction("Post", new { id = personEntity.ID }, personEntity));
}
public async Task CreatePersonAsync_NewPerson_PersonCreated(CreatePersonDto createPersonDto)
{
// Arrange
// Act
await _personServiceSUT.CreatePersonAsync(createPersonDto);
await _unitOfWork.CompleteAsync();
// Assert
var domainPerson = await _context.Persons
.Where(p => !ExistingPersonIDs.Contains(p.ID.Value))
.SingleOrDefaultAsync();
Assert.NotNull(domainPerson);
Assert.NotNull(domainPerson.ID);
Assert.NotEqual(Guid.Empty, domainPerson.ID);
Assert.False(string.IsNullOrWhiteSpace(domainPerson.FirstName));
Assert.False(string.IsNullOrWhiteSpace(domainPerson.LastName));
Assert.All(domainPerson.PhoneNumbers, (phoneNumber) =>
{
Assert.True(phoneNumber.CountryID.HasValue);
Assert.True(phoneNumber.PhoneNumberType.HasValue);
Assert.False(string.IsNullOrWhiteSpace(phoneNumber.Number));
});
Assert.All(domainPerson.Addresses, (address) =>
{
Assert.True(address.CountryID.HasValue);
Assert.True(address.AddressType.HasValue);
Assert.False(string.IsNullOrWhiteSpace(address.FirstLine));
Assert.False(string.IsNullOrWhiteSpace(address.PostCode));
Assert.False(string.IsNullOrWhiteSpace(address.City));
Assert.False(string.IsNullOrWhiteSpace(address.State));
});
}
public void Insert(CreatePersonDto model)
{
var person = new Person(model.Name, model.Age);
_unitOfWork.PersonRepository.Add(person);
_unitOfWork.Commit();
}
public async Task <IActionResult> ExternalAuth([FromBody] ExternalUserDto externalUser)
{
try
{
var userData = await authenticationService.GetUserDataByEmail(externalUser.Email);
if (userData != null)
{
var personalData = await personService.GetPersonalDataByUserId(userData.Id);
var personDataBasic = mapper.Map <PersonBasicDto>(personalData);
return(CustomResponse(await authenticationService.GenerateJwt(userData.Email, personDataBasic)));
}
else
{
var result = await authenticationService.CreateNewExternalUser(externalUser);
if (result.Succeeded)
{
var user = await authenticationService.GetUserDataByEmail(externalUser.Email);
var person = new CreatePersonDto
{
PersonId = Guid.NewGuid(),
FirstName = externalUser.FirstName,
LastName = externalUser.LastName,
CreatedDate = DateTime.Now,
UserId = Guid.Parse(user.Id)
};
if (await personService.CreatePerson(person))
{
var personDataBasic = mapper.Map <PersonBasicDto>(person);
return(CustomResponse(await authenticationService.GenerateJwt(externalUser.Email, personDataBasic)));
}
else
{
var createdUser = await userManager.FindByEmailAsync(externalUser.Email);
await userManager.DeleteAsync(createdUser);
AddProccessError("Falha ao registrar novo usuário");
}
}
foreach (var error in result.Errors)
{
AddProccessError(error.Description);
}
return(CustomResponse());
}
}
catch (Exception ex)
{
return(HandleException(ex.Message));
}
}
public void Should_Create_New_Person()
{
var initialPeopleCount = GetPeopleCount();
var loCelso = new CreatePersonDto
{
FirstName = "Lo",
LastName = "Celso",
Gender = Gender.Male,
BirthDate = new DateTime(1996, 4, 9)
};
_personAppService.Create(loCelso);
UsingDbContext(context =>
{
context.People.Count().ShouldBe(initialPeopleCount + 1);
var foundLoCelso = context.People.FirstOrDefault
(
p => p.FirstName == loCelso.FirstName &&
p.LastName == loCelso.LastName &&
p.Gender == loCelso.Gender &&
p.BirthDate == loCelso.BirthDate
);
foundLoCelso.ShouldNotBeNull();
});
}
public int Create(CreatePersonDto dto)
{
var people = _mapper.Map <Person>(dto);
_dbContext.People.Add(people);
_dbContext.SaveChanges();
return(people.Id);
}
public async Task CreateAsync(CreatePersonDto input)
{
var person = MapToEntity(input);
ThrowExceptionIfPersonExists(person);
await _personRepository.InsertAsync(person);
}
public async Task <IActionResult> CreatePersonAsync([FromBody] CreatePersonDto createPersonDto, CancellationToken cancellationToken)
{
await _personService.CreatePersonAsync(createPersonDto, cancellationToken);
await _unitOfWork.CompleteWithAuditAsync(cancellationToken);
return(Ok());
}
public void Create(CreatePersonDto input)
{
var person = MapToEntity(input);
ThrowExceptionIfPersonExists(person);
_personRepository.Insert(person);
}
public async Task <bool> CreatePerson(CreatePersonDto person)
{
var personData = mapper.Map <Person>(person);
await personRepository.Create(personData);
return(await personRepository.SaveChanges());
}
public async Task <CreatePersonDto> CreatePerson(CreatePersonDto person)
{
var addedItem = await _context.Persons.AddAsync(new Person { Name = person.Name, GroupId = person.GroupId });
_context.SaveChanges();
return(new CreatePersonDto {
PersonId = addedItem.Entity.Id, Name = addedItem.Entity.Name, GroupId = addedItem.Entity.GroupId
});
}
private ActionResult <CreatePersonResponseDto> _CreatePerson(CreatePerson createPerson)
{
var createPersonDto = new CreatePersonDto()
{
DOME_createPerson = new CreatePersonInnerDto()
{
personCivilityId = (int?)createPerson.PersonCivility ?? -1,
personCivilityIdSpecified = createPerson.PersonCivility.HasValue,
personBirthDate = (DateTime?)createPerson.PersonBirthDate ?? DateTime.MinValue.Date,
personBirthDateSpecified = createPerson.PersonBirthDate.HasValue,
personAddressComp1 = createPerson.PersonAddressComp1,
personAddressComp2 = createPerson.PersonAddressComp2,
personBirthName = createPerson.PersonBirthName,
personCedex = createPerson.PersonCedex,
personCityName = createPerson.PersonCityName,
personCityZipCode = createPerson.PersonCityZipCode,
personComment = createPerson.PersonComment,
personEmail1 = createPerson.PersonEmail1,
personEmail2 = createPerson.PersonEmail2,
personFirstName = createPerson.PersonFirstName,
personINSA = createPerson.PersonInsa,
personINSC = createPerson.PersonInsc,
personJob = createPerson.PersonJob,
personLastName = createPerson.PersonLastName,
personLieuDit = createPerson.PersonLieuDit,
personMobilePhoneNumber = createPerson.PersonMobilePhoneNumber,
personNIR = createPerson.PersonNir,
personPhoneNumber = createPerson.PersonPhoneNumber,
personPostBox = createPerson.PersonPostBox,
personRoadName = createPerson.PersonRoadName,
personRoadNumber = createPerson.PersonRoadNumber,
personRoadType = createPerson.PersonRoadType,
personRPPS = createPerson.PersonRpps,
specialCriteria = createPerson.SpecialCriteria,
},
DOME_header = new domeHeaderDto()
{
langue = "fr",
deviceTypeSpecified = true,
deviceType = (int)DeviceType,
dateSpecified = true,
date = AuthentificationHelper.date,
version = AuthentificationHelper.version,
}
};
var createPersonDomeResult = DomeCallSoap.CreatePerson(createPersonDto);
if (createPersonDomeResult.statusId == 0)
{
return(new ActionResult <CreatePersonResponseDto>(true, createPersonDomeResult));
}
return(new ActionResult <CreatePersonResponseDto>(false, createPersonDomeResult, new Message(MessageType.Error, createPersonDomeResult.statusErrorMessage)));
}
public async Task <IActionResult> CreateNewPerson(CreatePersonDto dto)
{
var home = await GetHomeAsync("/home/");
dto.Age += 10;
var abc = await WritePersonAsync("/demo/createperson", dto);
return(Ok(abc));
}
public IActionResult PostPerson([FromBody] CreatePersonDto personDto)
{
var person = _mapper.Map <Person>(personDto);
var createdPerson = _personInteractor.CreatePerson(person);
var createdPersonDto = _mapper.Map <PersonDto>(createdPerson);
return(CreatedAtRoute("GetPerson", new { id = createdPersonDto.Id }, createdPersonDto));
}
public async Task <ActionResult <Person> > EditPerson(int id, CreatePersonDto dto)
{
var personToEdit = _context.Set <Person>().Find(id);
personToEdit.Age = dto.Age;
personToEdit.FirstName = dto.FirstName;
personToEdit.LastName = dto.LastName;
await _context.SaveChangesAsync();
return(Ok(personToEdit));
}
async Task <HttpResponseMessage> WritePersonAsync(string path, CreatePersonDto dto)
{
var baseUrl = HttpContext.Request.Host.Value.IndexOf("localhost") > -1 ? _config.GetValue <string>("HttpUrl:LocalHost") : _config.GetValue <string>("HttpUrl:Demo");
HttpClient client = new HttpClient()
{
BaseAddress = new Uri(baseUrl)
};
HttpContent contentPost = new StringContent(JsonConvert.SerializeObject(dto), Encoding.UTF8, "application/json");
return(await client.PostAsync(path, contentPost));
}
public ActionResult <Person> GetAllPeople(CreatePersonDto dto)
{
var addPerson = new Person
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Age = dto.Age
};
_context.Set <Person>().Add(addPerson);
_context.SaveChanges();
return(Created($"/api/Person/the-id", addPerson));
}
public async Task <IActionResult> CreatePerson([FromBody] CreatePersonDto p)
{
if (p.Email != "")
{
var existemail = await _email.EmailExist(p.Email);
if (existemail)
{
return(BadRequest("Person's email already on the database"));
}
}
if (p.Phone != "")
{
var phoneValid = _phone.ValidPhone(p.Phone);
if (!phoneValid)
{
return(BadRequest("Invalid Phone number"));
}
var existphone = await _phone.PhoneExist(p.Phone);
if (existphone)
{
return(BadRequest("Person's number already on the database"));
}
}
var person = await _person.CreatePerson(p.Name, p.City, p.Notes);
await _email.CreateEmail(person.Id, p.Email);
await _phone.CreatePhone(person.Id, p.Phone, p.Name);
var userEmail = User.FindFirst(System.Security.Claims.ClaimTypes.Email).Value;
await _log.Create(userEmail, p.Phone, p.Email, $"CREATED - {p.Name}");
return(Ok(person.Id));
}
public async Task <Guid> CreatePersonAsync(CreatePersonDto createPersonDto, CancellationToken ct)
{
Person personsEntity = _mapper.Mapper.Map <Person>(createPersonDto);
_uow.Persons.CreatePerson(personsEntity);
if (await _uow.SaveChangesAsync(ct) > 0)
{
return(personsEntity.Id);
}
else
{
return(Guid.Empty);
}
}
public async Task <ActionResult> PostPerson(CreatePersonDto createPersonDto)
{
if (!string.IsNullOrWhiteSpace(createPersonDto.Picture))
{
var personPicture = Convert.FromBase64String(createPersonDto.Picture);
createPersonDto.Picture = await _fileStorageService.SaveFile(personPicture, "jpg", "people");
}
Person person = _mapper.Map <Person>(createPersonDto);
_repo.CreatePerson(person);
_repo.SaveChanges();
return(CreatedAtRoute(nameof(GetPersonById), new { id = person.Id }, person));
}
public async Task <IActionResult> CreatePerson([FromBody] CreatePersonDto person, CancellationToken ct)
{
_logger.LogInformation("called CreatePerson {0}", person.ToString());
var id = await _personService.CreatePersonAsync(person, ct);
if (id == Guid.Empty)
{
return(UnprocessableEntity());
}
else
{
return(CreatedAtRoute("GetPerson",
new { id = id },
person));
}
}
public void Should_Not_Create_New_Person_If_FirstName_Is_Null()
{
var initialPeopleCount = UsingDbContext(context => context.People.Count());
var personWithNullFirstName = new CreatePersonDto
{
LastName = "Doe",
Gender = Gender.Male,
BirthDate = new DateTime(1992, 6, 15),
BirthPlace = "USA",
OtherDetails = "We don't know the first name of this person"
};
Should.Throw <AbpValidationException>(() => _personAppService.Create(personWithNullFirstName));
UsingDbContext(context => context.People.Count().ShouldBe(initialPeopleCount));
}
public void Should_Not_Create_New_Person_If_LastName_Is_Null()
{
var initialPeopleCount = GetPeopleCount();
var personWithNullLastName = new CreatePersonDto
{
FirstName = "John",
Gender = Gender.Male,
BirthDate = new DateTime(1992, 6, 15),
BirthPlace = "USA",
OtherDetails = "We don't know the last name of this person"
};
Should.Throw <AbpValidationException>(() => _personAppService.Create(personWithNullLastName));
GetPeopleCount().ShouldBe(initialPeopleCount);
}
public void Should_Not_Create_New_Person_If_Person_Exist()
{
var initialPeopleCount = UsingDbContext(context => context.People.Count());
var salah = new CreatePersonDto
{
FirstName = "Mohamed",
LastName = "Salah",
Gender = Gender.Male,
BirthDate = new DateTime(1992, 6, 15)
};
Should.Throw <UserFriendlyException>(() => _personAppService.Create(salah))
.Message.ShouldBe("This Person already exists");
UsingDbContext(context => context.People.Count().ShouldBe(initialPeopleCount));
}
public void Should_Not_Create_New_Person_If_BirthPlace_Length_Is_Oversize()
{
var initialPeopleCount = GetPeopleCount();
var oversizedBirthPlace = Strings.GenerateRandomString(Person.MaxBirthPlaceNameLength + 1);
var personWithOversizedBirthPlaceLength = new CreatePersonDto
{
FirstName = "John",
LastName = "Doe",
Gender = Gender.Male,
BirthDate = new DateTime(1992, 6, 15),
BirthPlace = oversizedBirthPlace
};
Should.Throw <AbpValidationException>(() => _personAppService.Create(personWithOversizedBirthPlaceLength));
GetPeopleCount().ShouldBe(initialPeopleCount);
}
public async Task <ServiceResult <Person> > CreateAsync(CreatePersonDto model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (model.UserId <= 0)
{
throw new InvalidUserIdException();
}
var result = new ServiceResult <Person>();
if (model.Title.IsNotNullOrEmpty())
{
return(result.Which(
isValid: false,
withMessage: ErrorText.Person_Title_Required));
}
var existed = await FindByTitleAsync(model.UserId, model.Title);
if (existed != null)
{
result.Result = existed;
return(await Task.FromResult(result));
}
var person = new Person {
CreateDate = _dateService.UtcNow(),
Phone = model.Phone,
TelegramUsername = model.TelegramUsername,
Title = model.Title.ApplyCorrectYeKe()
};
await _repository.InsertAsync(person);
result.Result = person;
return(await Task.FromResult(result));
}
public void Should_Not_Create_New_Person_If_Gender_Value_Is_Invalid()
{
var initialPeopleCount = GetPeopleCount();
var personWithInvalidGenderValue = new CreatePersonDto
{
FirstName = "John",
LastName = "Doe",
BirthDate = new DateTime(1992, 6, 15),
BirthPlace = "USA",
OtherDetails = "We don't know the gender of this person"
};
Should.Throw <AbpValidationException>(() => _personAppService.Create(personWithInvalidGenderValue));
personWithInvalidGenderValue.Gender = (Gender)3; //Value can only be Female = 1 or Male = 2.
Should.Throw <AbpValidationException>(() => _personAppService.Create(personWithInvalidGenderValue));
GetPeopleCount().ShouldBe(initialPeopleCount);
}
