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