public Provider EnlistProvider(ProviderInfo providerInfo, Guid practiceId) { var person = Find(providerInfo.PersonNameInfo); var provider = Provider.Create(providerInfo, practiceId); if (null == person) { person = Person.CreateProvider(providerInfo); var newProvider = person.AssignProvider(provider); _personRepository.InsertOrUpdate(person); _personRepository.Save(); _providerRepository.InsertOrUpdate(newProvider); _providerRepository.Save(); return(newProvider); } var personName = PersonName.Create(providerInfo.PersonNameInfo); var updatedNames = person.AssignName(personName); var updateProvider = person.AssignProvider(provider); _personNameRepository.InsertOrUpdate(updatedNames); _personNameRepository.Save(); _providerRepository.InsertOrUpdate(updateProvider); _providerRepository.Save(); return(updateProvider); }
public async Task Create(string firstName, string lastName, int age, int suffixId) { var firstNameResult = Name.Create(firstName); var lastNameResult = Name.Create(lastName); var ageResult = Age.Create(age); Maybe <Suffix> maybeSuffix = Suffix.FromId(suffixId); await Result .Combine(firstNameResult, lastNameResult, ageResult) .Bind(() => PersonName.Create(firstNameResult.Value, lastNameResult.Value, maybeSuffix.Value)) .Bind(personName => Person.Create(personName, ageResult.Value)) .Tap(person => _repository.Save(person)) .Tap(() => _unitOfWork.CommitAsync()) .Tap(() => _logger.LogInformation($"Person was stored to db: {firstName} {lastName}")) .OnFailure(error => _logger.LogError(error)); /* * var firstNameResult = Name.Create(firstName); * var lastNameResult = Name.Create(lastName); * var ageResult = Age.Create(age); * var personName = PersonName.Create(firstNameResult.Value, lastNameResult.Value); * var personResult = Person.Create(personName.Value, ageResult.Value); * * _repository.Save(personResult.Value); * await _unitOfWork.CommitAsync(); */ }
public async Task Rename(int personId, string firstName, string lastName, int suffixId) { var firstNameResult = Name.Create(firstName); var lastNameResult = Name.Create(lastName); Maybe <Suffix> maybeSuffix = Suffix.FromId(suffixId); await Result .Combine(firstNameResult, lastNameResult, maybeSuffix.ToResult("Suffix is null.")) .Bind(() => _repository .GetByIdAsync(personId) .ToResult($"Person was not found for ID: {personId}")) .Bind(person => PersonName .Create(firstNameResult.Value, lastNameResult.Value, maybeSuffix.Value) .Tap(personName => person.Rename(personName))) .Tap(() => _unitOfWork.CommitAsync()) .Tap(() => _logger.LogInformation($"Person was renamed to {maybeSuffix.Value} {firstName} {lastName}")) .OnFailure(error => _logger.LogError(error)); /* * var firstNameResult = Name.Create(firstName); * var lastNameResult = Name.Create(lastName); * var personNameResult = PersonName.Create(firstNameResult.Value, lastNameResult.Value); * * var maybePerson = await _repository.GetById(personId); * maybePerson.Value.Rename(personNameResult.Value); */ }
public async Task ShouldUpdate_EmployeeContactPerson_UsingRepo() { var employee = await _employeeRepo.GetByIdAsync(new Guid("4b900a74-e2d9-4837-b9a4-9e828752716e")); var contact = (from item in employee.ContactPersons() where item.Id.Equals(2) select item).SingleOrDefault(); Assert.Equal("Steve", contact.ContactName.FirstName); Assert.Equal("Harvey", contact.ContactName.LastName); Assert.Equal("972-854-5688", contact.Telephone); employee.UpdateContactPerson ( contact.Id, PersonName.Create("Bubba", "Smith", "C"), PhoneNumber.Create("987-965-1234"), "You have been updated" ); _employeeRepo.Update(employee); await _unitOfWork.Commit(); var result = (from item in employee.ContactPersons() where item.Id.Equals(2) select item).SingleOrDefault(); Assert.Equal("Bubba", result.ContactName.FirstName); Assert.Equal("987-965-1234", result.Telephone); Assert.Equal("You have been updated", result.Notes); }
public User EnlistUser(UserInfo userInfo, Guid practiceId) { var person = Find(userInfo.PersonNameInfo); var user = User.Create(userInfo, practiceId); if (null == person) { person = Person.CreateUser(userInfo); var newUser = person.AssignUser(user); _personRepository.InsertOrUpdate(person); _personRepository.Save(); _userRepository.InsertOrUpdate(newUser); _userRepository.Save(); return(newUser); } var personName = PersonName.Create(userInfo.PersonNameInfo); var updatedNames = person.AssignName(personName); var updateUser = person.AssignUser(user); _personNameRepository.InsertOrUpdate(updatedNames); _personNameRepository.Save(); _userRepository.InsertOrUpdate(updateUser); _userRepository.Save(); return(updateUser); }
public async Task ShouldInsert_ExternalAgentAndEmployee() { Guid id = Guid.NewGuid(); Employee employee = new Employee ( new ExternalAgent(id, AgentType.Employee), SupervisorId.Create(id), PersonName.Create("George", "Orwell", "J"), SSN.Create("623789999"), PhoneNumber.Create("817-987-1234"), MaritalStatus.Create("M"), TaxExemption.Create(5), PayRate.Create(40.00M), StartDate.Create(new DateTime(1998, 12, 2)), IsActive.Create(true) ); await _employeeRepo.AddAsync(employee); await _unitOfWork.Commit(); var employeeResult = await _employeeRepo.Exists(employee.Id); Assert.True(employeeResult); }
private static Nomination LoadSuperStarAwardsNominationFromSurveyExport(Row row, int rowNumber) { var isAnonymousNominator = row[10] != @"Display My Name (Recommended)"; var nominatorName = PersonName.CreateForNominator(row[9], isAnonymousNominator); var nomineeName = PersonName.Create(row[12]); var awardType = AwardType.SuperStar; var nomineeOfficeLocation = OfficeLocation.FindByName(row[14]); var hasContinuouslyImproving = !string.IsNullOrWhiteSpace(row[15]); var hasDrivingInnovation = !string.IsNullOrWhiteSpace(row[16]); var hasDelightingCustomers = !string.IsNullOrWhiteSpace(row[17]); var hasBehavingWithIntegrity = !string.IsNullOrWhiteSpace(row[18]); var hasDeliveringMeaningfulOutcomes = !string.IsNullOrWhiteSpace(row[19]); var hasStreamingGood = !string.IsNullOrWhiteSpace(row[20]); var writeUp = NominationWriteUp.Create(nomineeName, row[21]); var writeUpSummary = NominationWriteUpSummary.NotApplicable; var companyValues = GetCompanyValues(hasContinuouslyImproving, hasDrivingInnovation, hasDelightingCustomers, hasBehavingWithIntegrity, hasDeliveringMeaningfulOutcomes, hasStreamingGood); var nominee = Person.Create(nomineeName, nomineeOfficeLocation, nomineeName.DerivedEmailAddress); var nomination = new Nomination(rowNumber, NomineeVotingIdentifier.Unknown, nominee, awardType, nominatorName, companyValues, writeUp, writeUpSummary); return(nomination); }
public static Person GetPersonWithoutId() { return(new Person( surrogateId: Option.None <string>(), firstName: PersonFirstName.Create("firstname").Value, name: PersonName.Create("name").Value, email: PersonEmail.Create("*****@*****.**").Value)); }
public static Person GetPerson(Option <PersonFirstName> firstName, Option <PersonName> name, Option <PersonEmail> email) { return(new Person( surrogateId: Option.None <string>(), firstName: firstName.ValueOr(PersonFirstName.Create("firstname").Value), name: name.ValueOr(PersonName.Create("name").Value), email: email.Else(Option.None <PersonEmail>()))); }
public static Person ToBusinessObject(this CreatePersonModel model) { return new Person( surrogateId: Option.None<string>(), firstName: PersonFirstName.Create(model.FirstName).Value, name: PersonName.Create(model.Name).Value, email: PersonEmail.Create(model.Email).Value); }
public static Person ToBusiness(this PersonEntity personEntity) { return(new Person( surrogateId: Option.Some(personEntity.Id), firstName: PersonFirstName.Create(personEntity.FirstName).Value, name: PersonName.Create(personEntity.Name).Value, email: PersonEmail.Create(personEntity.Email).Value)); }
public async Task <IActionResult> CreateNewCandidate(CreateNewCandidateRequest request) { var newPersonName = PersonName.Create(request.firstName, request.lastName); var newCandidate = new Candidate(newPersonName); var createdCandidate = await _candidateService.CreateCandidate(newCandidate); return(CreatedAtAction(nameof(GetCandidateById), new { id = createdCandidate.Id }, createdCandidate)); }
public static Result Evaluate(this CreatePersonModel model) { var firstName = PersonFirstName.Create(model.FirstName); var name = PersonName.Create(model.Name); var email = PersonEmail.Create(model.Email); return Result.Combine(firstName, name, email); }
private Person GetDefaultPerson() { return(new Person( Option.None <string>(), firstName: PersonFirstName.Create("firstname").Value, name: PersonName.Create("name").Value, email: PersonEmail.Create("*****@*****.**").Value )); }
internal AwardWinner ToAwardWinner() { var awardType = ValueObjects.AwardType.FindByAwardName(AwardType); var person = Person.Create(PersonName.Create(Name), ValueObjects.OfficeLocation.FindByName(OfficeLocation), ValueObjects.EmailAddress.Create(EmailAddress)); return(new AwardWinner(awardType, person)); }
public void ShouldRaiseError_FirstNameTooLong() { var first = "Joe123456789saaadaadddaaaaaaaaaaaaaeeeeeeessssss"; string last = "Blow"; var mi = "Z"; Action action = () => PersonName.Create(first, last, mi); var caughtException = Assert.Throws <ArgumentOutOfRangeException>(action); Assert.Contains("Maximum length of the first name is 25 characters.", caughtException.Message); }
private void SeedWithFakeData() { var existingCandidates = new List <Candidate> { new Candidate(1, PersonName.Create("Joe", "Biden"), null), new Candidate(2, PersonName.Create("Abraham", "Lincoln"), null), new Candidate(3, PersonName.Create("Richard", "Nixon"), null), }; Candidates.AddRange(existingCandidates); SaveChanges(); }
public void ShouldRaiseError_AddingContactPersonWithNullTelephoneToEmployee() { var employee = GetEmployee(); var name = PersonName.Create("Fidel", "Castro", null); var notes = "You are being tested."; Action action = () => employee.AddContactPerson(1, name, null, notes); var caughtException = Assert.Throws <ArgumentNullException>(action); Assert.Contains("The contact person telephone number is required.", caughtException.Message); }
public void ShouldRaiseError_NullLastName() { var first = "Joe"; string last = null; var mi = "Z"; Action action = () => PersonName.Create(first, last, mi); var caughtException = Assert.Throws <ArgumentNullException>(action); Assert.Equal("A last name is required.", caughtException.ParamName); }
public void ShouldRaiseError_MiddleInitialTooLong() { var first = "Joe"; string last = "Blow"; var mi = "ZZ"; Action action = () => PersonName.Create(first, last, mi); var caughtException = Assert.Throws <ArgumentOutOfRangeException>(action); Assert.Contains("Maximum length of middle initial is 1 character.", caughtException.Message); }
public void EmailCanBeEmpty() { //Init var firstName = Option.Some(PersonFirstName.Create("firstname").Value); var name = Option.Some(PersonName.Create("name").Value); var email = Option.None <PersonEmail>(); //Act var person = GetPerson(firstName, name, email); //Assert Check.That(person.Email.HasValue).IsFalse(); }
public void NameShouldBeTheSameAsConstructorParameter() { //Init var firstName = Option.None <PersonFirstName>(); var name = Option.Some(PersonName.Create("name").Value); var email = Option.None <PersonEmail>(); //Act var person = GetPerson(firstName, name, email); //Assert Check.That <string>(person.Name).Equals("name"); }
public void ShouldAdd_ContactPersonToEmployee() { var employee = GetEmployee(); var name = PersonName.Create("Fidel", "Castro", null); var phone = PhoneNumber.Create("555-555-5555"); var notes = "You are being tested."; employee.AddContactPerson(1, name, phone, notes); var count = employee.ContactPersons().Count; Assert.Equal(1, count); }
public void ShouldReturn_Valid_PersonName_WithNullMiddleInitial() { string first = "Joe"; string last = "Blow"; string mi = null; var result = PersonName.Create(first, last, mi); Assert.IsType <PersonName>(result); Assert.Equal(first, result.FirstName); Assert.Equal(last, result.LastName); Assert.Equal(mi, result.MiddleInitial); }
public void ShouldRaiseError_AddingDuplicateContactPersonToEmployee() { var employee = GetEmployee(); var name = PersonName.Create("Fidel", "Castro", null); var phone = PhoneNumber.Create("555-555-5555"); var notes = "You are being tested."; employee.AddContactPerson(1, name, phone, notes); Action action = () => employee.AddContactPerson(2, name, phone, notes); var caughtException = Assert.Throws <InvalidOperationException>(action); Assert.Contains("We already have this contact person.", caughtException.Message); }
public void FirstNameShouldNotBeNull() { PersonFirstName firstName = null; Action action = () => { new Person( surrogateId: Option.None <string>(), firstName: firstName, name: PersonName.Create("name").Value, email: PersonEmail.Create("*****@*****.**").Value ); }; Check.ThatCode(action).Throws <ArgumentException>(); }
private Result MapCustomer(Maybe <CustomerEntity> customer, CustomerDetailsViewModel viewModel) { if (customer.HasNoValue) { return(Result.Fail(new Dictionary <string, object>() { { nameof(customer.Value), customer.Value } })); } viewModel.FullName = PersonName.Create(customer).Value; viewModel.DateOfBirth = CustomerDateOfBirth.Create(customer.Value.DateOfBirth, viewModel.Configuration?.Format).Value; viewModel.Address = PostalAddress.Create(customer.Value.PostalAddress).Value; viewModel.MobileNumber = customer.Value.MobileNumber; viewModel.HomeNumber = customer.Value.HomeNumber; viewModel.EmailAddress = customer.Value.EmailAddress; return(Result.Ok()); }
public async Task ShouldUpdate_Employee_UsingRepository() { var employee = await _employeeRepo.GetByIdAsync(new Guid("4b900a74-e2d9-4837-b9a4-9e828752716e")); Assert.Equal("Ken", employee.EmployeeName.FirstName); Assert.Equal("Sanchez", employee.EmployeeName.LastName); employee.UpdateEmployeeName(PersonName.Create("Lil", "Wayne", null)); _employeeRepo.Update(employee); await _unitOfWork.Commit(); var updatedEmployee = await _employeeRepo.GetByIdAsync(new Guid("4b900a74-e2d9-4837-b9a4-9e828752716e")); Assert.Equal("Lil", updatedEmployee.EmployeeName.FirstName); Assert.Equal("Wayne", updatedEmployee.EmployeeName.LastName); }
public async Task <IActionResult> AddVoteToElection(AddVoteToElectionRequest request) { var Voter = PersonName.Create(request.firstName, request.lastName); Election election = await _electionService.AddVoteToElection(request.ElectionId, request.CandidateId, Voter); var currentCandidacy = election.Candidacies.First(x => x.Candidate.Id == request.CandidateId); var response = new VoteAddedToElectionResponse { ElectionId = request.ElectionId, CandidateId = request.CandidateId, VoterName = Voter, TotalVotes = currentCandidacy.Ballots.Count() }; return(Ok(response)); }
public async Task ShouldAdd_ContactPersonToEmployee_UsingRepo() { var employee = await _employeeRepo.GetByIdAsync(new Guid("4b900a74-e2d9-4837-b9a4-9e828752716e")); var originalContactCount = employee.ContactPersons().Count; var name = PersonName.Create("Fidel", "Castro", null); var phone = PhoneNumber.Create("555-555-5555"); var notes = "You are being tested."; employee.AddContactPerson(0, name, phone, notes); _employeeRepo.Update(employee); await _unitOfWork.Commit(); var count = employee.ContactPersons().Count; Assert.Equal(originalContactCount + 1, count); }