From b164523d0522d85c001c74297c5d321ddf1b8500 Mon Sep 17 00:00:00 2001 From: john Date: Mon, 24 Nov 2025 21:23:14 -0700 Subject: [PATCH] chore: restore to gitea from backup --- .gitignore | 4 + .project | 34 ++ README.md | 161 ++++++ pom.xml | 122 ++++ .../jkgroller/whatsinaname/Application.java | 27 + .../whatsinaname/config/NamesConfig.java | 42 ++ .../converter/IndividualNameConverter.java | 40 ++ .../resource/IndividualNameResource.java | 192 +++++++ .../IndividualNameResourceRepository.java | 99 ++++ .../IndividualNameFormatterService.java | 31 + .../IndividualNameFormatterServiceImpl.java | 532 ++++++++++++++++++ .../to/IndividualNameFormatterRequestTO.java | 87 +++ .../to/IndividualNameFormatterResponseTO.java | 177 ++++++ src/main/resources/application.properties | 10 + src/main/resources/licenseTemplate.txt | 3 + .../IndividualNameFormatterServiceTest.java | 465 +++++++++++++++ 16 files changed, 2026 insertions(+) create mode 100644 .gitignore create mode 100644 .project create mode 100644 README.md create mode 100644 pom.xml create mode 100644 src/main/java/com/jkgroller/whatsinaname/Application.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/config/NamesConfig.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/converter/IndividualNameConverter.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/resource/IndividualNameResource.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/resource/repository/IndividualNameResourceRepository.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterService.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceImpl.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterRequestTO.java create mode 100644 src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterResponseTO.java create mode 100644 src/main/resources/application.properties create mode 100644 src/main/resources/licenseTemplate.txt create mode 100644 src/test/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceTest.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..183893d --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/.classpath + +/target +/.factorypath diff --git a/.project b/.project new file mode 100644 index 0000000..925ec79 --- /dev/null +++ b/.project @@ -0,0 +1,34 @@ + + + WhatsInAName + + + + + + org.eclipse.wst.common.project.facet.core.builder + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.springframework.ide.eclipse.boot.validation.springbootbuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + org.eclipse.wst.common.project.facet.core.nature + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..8f60815 --- /dev/null +++ b/README.md @@ -0,0 +1,161 @@ +# Individual Name Formatter API + +A RESTful API for properly formatting and generating multiple representations of individual names. The API handles capitalization, prefixes, suffixes, middle initials, and professional designations. + +--- + +## Base URL + +``` +http://localhost:8080/v1 +``` + +--- + +## Overview + +This API takes name components (first name, middle name, last name, prefix, suffix) and returns multiple formats, including: + +* FirstName LastName +* FirstName MiddleInitial LastName +* LastName, FirstName +* LastName, FirstName MiddleInitial +* Prefix FirstName LastName +* Prefix FirstName MiddleInitial LastName +* Prefix LastName +* FirstName LastName Suffix +* FirstName MiddleName LastName + +--- + +## Content-Type + +All **POST** requests must include: + +``` +Content-Type: application/json +``` + +--- + +## Endpoints + +### Format Individual Name + +**POST** `/individualNames/format` + +#### Request Body + +```json +{ + "firstName": "john", + "middleName": "kenneth", + "lastName": "doe", + "prefix": "dr", + "suffix": "jr", + "preferredName": "johnny", + "professionalDesignation": "PhD" +} +``` + +#### Example Response + +```json +{ + "firstName": "John", + "middleName": "Kenneth", + "lastName": "Doe", + "prefix": "Dr", + "suffix": "Jr", + "preferredName": "johnny", + "professionalDesignation": "PhD", + "firstNameLastName": "John Doe", + "firstNameMiddleNameLastName": "John Kenneth Doe", + "firstNameLastNameSuffix": "John Doe Jr", + "lastNameFirstName": "Doe, John", + "lastNameFirstNameMiddleInitial": "Doe, John K.", + "prefixFirstNameLastName": "Dr John Doe", + "prefixFirstNameMiddleInitialLastName": "Dr John K. Doe", + "prefixLastName": "Dr Doe" +} +``` + +--- + +## Examples + +#### 1. Simple Name + +Request: + +```json +{ + "firstName": "jane", + "lastName": "smith" +} +``` + +Response: + +```json +{ + "firstNameLastName": "Jane Smith", + "lastNameFirstName": "Smith, Jane" +} +``` + +#### 2. Name with Middle Name and Suffix + +Request: + +```json +{ + "firstName": "robert", + "middleName": "alan", + "lastName": "johnson", + "suffix": "III" +} +``` + +Response: + +```json +{ + "firstNameMiddleNameLastName": "Robert Alan Johnson", + "firstNameLastNameSuffix": "Robert Johnson III", + "lastNameFirstNameMiddleInitial": "Johnson, Robert A." +} +``` + +#### 3. Name with Prefix + +Request: + +```json +{ + "prefix": "ms", + "firstName": "anna", + "lastName": "lee" +} +``` + +Response: + +```json +{ + "prefixFirstNameLastName": "Ms Anna Lee", + "prefixLastName": "Ms Lee" +} +``` + +--- + +## License + +Specify license information here. + +--- + +## Acknowledgments + +Developed by John Groller. Inspired by the need for standardized name formatting in applications. diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..7fd7786 --- /dev/null +++ b/pom.xml @@ -0,0 +1,122 @@ + + 4.0.0 + com.jkgroller + WhatsInAName + 1.0.0-SNAPSHOT + + + John Groller + http://www.jkgroller.com + + + + org.springframework.boot + spring-boot-starter-parent + 2.1.5.RELEASE + + + + + UTF-8 + 1.8 + 2.3 + 1.8 + 1.8 + 2.3 + + + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-starter-test + + + org.apache.commons + commons-lang3 + + + org.mapstruct + mapstruct-jdk8 + 1.3.0.Beta2 + + + io.crnk + crnk-setup-spring-boot2 + 2.6.20180522184741 + + + org.springframework.boot + spring-boot-devtools + true + + + + + + + com.mycila + license-maven-plugin + ${license-maven-plugin.version} + +
src/main/resources/licenseTemplate.txt
+ + src/main/** + src/test/** + + + src/main/resources/** + src/test/resources/** + + + + + + format + + process-sources + + + + + com.mycila + licenses + 1 + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + org.mapstruct + mapstruct-processor + 1.3.0.Beta2 + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + repackage + + + + + + + + \ No newline at end of file diff --git a/src/main/java/com/jkgroller/whatsinaname/Application.java b/src/main/java/com/jkgroller/whatsinaname/Application.java new file mode 100644 index 0000000..6dd1190 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/Application.java @@ -0,0 +1,27 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +package com.jkgroller.whatsinaname; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +/** + * + * @author John Groller (john@grollerfamily.com) + * + * This API attempts to properly format and capitalize components of a + * name. Then, using those values, this API provides several formats of + * the name. + * + */ +@SpringBootApplication +public class Application { + + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/config/NamesConfig.java b/src/main/java/com/jkgroller/whatsinaname/config/NamesConfig.java new file mode 100644 index 0000000..425ed09 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/config/NamesConfig.java @@ -0,0 +1,42 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +package com.jkgroller.whatsinaname.config; + +import java.util.List; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * + * @author john@grollerfamily.com + * + * Configuration class. + * + */ +@Configuration +public class NamesConfig { + + @Value("${names}") + private List names; + + /** + * + * Makes a List of predefined names available in-memory for searching. + * These names can be found in application.properties. This list contains proper + * nouns with multiple capitalizations and non-alphabetic characters. + * + * @return + */ + @Bean + public List names() { + + return names; + + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/converter/IndividualNameConverter.java b/src/main/java/com/jkgroller/whatsinaname/converter/IndividualNameConverter.java new file mode 100644 index 0000000..9d5785f --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/converter/IndividualNameConverter.java @@ -0,0 +1,40 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +/** + * + */ +package com.jkgroller.whatsinaname.converter; + +import org.mapstruct.Mapper; + +import com.jkgroller.whatsinaname.resource.IndividualNameResource; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterRequestTO; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterResponseTO; + +/** + * @author john@grollerfamily.com + * + * @see MapStruct. + * + * Converts domain and resource objects. + * + */ +@Mapper(componentModel = "spring") +public interface IndividualNameConverter { + + IndividualNameFormatterRequestTO convertResourceToFormatterRequest(IndividualNameResource individualNameResource); + + /** + * + * Converts IndividualNameFormatterResponseTO to IndividualNameResource + * + * @param individualNameFormatterResponseTO + * @return + */ + IndividualNameResource convertFormatterResponseToResource( + IndividualNameFormatterResponseTO individualNameFormatterResponseTO); + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/resource/IndividualNameResource.java b/src/main/java/com/jkgroller/whatsinaname/resource/IndividualNameResource.java new file mode 100644 index 0000000..908d826 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/resource/IndividualNameResource.java @@ -0,0 +1,192 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +/** + * + */ +package com.jkgroller.whatsinaname.resource; + +import io.crnk.core.resource.annotations.JsonApiField; +import io.crnk.core.resource.annotations.JsonApiId; +import io.crnk.core.resource.annotations.JsonApiResource; + +/** + * @author john@grollerfamily.com + * + * This is the individualName (/individualNames) resource. Consumers may + * POST prefix, firstName, middleName, lastName, suffix, and + * preferredName, but nothing else. All values are presented in a GET. + * Nothing can be PATCHED, currently. + * + */ +@JsonApiResource(type = "individualName", resourcePath = "individualNames") +public class IndividualNameResource { + + @JsonApiId + private Integer individualNameIdentifier; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String prefix; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String firstName; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String middleName; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String lastName; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String suffix; + + @JsonApiField(readable = true, postable = true, patchable = false) + private String preferredName; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String professionalDesignation; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String prefixLastName; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String lastNameFirstName; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String lastNameFirstNameMiddleInitial; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String prefixFirstNameMiddleInitialLastName; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String firstNameMiddleNameLastName; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String firstNameLastNameSuffix; + + @JsonApiField(readable = true, postable = false, patchable = false) + private String prefixFirstNameLastName; + + public Integer getIndividualNameIdentifier() { + return individualNameIdentifier; + } + + public void setIndividualNameIdentifier(Integer individualNameIdentifier) { + this.individualNameIdentifier = individualNameIdentifier; + } + + public String getPrefix() { + return prefix; + } + + public void setPrefix(String prefix) { + this.prefix = prefix; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getMiddleName() { + return middleName; + } + + public void setMiddleName(String middleName) { + this.middleName = middleName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getSuffix() { + return suffix; + } + + public void setSuffix(String suffix) { + this.suffix = suffix; + } + + public String getPreferredName() { + return preferredName; + } + + public void setPreferredName(String preferredName) { + this.preferredName = preferredName; + } + + public String getProfessionalDesignation() { + return professionalDesignation; + } + + public void setProfessionalDesignation(String professionalDesignation) { + this.professionalDesignation = professionalDesignation; + } + + public String getPrefixLastName() { + return prefixLastName; + } + + public void setPrefixLastName(String prefixLastName) { + this.prefixLastName = prefixLastName; + } + + public String getLastNameFirstName() { + return lastNameFirstName; + } + + public void setLastNameFirstName(String lastNameFirstName) { + this.lastNameFirstName = lastNameFirstName; + } + + public String getLastNameFirstNameMiddleInitial() { + return lastNameFirstNameMiddleInitial; + } + + public void setLastNameFirstNameMiddleInitial(String lastNameFirstNameMiddleInitial) { + this.lastNameFirstNameMiddleInitial = lastNameFirstNameMiddleInitial; + } + + public String getPrefixFirstNameMiddleInitialLastName() { + return prefixFirstNameMiddleInitialLastName; + } + + public void setPrefixFirstNameMiddleInitialLastName(String prefixFirstNameMiddleInitialLastName) { + this.prefixFirstNameMiddleInitialLastName = prefixFirstNameMiddleInitialLastName; + } + + public String getFirstNameMiddleNameLastName() { + return firstNameMiddleNameLastName; + } + + public void setFirstNameMiddleNameLastName(String firstNameMiddleNameLastName) { + this.firstNameMiddleNameLastName = firstNameMiddleNameLastName; + } + + public String getFirstNameLastNameSuffix() { + return firstNameLastNameSuffix; + } + + public void setFirstNameLastNameSuffix(String firstNameLastNameSuffix) { + this.firstNameLastNameSuffix = firstNameLastNameSuffix; + } + + public String getPrefixFirstNameLastName() { + return prefixFirstNameLastName; + } + + public void setPrefixFirstNameLastName(String prefixFirstNameLastName) { + this.prefixFirstNameLastName = prefixFirstNameLastName; + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/resource/repository/IndividualNameResourceRepository.java b/src/main/java/com/jkgroller/whatsinaname/resource/repository/IndividualNameResourceRepository.java new file mode 100644 index 0000000..efbaade --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/resource/repository/IndividualNameResourceRepository.java @@ -0,0 +1,99 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +/** + * + */ +package com.jkgroller.whatsinaname.resource.repository; + +import java.util.Random; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import com.jkgroller.whatsinaname.converter.IndividualNameConverter; +import com.jkgroller.whatsinaname.resource.IndividualNameResource; +import com.jkgroller.whatsinaname.service.IndividualNameFormatterService; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterRequestTO; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterResponseTO; + +import io.crnk.core.exception.MethodNotAllowedException; +import io.crnk.core.queryspec.QuerySpec; +import io.crnk.core.repository.ResourceRepositoryV2; +import io.crnk.core.resource.list.ResourceList; + +/** + * @author john@grollerfamily.com + * + * Resource repository for IndividualName. + * + */ +@Component +public class IndividualNameResourceRepository implements ResourceRepositoryV2 { + + @Autowired + private IndividualNameConverter individualNameConverter; + + @Autowired + private IndividualNameFormatterService individualNameFormatterService; + + @Override + public Class getResourceClass() { + return IndividualNameResource.class; + } + + @Override + public IndividualNameResource findOne(Integer id, QuerySpec querySpec) { + throw new MethodNotAllowedException("Not yet implemented. Planned for future release."); + } + + @Override + public ResourceList findAll(QuerySpec querySpec) { + throw new MethodNotAllowedException("Not yet implemented. Planned for future release."); + } + + @Override + public ResourceList findAll(Iterable ids, QuerySpec querySpec) { + throw new MethodNotAllowedException("Not yet implemented. Planned for future release."); + } + + @Override + public S save(S resource) { + throw new MethodNotAllowedException("Not yet implemented. Planned for future release."); + } + + /** + * + * Creates the IndividualName resource. Currently does not persist the data and + * is returned with a random and meaningless identifier. Future plans may + * include persisting this data simply as a mechanism to gather information and + * update back-end systems. It would have the added benefit of being more + * "RESTful". + * + */ + @SuppressWarnings("unchecked") + @Override + public S create(S resource) { + + IndividualNameFormatterRequestTO individualNameFormatterRequestTO = individualNameConverter + .convertResourceToFormatterRequest(resource); + + IndividualNameFormatterResponseTO individualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + resource = (S) individualNameConverter.convertFormatterResponseToResource(individualNameFormatterResponseTO); + + Random random = new Random(); + resource.setIndividualNameIdentifier(random.nextInt((99999 - 9999) + 1) + 9999); + + return resource; + } + + @Override + public void delete(Integer id) { + throw new MethodNotAllowedException("Not implemented."); + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterService.java b/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterService.java new file mode 100644 index 0000000..f139311 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterService.java @@ -0,0 +1,31 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +/** + * + */ +package com.jkgroller.whatsinaname.service; + +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterRequestTO; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterResponseTO; + +/** + * @author john@grollerfamily.com + * + * Provides many formats of individual names. + */ +public interface IndividualNameFormatterService { + + /** + * + * Provides many formats of an individual's name given name elements. + * + * @param individualNameFormatterRequestTO + * @return + */ + IndividualNameFormatterResponseTO formatIndividualName( + IndividualNameFormatterRequestTO individualNameFormatterRequestTO); + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceImpl.java b/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceImpl.java new file mode 100644 index 0000000..6d499ab --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceImpl.java @@ -0,0 +1,532 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +/** + * + */ +package com.jkgroller.whatsinaname.service; + +import java.util.List; + +import org.apache.commons.lang3.CharUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterRequestTO; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterResponseTO; + +/** + * @author john@grollerfamily.com + * + */ +@Service +public class IndividualNameFormatterServiceImpl implements IndividualNameFormatterService { + + @Autowired + private List names; + + /** + * Comma constant. + */ + private static final String COMMA = ","; + + /** + * Comma space constant. + */ + private static final String COMMA_SPACE = COMMA + StringUtils.SPACE; + + /** + * Period constant. + */ + private static final String PERIOD = "."; + + /** + * Period space constant. + */ + private static final String PERIOD_SPACE = PERIOD + StringUtils.SPACE; + + /** + * + * Orchestrates all formatting and generating of names based on primary name. + * + */ + public IndividualNameFormatterResponseTO formatIndividualName( + IndividualNameFormatterRequestTO individualNameFormatterRequestTO) { + + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO = properlyFormatPrimaryNameElements( + individualNameFormatterRequestTO); + + individualrNameFormatterResponseTO.setPreferredName(individualNameFormatterRequestTO.getPreferredName()); + + individualrNameFormatterResponseTO.setSuffix(individualNameFormatterRequestTO.getSuffix()); + + individualrNameFormatterResponseTO + .setFirstNameLastNameSuffix(generateFirstNameLastNameSuffix(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO.setFirstNameMiddleNameLastName( + generateFirstNameMiddleNameLastName(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO + .setLastNameFirstName(generateLastNameFirstName(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO.setLastNameFirstNameMiddleInitial( + generateLastNameFirstNameMiddleInitial(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO + .setPrefixFirstNameLastName(generatePrefixFirstNameLastName(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO.setPrefixFirstNameMiddleInitialLastName( + generatePrefixFirstNameMiddleInitialLastName(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO + .setPrefixLastName(generatePrefixLastName(individualrNameFormatterResponseTO)); + + individualrNameFormatterResponseTO + .setFirstNameLastName(generateFirstNameLastName(individualrNameFormatterResponseTO)); + + return individualrNameFormatterResponseTO; + + } + + /** + * + * Properly formats primary name elements... the elements from which all other + * name formats are derived: firstName, lastName, middleName, prefix. + * + * @param individualrNameFormatterRequestTO + * @return + */ + private IndividualNameFormatterResponseTO properlyFormatPrimaryNameElements( + IndividualNameFormatterRequestTO individualrNameFormatterRequestTO) { + + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO = new IndividualNameFormatterResponseTO(); + + individualrNameFormatterResponseTO + .setFirstName(properlyFormatNameElement(individualrNameFormatterRequestTO.getFirstName())); + + individualrNameFormatterResponseTO + .setMiddleName(properlyFormatNameElement(individualrNameFormatterRequestTO.getMiddleName())); + + individualrNameFormatterResponseTO + .setLastName(properlyFormatNameElement(individualrNameFormatterRequestTO.getLastName())); + + individualrNameFormatterResponseTO + .setPrefix(properlyFormatNameElement(individualrNameFormatterRequestTO.getPrefix())); + + return individualrNameFormatterResponseTO; + + } + + /** + * + * Orchestrates formattting of the name by first checking for null, then + * checking for matching name in name list. If found, return that matching name. + * If not, properly capitalize name element and return. + * + * @param nameElement + * @return + */ + private String properlyFormatNameElement(String nameElement) { + + if (StringUtils.isBlank(nameElement)) { + return null; + } + + String matchingName = findMatchingName(nameElement); + + if (null != matchingName) { + return matchingName; + } + + return properlyCapitalizeNameElement(nameElement); + + } + + /** + * + * Searches the names collection for a matching name element. + * + * If found, that matching name element is returned. + * + * @param nameElement + * @return + */ + private String findMatchingName(String nameElement) { + + return names.stream().filter(s -> s.equalsIgnoreCase(nameElement)).findFirst().orElse(null); + + } + + /** + * + * If nameElement is not null, changes the value to all lower case, then checks + * the entire string to verify alpha. If it is, return it with the first letter + * capitalized. + * + * If it's not totally alpha things get interesting. + * + * The lowerCase string is converted to a char array, and the very first char + * converted to uppercase, provided it's alpha. Then, the char array is looped + * through, looking for non-alphanumeric values (for names it will likely be + * things like "'", "-", and " ". When non-alpha values are found, the char + * after them is capitalized. If the end of the array contains the non-alpha, it + * does not attempt a case change since that would cause an index out of bounds + * exception. + * + * @param nameElement + * @return + */ + private String properlyCapitalizeNameElement(String nameElement) { + + if (StringUtils.isBlank(nameElement)) { + return null; + } + + String lowerCaseNameElement = nameElement.toLowerCase(); + + if (StringUtils.isAlpha(lowerCaseNameElement)) { + return StringUtils.capitalize(lowerCaseNameElement); + } + + char[] properlyCapitalizedNameElementChars = lowerCaseNameElement.toCharArray(); + + if (CharUtils.isAsciiAlpha(properlyCapitalizedNameElementChars[0])) { + properlyCapitalizedNameElementChars[0] = Character.toUpperCase(properlyCapitalizedNameElementChars[0]); + } + + int properlyCapitalizedNameElementCharsLength = properlyCapitalizedNameElementChars.length; + + for (int i = 0; i < properlyCapitalizedNameElementCharsLength; i++) { + if (!CharUtils.isAsciiAlpha(properlyCapitalizedNameElementChars[i])) { + if ((i + 1) < properlyCapitalizedNameElementCharsLength) { + properlyCapitalizedNameElementChars[i + 1] = Character + .toUpperCase(properlyCapitalizedNameElementChars[i + 1]); + } + } + } + + return new String(properlyCapitalizedNameElementChars); + + } + + /** + * Generates name in the format ,. + * + * Returns null if this can't be calculated. + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateLastNameFirstName(IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isFirstNameLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getLastName()); + stringBuilder.append(COMMA_SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getFirstName()); + + return stringBuilder.toString(); + } + + /** + * + * Generates name in the format + * ,. + * + * Returns null if this can't be calculated. + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateLastNameFirstNameMiddleInitial( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isFirstNameMiddleNameLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(generateLastNameFirstName(individualrNameFormatterResponseTO)); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getMiddleName().substring(0, 1).toUpperCase()); + stringBuilder.append(PERIOD); + + return stringBuilder.toString(); + + } + + /** + * + * Generates name in the format . + * + * Returns null if this can't be calculated. + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateFirstNameLastName(IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getFirstName()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getLastName()); + + return stringBuilder.toString(); + } + + /** + * + * Generates name in the format . + * + * Returns null if this can't be calculated. + * + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generatePrefixFirstNameLastName( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isPrefixFirstNameLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getPrefix()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(generateFirstNameLastName(individualrNameFormatterResponseTO)); + + return stringBuilder.toString(); + + } + + /** + * + * Generates name in the format . + * + * Returns null if this can't be calculated. + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generatePrefixLastName(IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isPrefixLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getPrefix()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getLastName()); + + return stringBuilder.toString(); + } + + /** + * + * Generates name in the format . + * + * Returns null if this can't be calculated. + * + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateFirstNameLastNameSuffix( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isFirstNameLastNameSuffixMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(generateFirstNameLastName(individualrNameFormatterResponseTO)); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getSuffix()); + + return stringBuilder.toString(); + + } + + /** + * + * Generates name in the format . + * + * Returns null if this can't be calculated. + * + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateFirstNameMiddleNameLastName( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isFirstNameMiddleNameLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getFirstName()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getMiddleName()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getLastName()); + + return stringBuilder.toString(); + + } + + /** + * + * Generates name in the format + * . + * + * Returns null if this can't be calculated. + * + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generateFirstNameMiddleInitialLastName( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getFirstName()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getMiddleName().substring(0, 1).toUpperCase()); + stringBuilder.append(PERIOD_SPACE); + stringBuilder.append(individualrNameFormatterResponseTO.getLastName()); + + return stringBuilder.toString(); + } + + /** + * + * Generates name in the format + * . + * + * Returns null if this can't be calculated. + * + * + * @param individualrNameFormatterResponseTO + * @return + */ + private String generatePrefixFirstNameMiddleInitialLastName( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + if (isPrefixFirstNameMiddleNameLastNameMissing(individualrNameFormatterResponseTO)) { + return null; + } + + StringBuilder stringBuilder = new StringBuilder(); + + stringBuilder.append(individualrNameFormatterResponseTO.getPrefix()); + stringBuilder.append(StringUtils.SPACE); + stringBuilder.append(generateFirstNameMiddleInitialLastName(individualrNameFormatterResponseTO)); + + return stringBuilder.toString(); + + } + + /** + * Checks for the existence of first and last names. + * + * True if either are missing. False if both are present. + * + * @return + */ + private boolean isFirstNameLastNameMissing(IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return StringUtils.isBlank(individualrNameFormatterResponseTO.getFirstName()) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getLastName()); + + } + + /** + * Checks for the existence of first, middle, and last names. + * + * True if any are missing. False if all are present. + * + * @return + */ + private boolean isFirstNameMiddleNameLastNameMissing( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return isFirstNameLastNameMissing(individualrNameFormatterResponseTO) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getMiddleName()); + + } + + /** + * Checks for the existence of prefix, first, and last names. + * + * True if any are missing. False if all are present. + * + * @return + */ + private boolean isPrefixFirstNameLastNameMissing( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return isFirstNameLastNameMissing(individualrNameFormatterResponseTO) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getPrefix()); + + } + + /** + * Checks for the existence of prefix, first, middle, and last names. + * + * True if any are missing. False if all are present. + * + * @return + */ + private boolean isPrefixFirstNameMiddleNameLastNameMissing( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return isPrefixFirstNameLastNameMissing(individualrNameFormatterResponseTO) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getMiddleName()); + + } + + /** + * Checks for the existence of first and last names, and suffix. + * + * True if any are missing. False if all are present. + * + * @return + */ + private boolean isFirstNameLastNameSuffixMissing( + IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return isFirstNameLastNameMissing(individualrNameFormatterResponseTO) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getSuffix()); + + } + + /** + * Checks for the existence of prefix and last name. + * + * True if either are missing. False if both are present. + * + * @return + */ + private boolean isPrefixLastNameMissing(IndividualNameFormatterResponseTO individualrNameFormatterResponseTO) { + + return StringUtils.isBlank(individualrNameFormatterResponseTO.getLastName()) + || StringUtils.isBlank(individualrNameFormatterResponseTO.getPrefix()); + + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterRequestTO.java b/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterRequestTO.java new file mode 100644 index 0000000..2e312f4 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterRequestTO.java @@ -0,0 +1,87 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +package com.jkgroller.whatsinaname.service.to; + +/** + * + * @author john@grollerfamily.com + * + * Request object for IndividualNameFormatterService. + * + */ +public class IndividualNameFormatterRequestTO { + + private String prefix; + + private String firstName; + + private String middleName; + + private String lastName; + + private String suffix; + + private String preferredName; + + private String professionalDesignation; + + public String getPrefix() { + return prefix; + } + + public void setPrefix(String prefix) { + this.prefix = prefix; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getMiddleName() { + return middleName; + } + + public void setMiddleName(String middleName) { + this.middleName = middleName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getSuffix() { + return suffix; + } + + public void setSuffix(String suffix) { + this.suffix = suffix; + } + + public String getPreferredName() { + return preferredName; + } + + public void setPreferredName(String preferredName) { + this.preferredName = preferredName; + } + + public String getProfessionalDesignation() { + return professionalDesignation; + } + + public void setProfessionalDesignation(String professionalDesignation) { + this.professionalDesignation = professionalDesignation; + } + +} diff --git a/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterResponseTO.java b/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterResponseTO.java new file mode 100644 index 0000000..bedff28 --- /dev/null +++ b/src/main/java/com/jkgroller/whatsinaname/service/to/IndividualNameFormatterResponseTO.java @@ -0,0 +1,177 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +package com.jkgroller.whatsinaname.service.to; + +/** + * + * @author john@grollerfamily.com + * + * Response object for IndividualNameFormatterService. + * + */ +public class IndividualNameFormatterResponseTO { + + private Integer individualNameIdentifier; + + private String prefix; + + private String firstName; + + private String middleName; + + private String lastName; + + private String suffix; + + private String preferredName; + + private String professionalDesignation; + + private String prefixLastName; + + private String lastNameFirstName; + + private String lastNameFirstNameMiddleInitial; + + private String prefixFirstNameMiddleInitialLastName; + + private String firstNameMiddleNameLastName; + + private String firstNameLastNameSuffix; + + private String prefixFirstNameLastName; + + private String firstNameLastName; + + public String getFirstNameLastName() { + return firstNameLastName; + } + + public void setFirstNameLastName(String firstNameLastName) { + this.firstNameLastName = firstNameLastName; + } + + public String getPrefix() { + return prefix; + } + + public void setPrefix(String prefix) { + this.prefix = prefix; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getMiddleName() { + return middleName; + } + + public void setMiddleName(String middleName) { + this.middleName = middleName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getSuffix() { + return suffix; + } + + public void setSuffix(String suffix) { + this.suffix = suffix; + } + + public String getPreferredName() { + return preferredName; + } + + public void setPreferredName(String preferredName) { + this.preferredName = preferredName; + } + + public String getProfessionalDesignation() { + return professionalDesignation; + } + + public void setProfessionalDesignation(String professionalDesignation) { + this.professionalDesignation = professionalDesignation; + } + + public String getPrefixLastName() { + return prefixLastName; + } + + public void setPrefixLastName(String prefixLastName) { + this.prefixLastName = prefixLastName; + } + + public String getLastNameFirstName() { + return lastNameFirstName; + } + + public void setLastNameFirstName(String lastNameFirstName) { + this.lastNameFirstName = lastNameFirstName; + } + + public String getLastNameFirstNameMiddleInitial() { + return lastNameFirstNameMiddleInitial; + } + + public void setLastNameFirstNameMiddleInitial(String lastNameFirstNameMiddleInitial) { + this.lastNameFirstNameMiddleInitial = lastNameFirstNameMiddleInitial; + } + + public String getPrefixFirstNameMiddleInitialLastName() { + return prefixFirstNameMiddleInitialLastName; + } + + public void setPrefixFirstNameMiddleInitialLastName(String prefixFirstNameMiddleInitialLastName) { + this.prefixFirstNameMiddleInitialLastName = prefixFirstNameMiddleInitialLastName; + } + + public String getFirstNameMiddleNameLastName() { + return firstNameMiddleNameLastName; + } + + public void setFirstNameMiddleNameLastName(String firstNameMiddleNameLastName) { + this.firstNameMiddleNameLastName = firstNameMiddleNameLastName; + } + + public String getFirstNameLastNameSuffix() { + return firstNameLastNameSuffix; + } + + public void setFirstNameLastNameSuffix(String firstNameLastNameSuffix) { + this.firstNameLastNameSuffix = firstNameLastNameSuffix; + } + + public String getPrefixFirstNameLastName() { + return prefixFirstNameLastName; + } + + public void setPrefixFirstNameLastName(String prefixFirstNameLastName) { + this.prefixFirstNameLastName = prefixFirstNameLastName; + } + + public Integer getIndividualNameIdentifier() { + return individualNameIdentifier; + } + + public void setIndividualNameIdentifier(Integer individualNameIdentifier) { + this.individualNameIdentifier = individualNameIdentifier; + } + +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 0000000..9ac1de5 --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1,10 @@ +#=============================== +# = CRNK +# =============================== +crnk.path-prefix=/v1 +crnk.return404-on-null=true + +#=============================== +# = Names (Proof of concept) +# =============================== +names=AbdulAdl,Abdul-Adl,AbdulAhad,Abdul-Ahad,AbdulAlim,AbdulAliyy,AbdulAzim,AbdulAziz,AbdulBadi,AbdulBaith,Abdul-Baith,AbdulBaqi,Abdul-Baqi,AbdulBari,AbdulBarr,Abdul-Barr,AbdulBasir,Abdul-Basir,AbdulBasit,Abdul-Basit,AbdulFattah,Abdul-Fattah,AbdulGhaffar,Abdul-Ghaffar,Abdul-Ghafur,AbdulGhani,Abdul-Ghani,AbdulHadi,Abdul-Hadi,AbdulHafiz,AbdulHakam,Abdul-Hakam,AbdulHakim,Abdul-Hakim,AbdulHalim,Abdul-Halim,AbdulHamid,AbdulHaqq,Abdul-Haqq,AbdulHasib,Abdul-Hasib,Abdul-Hayy,AbdulJabbar,Abdul-Jabbar,AbdulJalil,Abdul-Jalil,AbdulKarim,Abdul-Karim,AbdulKhabir,Abdul-Khabir,Abdul-Khaliq,AbdulLatif,AbdulMajid,Abdul-Majid,AbdulMalik,AbdulMatin,AbdulMubdi,Abdul-Mubdi,AbdulMughni,AbdulMuhaimin,Abdul-Muhaimin,AbdulMuhsi,Abdul-Muhsi,AbdulMuhyi,Abdul-Muhyi,AbdulMuid,Abdul-Muizz,AbdulMujib,Abdul-Mujib,AbdulMumin,Abdul-Mumin,AbdulMuqaddim,Abdul-Muqaddim,AbdulMuqtadir,Abdul-Muqtadir,AbdulMusawwir,AbdulMutaal,Abdul-Mutaal,AbdulNafi,AbdulNasir,Abdul-Nasir,AbdulNasser,Abdul-Nasser,AbdulNur,Abdul-Nur,AbdulQadir,AbdulQahhar,Abdul-Qahhar,AbdulQawi,Abdul-Qawi,AbdulQayyum,AbdulQuddus,Abdul-Quddus,AbdulRafi,Abdul-Rafi,AbdulRahim,AbdulRahman,Abdul-Rahman,AbdulRashid,Abdul-Rashid,AbdulRauf,Abdul-Rauf,AbdulRazzaq,Abdul-Razzaq,AbdulSabur,Abdul-Sabur,AbdulSalam,Abdul-Salam,AbdulSamad,Abdul-Samad,AbdulSami,Abdul-Sami,Abdul-Sattar,AbdulShahid,AbdulShakur,Abdul-Shakur,AbdulTawwab,Abdul-Tawwab,AbdulWadud,Abdul-Wadud,AbdulWahhab,Abdul-Wahhab,Abdul-Wahid,AbdulWajid,AbdulWakil,AbdulWali,Abdul-Wali,AbdulWaliy,AbdulWarith,Abdul-Warith,AbdulZahir,Ai-Chen,Ai-Huei,Ai-Meng,Amiot dit Villeneuve,Amyot dit Villeneuve,Ana-Maria,Anna-Liisa,Anna-Louise,Anne-Louise,Anne-Maree,Anne-Marie,Ann-Louise,Ann-Maree,Bette-Anne,Carol-Ann,Carol-Anne,Chieh-Ming,Chien-Chu,Chi-Feng,Chi-In,Chin-Chen,Chin-Chu,Ching-Yun,Chin-Lin,Chin-Te,Chiu-Yu,Cindy-Lee,D'Arne,de Bathesee Bath,DeAman,Deborah-Lee,Debra-Lee,DeWees,Di-Ann,Di-Anne,Donna-Lee,Donna-Marie,Duc-Tho,Eeva-Liisa,Eng-Fung,Eng-Tat,Eva-Maria,E'Vonne,Fee-Gon,Fu-Lai,Fu-Yuan,Hai-Chou,Hans-Dieter,Hans-Jeremy,Hsiu-Chen,Hsiu-Chu,Hsiu-Ming,Hsiu-Yueh,Hwa-Shi,I-Li,I-Tien,I-Yi,I-Ying,Jan-Maree,Jean-Claude,Jean-Paul,Jean-Pierre,Jill-Maree,Karl-Heinz,Kerri-Lyn,Koang-Ming,Kym-Maree,La Salle,LaCasse,Lai-Chun,Lea-Ann,Le-Anne,Lee-Anne,Leisa-Jane,Li-An,Li-Ching,Li-Chuan,Li-Hsia,Lisa-Jane,Lynn-Marie,MacAskill,MacCamish,MacCarthaig,MacCarthy,MacCash,MacCosh,MacLaws,MacLehose,MacTamhais,MacTammany,MacTause,MacTavish,Mao-Lin,Margaret-Mary,Marie-Claire,Marie-Jeanne,Marie-Louise,Marja-Leena,Mary-Clare,Mary-Ellen,Mary-Rita,Mary-Rose,McAddie,McAddog,McAlester,McAllester,McAlpin,McAtee,McAtte,McAttee,McBeal,McBee,McBride,McCad(d)ie,McCaffity,McCaislin,McCall,McCallister,McCarland,McCart,McCarthur,McCarty,McCaskill,McCasland,McCaualles,McCauley,McClasland,McClendon,McCloud,McClure,McClurg,McCod,McCondlin,McCoray,McCord,McCormack,McCormick,McCown,McCrady,McCrary,McCullough,McCurdy,McCurim,McCutsheon,McDaniel,McDill,McDonald,McDougal,McDuffy,McElro,McFarlin,McGalpin,McGavack,McGee,McGeeHee,McGeough,McGill,McGregor,McGriffin,McGuffin,McGuiggan,McGuire,McHafe,McIntosh,McIntyre,McKall,McKaran,McKenzie,McKinley,McKinney,McKinsey,McKinzie,McKisseck,McKivins,McLaird,McLaughlin,McLell,McLellan,McLelland,McLemore,McLendon,McLeod,McLreath,McMahon,McMann,McMilan,McMiltin,McMinn,McMullen,McMurtrey,McMurtry,McNally,McNeece,McNeil,McPheeters,McPheeters.,McRee,McReynolds,McRuley,McTimmons,McWatters,McWhorter,McWilliam,Mei-Hui,Mei-Ying,Mi-Li,Ming-Ho,M'Lellan,MN,Mo-Ling,M�rch,M�rck,M�rk,M�rk,Mui-Ching,Ng.K,Nyar-Kang,O'Callaghan,O'Callahan,O'Connor,O'Conor,O'Gara,O'Garey,O'Garry,O'Geary,O'Geiry,O'Hagen,O'hAnnagain,O'hAnnain,O'Hannon,O'Hara,O'Quin,O'Quinn,O'Reilly,O'Roney,O'Rownoe,O'Timmons,Pak-Yu,Pei-Chen,Pei-Hua,Peta-Lee,Pih-Shya,Pi-Hsia,Po-Chi,Rose-Marie,Sally-Ann,Sally-Anne,Sharon-Lee,Shu-Chen,Shu-Fen,Shu-Hui,Shun-Chu,Shu-Yin,Shu-Yu,St. Julian,Su-Ching,Sue-Ann,Sue-Anne,Su-Mei,SuU,Sze-Man,Tai-Chen,Tai-Li,Tracey-Lea,Tsai-Chi,Tsai-Hsien,Tsai-Hsiu,Tse-Shung,Tsung-Te,Tu-Chi,Tu-Su,Tze-Hung,Tzu-Te,VanDyke,VanNorstran,VartaKhatoun,Varta-Khatoun,VartigKhatoun,Wen-Long,Wie-Chou,Wolf-Dieter,Wu-Hsiung,Xiang-Jun,Ya-Fang,Ya-Huei,Ya-Hui,Yang-Hsiu-Ching,Yean-Cheng,Yeh-Lung,Yen-Chi,Yen-Yi,Yew-Kung,Yi-Bai,Ying-Chu,Ying-Haui,Ying-Ming,Ying-Wah,Yiok-Gin,Yu-An,Yuan-Lung,Yueh-Chin,Yueh-O,Yueh-Teng,Yueh-Ying,Yueh-Yun,Yuen-Kwan,Yuen-Teng,Yu-Hua,Yu-Ju,Yung-Fu,Yung-Hsiang,Yung-Hwa,Yung-Juei,Yung-Shu,Yung-Tsang,Yung-Yung,Yu-Ya,Yvonne-Elaine,Zdenka Gilland,Zhong-Ming,Ben Aron,Ben Moshe,Da Costa,Da Silva,D'Agostino,D'Aigle,D'Aigre,D'Aire,Dal Lago,Dalla Rosa,D'Alton,Dalton Allan,D'Amfreville,D'Anjou,D'Arcy,DaScola,DaSilva,De Acosta,De Aguero,De Almas,De Arnold,De Bathe,De Bevera,De Blanc,De Bohun,De Brieweres,De Cervantes,De Coninck,De Crocketagne,De Faitis+A1333,De Fecamp,De Feytis,De Forrester,De Gamaches,De Gamage,De Garrisson,De Grava,De Haveilland,De Havilland,De Isaac,De Joux,De La Montagne,De la Motta,De la Motte,De la Paor,De la Pena,De la Poar,De la Poer,De la Poher,De La Roche,De la Rosa,De Leon,De Liancour,De Lisle,De Lisser,De Little,De Los Rios,De Lotto,De Luna,De Madrid,De Maio,De Majo,De Manlegh,De Mayo,De Mente,De Mura,De Paor,De Pass,De Pau,De Paz,De Pena,De Poer,De Querton,De Quinemont,De Rattrief,De Rivera,De Rutlache,De Salazar Hachero,De Sandersted,De Silva,De Sotto,De Sousa,De Sutton,De Sutton-Clonard,De Tilston,De Velde,De Vuono,De Warenne,De Warrenne,De Wherton,De Yoe,DeBlasio,DeBois,DeBoys,DeBruijn,DeBruyn,DeC�spedes,DeConinck,DeCoursey,DeDoming,DeDominge,Del Badia,Della Mano,DeLong,DeMena,DeNiro,DePass,DePaz,DePue,DeQuerton,DeRevere,DerKaverian,DeRoche,D'Estes,DeVary,DeVito,DeVore,DeWaller,DeWarren,DeWine,DeWire,DeWitt,DeWolf,Di Domenico,DiBenedetto,DiCesare,DiCrescenzo,DiMartino,D'Silva,D'Souza,DuBose,DuLaney,Fernandez de Flores,Fernandez de Pedro,Fitz Gibbons,Fitz Waring,FitzGerald,Fitz-Hugh,Fitz-Randolph,Fleur-de-lis,Fleur-de-lix,Flores-Medina,Garcia de Noriega,Garcia Guajardo,Garcia Venegas,Garcia-Colon,Garcia-Cuevas,Garcia-Gonzalez,Garcia-Marin,Gomes-Farelo,Gomez-Infante,Gonzales-Cabrera,Gonzalez Baz,Gonzalez Bernal,Gonzalez Menendez,La Boon,La Bruviere,La Coste,La Lade,La Mont,La Montagne,La Monte,La Roche,La Susa,La Vine,LaBach,LaBoon,LaBrecque,LaCharite,LaFabre,LaFerney,LaFontaine,LaPage,LaPeer,LaPierre,LaRue,LaTour,LaVigne,Le Bail,Le Berger,Le Brun,Le Compte,Le Comte,Le Cousteur,Le Couteur,Le Duc,Le Fetty,Le Hericy,Le Juis,Le Noble,Le Normand,Le Poher,Le Poultre,Le Roche,Le Strang,Le Strange,Le Strein,Le Streing,Le Veler,LeBlanc,LeBon,LeBrock,LeJuis,LeMarquis,LeMond,LeNormand,LePage,LeRoy,LeTourneau,LeVeler,Lopez de Gauna,Lopez de Victoria,Lora y Betancourt,Mac Carr,Mac Carroll,Mac Clancy,Mac Coitir,Mac Concarraig,Mac Concarraigh,Mac Concharraigh,Mac Corcoran,Mac Cuinneagain,Mac Curtain,Mac Daniel,Mac Donald,Mac Ghille Mhuire,Mac Gibbons,Mac Giolla Dhuinn,Mac Giolla Ghunna,Mac Gregor,Mac Innes,Mac Kinsey,Mac Muircheartaigh,Mac Neil,Mac Nicol,Mac Noble,MacAdam,MacAdams,MacAddam,MacAdie,MacAfee,MacAlaster,MacAlister,MacAllan,MacAllen,MacAlley,MacAllister,MacAlly,MacAnally,MacAndrew,MacAngus,MacAnselan,MacAntil,MacArthur,MacAulay,MacAuley,MaCawley,MacBaker,MacBean,MacBee,MacBeen,MacBride,MacBryde,MacCall,MacCallan,MacCalley,MacCampbell,MacCane,MacCarmack,MacCathiain,MacCavish,MacCein,MacCeney,MacClain,MacClancy,MacClaren,MacClay,MacClellan,MacColl,MacComb,MacCombie,MacConcarraig,MacConnel,MacConnell,MacCoone,MacCord,MacCordum,MacCormack,MacCourt,MacCoy,MacCracken,MacCrain,MacCulley,MacCully,MacCurdy,MacCuric,MacCurtin,MacDaid,MacDanal,MacDanald,MacDaniel,MacDannal,MacDannell,MacDanold,MacDermid,MacDiarmid,MacDonald,MacDonell,MacDonnel,MacDonnell,MacDonnsliebhe,MacDouall,MacDougal,MacDougald,MacDougall,MacDowall,MacDowel,MacDowell,MacDuffie,MacDuffy,MacEachan,MacEachen,MacEgan,MacEoghain,MacEohain,MacEwan,MacEwen,MacEwing,MacFadyen,MacFarland,MacFee,MacFergus,MacFhionnlaoich,MacFhlannchaidh,MacFie,MacGee,MacGhee,MacGill,MacGmur,MacGregor,MacGrowther,MacGruder,MacGuigan,MacGuire,MacGuyer,MacGyuer,MacHaley,MacHendry,MacHenry,MacIain,MacIan,MacInnis,MacIntaylor,MacIntyre,MacIrish,MacIsaac,MacKain,MacKane,MacKean,MacKeen,MacKendrick,MacKenrick,MacKenzie,MacKey,MacKindlay,MacKinley,MacKinnis,MacKirdie,MackMillion,MacKnight,MacKnown,MacKorda,MacLachlan,MacLachlane,MacLain,MacLaine,MacLamb,MacLamore,MacLane,MacLaren,MacLauchlan,MacLauchlane,MacLaughlan,MacLaughlen,MacLaughlin,MacLaurin,MacLea,MacLean,MacLearen,MacLeay,MacLelan,MacLellan,MacLennan,MacLeod,MacLochlainn,MacLoughlin,MacMahan,MacMahon,MacManus,MacMartin,MacMaster,MacMasters,MacMath,MacMathon,MacMhathain,MacMillan,MacMillen,MacMillian,MacMullan,MacMullin,MacMurchadha,MacMurrough,MacMurtrie,MacMurtry,MacNachten,MacNair,MacNamara,MacNaughton,MacNeil,MacNeill,MacNichol,MacNickle,MacNicol,MacNown,MacOnlea,MacOric,MacOwen,MacParlain,MacParlan,MacPeters,MacPhedron,MacPhie,MacPhun,MacQueen,MacQueene,MacQuilkan,MacQuinn,MacQuire,MacQuiston,MacRae,MacRanald,MacRannald,MacReynold,MacReynolds,MacSeain,MacSeney,MacSimi,MacSum,MacTaggart,MacTamais,MacTavis,MacTaylor,,MacThomas,MacTiernan,MacTighe,MacTighernan,MacVean,MacVee,MacWatt,MacWattie,MacWhorter,MacWilliam,MacWilliams,MaGhan,MaGin,MaGruther,MakMillan,MakMillen,MaQuire,Mc Allister,Mc Cain,Mc Carrick,Mc Clancy,Mc Coitir,Mc Cracken,Mc Daniel,Mc Donald,Mc Eachern,Mc Ginley,Mc Innes,Mc Intyre,Mc Kenna,Mc Lain,Mc Neil,Mc Neill,Mc Pike,Mc Wherter,McAbee,McAdam,McAdam,,McAdams,McAddam,McAddame,McAfee,McAlaster,McAlister,McAllaster,McAllister,McAllisterA,McAlly,McAlpine,McAnair,McAnaley,McAnally,McAnaly,McAndrew,McAnear,McAneer,McAnelly,McAngus,McAnnalley,McAphee,McArdle,McArter,McArthur,McAulay,McAule,McAuley,McBean,McBryde,McCabe,McCadam,,McCadams,McCaddam,,McCaddan,McCaddon,McCadon,McCahan,McCain,McCaine,McCal,McCaleb,McCalester,McCalib,McCalip,MccAlister,McCallester,McCalley,McCallum,McCally,McCamey,McCampbell,McCamy,Mc'Candless,Mc'Canlis,McCann,McCarmack,McCarrick,McCarten,McCarter,McCartha,McCarthey,McCarthy,McCartie,McCartney,McCath�in,McCathren,McCaughan,McCaul,McCaulay,McCauly,McCaw,McCawley,McCeney,McChristian,McChriston,McClain,McClaine,McClam,McClanaghan,McClanahan,McClancy,McClane,McClannahan,McClaren,McClarin,McClay,McClayrin,McClean,McClearin,McCleester,McClelan,McCleland,McClellan,McClelland,McClenahan,McClenehan,McClenny,McClerin,McClerrin,McClin,McCloskey,McClung,McCoin,McCole,McColgan,McColister,McColl,McCollester,McColley,McCollister,McColly,McComas,McComb,McConal,McConchie,McConel,McConell,McConiel,McConley,McConmara,McConnal,McConnell,McCool,McCooley,McCoon,McCormac,McCormic,McCoun,McCourt,McCoutney,McCowan,McCowen,McCowin,McCowne,McCoy,McCracken,McCrackin,McCrae,McCrain,McCraine,McCraken,McCranie,McCraw,McCray,McCrea,McCreary,McCree,McCreghan,McCreight,McCrekan,McCright,McCrite,McCrodan,McCrory,McCrudden,McCruden,McCuistian,McCuistion,McCuiston,McCulley,McCullie,McCulloch,McCully,McCune,McCuric,McCush,McCutchan,McCutchen,McCutcheon,McCutchin,McDade,McDaid,McDanal,McDanald,McDanel,McDaniell,McDaniels,McDanil,McDannal,McDanniel,McDanold,McDavitt,McDeed,McDermid,McDermott,McDevitt,McDiarmid,McDiffie,McDole,McDonal,McDonell,McDonnel,McDougald,McDougall,McDowall,McDowel,McDuff,McDuffe,McDuffee,McDuffey,McDuffie,McEachain,McEachan,McEachern,McElgunn,McElroy,McEnally,McEnerny,McEnery,McEnnier,McEnree,McEoin,McEwan,McEwen,McEwing,McFadden,McFaden,McFarland,McFarling,McFeaters,McFeatures,McFee,McFeeters,McFie,McGahan,McGanagil,McGaughan,McGaw,McGay,McGeever,McGehee,McGeogh,McGergor,McGettigan,McGhan,McGhee,McGhehee,McGie,McGin,McGinley,McGinn,McGinnes,McGinness,McGinnigle,McGinnis,McGlaughlin,McGlin,McGlothlin,McGmur,McGoff,McGoigle,McGonagill,McGonegle,McGonigal,McGonigle,McGonnagal,McGonnagle,McGonnigal,McGonnigil,McGonnogle,McGough,McGoveran,McGovern,McGowan,McGowen,McGowran,McGrail,McGrath,McGraw,McGreal,McGreggor,McGriggor,McGrigor,McGruder,McGruther,McGue,McGuffey,McGuffie,McGuier,McGuigan,McGuin,McGuirk,McGully,McGunnegle,McGunnigle,McGurik,McGurk,McGuyer,McGuyre,McGwier,McGwire,McHaley,McHenry,M'Chruiter,M'Chruter,M'Churter,McIain,McIan,McIlmorrow,McIlreich,McInair,McInally,McInearney,McInerney,McInerny,McIngvale,McInis,McInish,McInnes,McInnis,McInnish,McInvail,McInvaill,McInvaille,McInvale,McIsaac,McIver,McKain,McKamey,McKamy,McKane,McKaughan,McKay,McKean,McKeane,McKechnie,McKee,McKeegan,McKeen,McKeene,McKeever,McKegney,McKendrick,McKendry,McKenna,McKenney,McKenny,McKenrick,McKenze,McKenzey,McKenzy,McKeown,McKernan,McKerras,McKibbin,McKiernan,McKigney,McKillican,McKimmon,McKiney,McKinlay,McKinna,McKinnes,McKinnie,McKinnis,McKinniss,McKinsay,McKinza,McKinzey,McKirdie,McKnight,McKnowen,McKnown,McKoin,McKowen,McKown,McKoy,McKoye,McKrachen,McKracken,McKully,McLachlan,McLae,McLain,McLaine,McLam,McLamb,McLamore,McLane,McLaorin,McLaren,McLarin,McLarrin,McLaughlan,McLauren,McLaurin,McLay,McLea,McLean,McLearen,McLeester,McLennan,McLennon,McLin,McLoughlin,McMachen,McMaghan,McMaghon,McMaham,McMahan,McMahen,McMains,McManis,McManners,McMannus,McManus,McMartin,McMaster,McMasters,McMean,McMeans,McMellen,McMillan,McMillen,McMillian,McMillin,McMillion,McMillon,McMinns,McMullan,McMullin,McMurchy,McMurrey,McMurtray,McMurtrie,McMurty,McNair,McNairy,McNamara,McNamera,McNaught,McNaughtan,McNaughten,McNeal,McNece,McNeely,McNeer,McNees,McNeill,McNeilly,McNerney,McNett,McNevin,McNew,McNiel,McNiell,McNight,McNite,McNitt,McNown,McNutt,McOnLea,McOric,McOrmond,McPaden,McPaidin,McParlan,McParland,McParlane,McPartland,McPeak,McPeek,McPeeters,McPeke,McPeters,McPhail,McPharland,McPhee,McPhee,,McPherson,McPheters,McPhetters,McPhillips,McPike,McQuarter,McQueene,McQuerter,McQuesten,McQuestian,McQuestion,McQueston,McQueter,McQuilkan,McQuilken,McQuilkin,McQuillan,McQuilliam,McQuillin,McQuinn,McQuire,McQuirter,McQuisten,McQuistian,McQuistion,McQuiston,McQuorter,McQuown,McRacken,McRackin,McRae,McRainey,McRaney,McRanie,McRannald,McRavy,McRea,McReavy,McRight,McShane,McSharry,McShea,McSherry,McSimon,McStewart,McTaggart,McTaggert,McTavish,McTernan,McThomas,McTiernan,McTighe,M'Cully,Mcvicar Fitzpartick,McWharter,McWherter,McWhirter,McWilkane,McWilliams,McWorter,M'Donald,M'Farland,M'Farlane,MicCracken,M'Kenzie,M'Kindlay,M'Kinlay,M'Lean,O Bannon,O Carroll,O Corcoran,O Corcrain,O Donoghue,O Gaoithin,O Gormley,� Maoileoin,� Seachnasaigh,O`Dwyer,O`Dyer,O'Banion,O'Banner,O'Bannion,OBannon,O'Bannon,O'Beirne,O'Block,O'Boys,O'Brady,O'Bresnahan,O'Bresnehan,O'Brian,O'Brien,O'Brollaghain,O'Brosnahan,O'Bryan,O'Byrne,O'Byrnes,O'Cahan,O'Cain,O'Caisade,O'Callan,O'Cane,O'Carroll,O'Cathain,O'Cathan,O'Cearbhaill,O'Cein,O'Cleary,O'Cleirigh,O'Clery,O'Colgan,OConnell,O'Conner,O'Cuilinn,O'Cuinneagain,O'Daniel,O'Daniell,O'Daniels,O'Dannel,O'Dannell,O'Daugherty,O'Day,O'Dea,O'Dempsey,O'Dinn,O'Dochartaigh,O'Dogherty,O'Doherty,O'Doinn,O'Donaghue,O'Donnchadda,ODonnell,O'Donnell,O'Donnelly,O'Donoghue,O'Donohoe,O'Donohue,O'Donovan,O'Dooghue,O'Dougherty,O'Dowrish,O'Doyer,O'Doyne,O'Driscoll,O'Duinn,O'Dunne,ODwyer,O'Dwyer,O'Factnain,O'Farrell,Offutt-Offord,O'Flaherty,O'Flannery,O'Flinn,O'Floinn,O'Flynn,O'Foghlu,OGadhra,O'Gan,OGar,O'Gar,O'Garr,O'Garra,O'Ghadra,O'Gorman,O'Grady,O'Guin,O'Guinea,O'Guinee,O'Guiney,O'Guinn,O'Hagan,OHagerty,O'Hainmhire,O'Haminhire,O'Harra,O'hArractain,O'Harrah,O'Harrow,O'Hart,OHegarty,O'Heyne,O'Hickey,O'Hoollaghan,O'Kain,O'Kane,O'Keane,O'Kearney,O'Kelly,OKS,O'Lennon,O'Malley,O'Mallie,O'Manlie,O'Meachair,O'Meagher,O'More,O'Mullally,O'Neal,O'Neil,O'Neill,O'Nolan,O'Quinlan,O'Reagan,O'Reiley,O'Rielly,O'Riley,O'Rilly,O'Roark,O'Rosa,O'Rourke,O'Se,O'Sewell,O'Shannassy,O'Shannessy,O'Shaughnessy,O'Shaunessy,O'Shay,O'Shea,O'Shee,Ostenson Lunde,O'Sullivan,O'Tierney,O'Tighe,O'Tole,O'Toole,O'Towle,Saint Clair,Saint Claire,Saint Jmaes,Spence-Thomas,,St Clair,St James,St John,St Louis,St. Clair,St. Claire,St. Denis,St. Dennis,St. George,St. Jacques,St. Jarre,St. Jeor,St. John,St. Johns,St. Jorre,St. Julien,St.John,Van Aalen,Van Adder,Van Alen,Van Alin,Van Allen,Van Atter,Van Block,Van Boldrik,Van Bradt,Van Braeckel,Van Braekel,Van Brakel,Van Brakele,Van Coppenaele,Van Coppenolle,Van Dake,Van de Dood,Van de Velde,Van den Brande,Van den Branden,Van den Brander,Van der Merwe,Van der Veer,Van der Vliedt,Van der Vliet,Van der Vliett,Van der Voort,Van Dood,Van Fleet,Van Fossen,Van Gilder,Van Hees,Van Horn,Van Horne,Van Kenhove,Van Kortryk,Van Kuykendall,Van Natta,Van Neck,Van Patten,Van Sandt,Van Sant,Van Slyke,Van Sutphen,Van Tienhoven,Van Tilberg,Van Tilburg,Van Tilburgh,Van Tilbury,Van Tillburg,Van Vliet,Van Vossen,Van Wicklen,Van Zandt,Van Zeeland,Van Zutphen,VanArsdale,VanArsdalen,VandeMerwe,VanderHeijden,VanderHeyden,VanderMerwe,VanNatta,VanSeters \ No newline at end of file diff --git a/src/main/resources/licenseTemplate.txt b/src/main/resources/licenseTemplate.txt new file mode 100644 index 0000000..6d13a9b --- /dev/null +++ b/src/main/resources/licenseTemplate.txt @@ -0,0 +1,3 @@ +Copyright (c) 2019 John Groller + +WhatsInAName - John Groller diff --git a/src/test/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceTest.java b/src/test/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceTest.java new file mode 100644 index 0000000..9b4a7ae --- /dev/null +++ b/src/test/java/com/jkgroller/whatsinaname/service/IndividualNameFormatterServiceTest.java @@ -0,0 +1,465 @@ +/** + * Copyright (c) 2019 John Groller + * + * WhatsInAName - John Groller + */ +package com.jkgroller.whatsinaname.service; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterRequestTO; +import com.jkgroller.whatsinaname.service.to.IndividualNameFormatterResponseTO; + +@RunWith(MockitoJUnitRunner.class) +public class IndividualNameFormatterServiceTest { + + @Mock + List names = new ArrayList() { + private static final long serialVersionUID = 1L; + + { + add("McGinnis"); + add("McGlaughlin"); + add("McGlin"); + } + }; + + private IndividualNameFormatterRequestTO individualNameFormatterRequestTO; + + private IndividualNameFormatterResponseTO expectedIndividualNameFormatterResponseTO; + + @InjectMocks + private IndividualNameFormatterServiceImpl individualNameFormatterService; + + /** + * + */ + @Before + public void setupRequestAndResponses() { + + individualNameFormatterRequestTO = generateIndividualNameFormatterRequestTO(); + + expectedIndividualNameFormatterResponseTO = generateIndividualNameFormatterResponseTO(); + + } + + /** + * + */ + @Test + public void testLastNameFirstNameCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getLastNameFirstName(), + actualIndividualNameFormatterResponseTO.getLastNameFirstName()); + + } + + /** + * + */ + @Test + public void testLastNameFirstNameFirstNameNull() { + + individualNameFormatterRequestTO.setFirstName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getLastNameFirstName()); + + } + + /** + * + */ + @Test + public void testLastNameFirstNameLastNameNull() { + + individualNameFormatterRequestTO.setLastName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getLastNameFirstName()); + + } + + /** + * + */ + @Test + public void testLastNameFirstNameMiddleInitialCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getLastNameFirstNameMiddleInitial(), + actualIndividualNameFormatterResponseTO.getLastNameFirstNameMiddleInitial()); + + } + + /** + * + */ + @Test + public void testLastNameFirstNameMiddleInitialMiddleNameNull() { + + individualNameFormatterRequestTO.setMiddleName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getLastNameFirstNameMiddleInitial()); + } + + /** + * + */ + @Test + public void testPrefixFirstNameLastNameCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getPrefixFirstNameLastName(), + actualIndividualNameFormatterResponseTO.getPrefixFirstNameLastName()); + } + + /** + * + */ + @Test + public void testPrefixFirstNameLastNamePrefixNull() { + + individualNameFormatterRequestTO.setPrefix(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getPrefixFirstNameLastName()); + + } + + /** + * + */ + @Test + public void testPrefixFirstNameLastNameFirstNameNull() { + + individualNameFormatterRequestTO.setFirstName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getPrefixFirstNameLastName()); + + } + + /** + * + */ + @Test + public void testPrefixLastNameCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getPrefixLastName(), + actualIndividualNameFormatterResponseTO.getPrefixLastName()); + + } + + /** + * + */ + @Test + public void testPrefixLastNamePrefixNull() { + + individualNameFormatterRequestTO.setPrefix(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getPrefixLastName()); + + } + + /** + * + */ + @Test + public void testPrefixLastNameLastNameNull() { + + individualNameFormatterRequestTO.setLastName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getPrefixLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameSuffixCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix(), + actualIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameSuffixSuffixNull() { + + individualNameFormatterRequestTO.setSuffix(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameSuffixLastNameNull() { + + individualNameFormatterRequestTO.setLastName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameSuffixFirstNameNull() { + + individualNameFormatterRequestTO.setFirstName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameSuffixFirstNameAndLastNameNull() { + + individualNameFormatterRequestTO.setFirstName(null); + individualNameFormatterRequestTO.setLastName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameLastNameSuffix()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameLastNameCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName(), + actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameMiddleNameNull() { + + individualNameFormatterRequestTO.setMiddleName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameLastNameNull() { + + individualNameFormatterRequestTO.setLastName(null); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertNull(actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * + */ + @Test + public void testPrefixFirstNameMiddleInitialLastNameCorrectFormat() { + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals(expectedIndividualNameFormatterResponseTO.getPrefixFirstNameMiddleInitialLastName(), + actualIndividualNameFormatterResponseTO.getPrefixFirstNameMiddleInitialLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameLastNameLastNameOnTheList() { + + individualNameFormatterRequestTO.setFirstName("JOHN"); + individualNameFormatterRequestTO.setLastName("LA MONTAGNE"); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals("John La Montagne", actualIndividualNameFormatterResponseTO.getFirstNameLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameLastNameLastNameSpace() { + + individualNameFormatterRequestTO.setFirstName("JOHN"); + individualNameFormatterRequestTO.setMiddleName("JACOB"); + individualNameFormatterRequestTO.setLastName("JINGLEHEIMER SCHMIDT"); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals("John Jacob Jingleheimer Schmidt", + actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameLastNameLastNameHyphen() { + + individualNameFormatterRequestTO.setFirstName("JOHN"); + individualNameFormatterRequestTO.setMiddleName("JACOB"); + individualNameFormatterRequestTO.setLastName("JINGLEHEIMER-SCHMIDT"); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals("John Jacob Jingleheimer-Schmidt", + actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * + */ + @Test + public void testFirstNameMiddleNameLastNameFirstNameHyphen() { + + individualNameFormatterRequestTO.setFirstName("JOHN-SOMETHING"); + individualNameFormatterRequestTO.setMiddleName("JACOB"); + individualNameFormatterRequestTO.setLastName("JINGLEHEIMER-SCHMIDT"); + + IndividualNameFormatterResponseTO actualIndividualNameFormatterResponseTO = individualNameFormatterService + .formatIndividualName(individualNameFormatterRequestTO); + + assertEquals("John-Something Jacob Jingleheimer-Schmidt", + actualIndividualNameFormatterResponseTO.getFirstNameMiddleNameLastName()); + + } + + /** + * Setup the request. + * + * @return + */ + private IndividualNameFormatterRequestTO generateIndividualNameFormatterRequestTO() { + IndividualNameFormatterRequestTO individualNameFormatterRequestTO = new IndividualNameFormatterRequestTO(); + + individualNameFormatterRequestTO.setFirstName("JOHN"); + individualNameFormatterRequestTO.setLastName("GROLLER"); + individualNameFormatterRequestTO.setPrefix("DR."); + individualNameFormatterRequestTO.setSuffix("IV"); + individualNameFormatterRequestTO.setMiddleName("CHRISTOPHER"); + individualNameFormatterRequestTO.setPreferredName("JAMES WESTFALL"); + + return individualNameFormatterRequestTO; + + } + + /** + * Setup the expected response. + * + * @return + */ + private IndividualNameFormatterResponseTO generateIndividualNameFormatterResponseTO() { + + IndividualNameFormatterResponseTO individualNameFormatterResponseTO = new IndividualNameFormatterResponseTO(); + + individualNameFormatterResponseTO.setFirstName("John"); + individualNameFormatterResponseTO.setLastName("Groller"); + individualNameFormatterResponseTO.setPrefix("Dr."); + individualNameFormatterResponseTO.setSuffix("IV"); + individualNameFormatterResponseTO.setMiddleName("Christopher"); + individualNameFormatterResponseTO.setPreferredName("James Westfall"); + individualNameFormatterResponseTO.setFirstNameLastNameSuffix("John Groller IV"); + individualNameFormatterResponseTO.setFirstNameMiddleNameLastName("John Christopher Groller"); + individualNameFormatterResponseTO.setLastNameFirstName("Groller, John"); + individualNameFormatterResponseTO.setLastNameFirstNameMiddleInitial("Groller, John C."); + individualNameFormatterResponseTO.setPrefixFirstNameLastName("Dr. John Groller"); + individualNameFormatterResponseTO.setPrefixFirstNameMiddleInitialLastName("Dr. John C. Groller"); + individualNameFormatterResponseTO.setPrefixLastName("Dr. Groller"); + individualNameFormatterResponseTO.setProfessionalDesignation("Esquire"); + + return individualNameFormatterResponseTO; + } + +}