Person saving

PersonFormValidator.java

package heimdall.ui.validator;

import com.google.common.base.Strings;
import heimdall.ui.recipient.AddressForm;
import heimdall.ui.recipient.PersonForm;
import org.apache.commons.lang.math.NumberUtils;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 *
 * @author sandeshb
 *
 */
public class PersonFormValidator implements Validator {

    private static final String REG_EX_SPACES = "^\\s+|\\s+$";
    private static final int MAX_SDS_NUMBER = 15;
    private static final int MAX_PHONE_NUMBER = 12;
    private static final int MAX_CODE_NUMBER = 4;
    private static final int FIRSTNAME_MAX_LENGTH = 64;
    private boolean hasAddress = false;



    @Override
    public boolean supports(final Class<?> clazz) {
        return true;
    }

    @Override
    public void validate(final Object target, final Errors errors) {
        PersonForm form = (PersonForm) target;
        validateNotEmptyAddresFormList(form.getAddressList(), errors);
        form.setFirstname(validateTralingSpaces("firstname", form.getFirstname(), errors));
        form.setLastname(validateTralingSpaces("lastname", form.getLastname(), errors));
        form.setFirstname(validateEmptySpaces("firstname", form.getFirstname(), errors));
        form.setLastname(validateEmptySpaces("lastname", form.getLastname(), errors));
        form.setFirstname(validateLength("firstname", form.getFirstname(), errors));
        form.setLastname(validateLength("lastname", form.getLastname(), errors));
        form.setPositions(validateLength("positions", form.getPositions(), errors));
        form.setOrganizations(validateLength("organizations", form.getOrganizations(), errors));
        if (hasAddress) {
            validateAddresFormList(form.getAddressList(), errors);
        }
    }

    private String validateTralingSpacesForNumbers(final String field, final String value,
                                                   final int maxLength, final Errors errors) {
        Pattern trimmer = Pattern.compile(REG_EX_SPACES);
        if (trimmer.matcher(Strings.nullToEmpty(value)).find()) {
            errors.rejectValue(field, "trailing.spaces.removed");
            return value.replaceAll(REG_EX_SPACES, "");
        }
        if(!"".equalsIgnoreCase(value))
        {
            if (!NumberUtils.isNumber(value)) {
                if (maxLength == 12) {
                    errors.rejectValue(field, "addressbook.person.validation.phone.number");
                } else {
                    errors.rejectValue(field, "addressbook.person.validation.code.number");
                }

                return value;
            }
            if (value.length() > maxLength) {
                if (maxLength == 12) {
                    errors.rejectValue(field,  "addressbook.person.validation.phone.too.long");
                } else {
                    errors.rejectValue(field,  "addressbook.person.validation.code.too.long");
                }

                return value;
            }
        }
        return value;
    }

    private String validateTralingSpaces(final String field, final String value, final Errors errors) {
        Pattern trimmer = Pattern.compile(REG_EX_SPACES);
        if (trimmer.matcher(Strings.nullToEmpty(value)).find()) {
            errors.rejectValue(field, "trailing.spaces.removed");
            return value.replaceAll(REG_EX_SPACES, "");
        }
        return value;
    }

    private String validateEmptySpaces(final String field, final String value, final Errors errors) {
        if (Strings.isNullOrEmpty(field)) {
            errors.rejectValue(field, "addressbook.person.validation.name.missing");
        }
        return value;
    }

    private List<String> validateStringList(final String field,
                                            final List<String> valueList, final Errors errors) {
        final List<String> stringList = new ArrayList<>();
        for (String value : valueList) {
            stringList.add(validateTralingSpaces(field, value, errors));
        }
        return stringList;
    }

    private String validateEmail(final String field, final String value, final Errors errors) {

        String newValue = validateTralingSpaces(field, value, errors);
        if (!errors.hasErrors())  {
            if (!newValue.contains("@")) {
                errors.rejectValue(field, "addressbook.person.validation.email.valid");
                return newValue;
            }
        }
        return newValue;
    }

    private String validateLength(final String field, final String value, final Errors errors) {
        if (!Strings.isNullOrEmpty(field) && field.length() > FIRSTNAME_MAX_LENGTH) {
            errors.rejectValue(field, "addressbook.person.validation.name.too.long");
        }
        return value;
    }
    private void validateAddresFormList(final List<AddressForm> addressForms, final Errors errors) {
        int index = 0;
        for (AddressForm addressForm : addressForms) {
            switch (addressForm.getType()) {
                case PHONE:
                    addressForm.setNumber(validateTralingSpacesForNumbers("addressList["

                            + index + "]", addressForm.getNumber(), MAX_PHONE_NUMBER, errors));
                    addressForm.setCountryCode(validateTralingSpacesForNumbers("addressList["
                            + index + "]", addressForm.getCountryCode(), MAX_CODE_NUMBER, errors));
                    break;

                case EMAIL:
                    addressForm.setValue(validateEmail("addressList["
                            + index + "]", addressForm.getValue(), errors));

                    break;

                case SDS:
                    addressForm.setNumber(validateTralingSpacesForNumbers("addressList["
                            + index + "]", addressForm.getNumber(), MAX_PHONE_NUMBER, errors));
                    addressForm.setCountryCode(validateTralingSpacesForNumbers("addressList["
                            + index + "]", addressForm.getCountryCode(), MAX_CODE_NUMBER, errors));
                    if (addressForm.getNumber() != null) {
                        if (addressForm.getNumber().length() > MAX_SDS_NUMBER) {
                            errors.rejectValue("addressList["
                                    + index + "]", "address.sds.number.max");
                        }
                    }
                    break;

                default:
                    errors.rejectValue(("addressList["
                            + index + "]"),
                            "Undefined type");
            }
            index++;
        }
    }
    @SuppressWarnings("checkstyle:cyclomatic")
    private void validateNotEmptyAddresFormList(final List<AddressForm> addressForms, final Errors errors) {
        for (AddressForm addressForm : addressForms) {
            if (!hasAddress) {
                switch (addressForm.getType()) {
                    case PHONE: hasAddress = isValidAddress(addressForm);
                        break;

                    case EMAIL:
                        if (!Strings.isNullOrEmpty(addressForm.getValue())) {
                            hasAddress = true;
                        }
                        break;

                    case SDS:
                        hasAddress = isValidAddress(addressForm);
                        break;

                    default:
                        throw new IllegalStateException("Unsupported type: "
                                + addressForm.getType());
                }
            }

        }
        if (!hasAddress) {
            errors.rejectValue("firstname", "addressbook.person.validation.address.missing.addressList");
        }
    }

    /**
     *
     * @param addressForm AddressForm
     * @return
     */
    private boolean isValidAddress(final AddressForm addressForm) {
        if (!Strings.isNullOrEmpty(addressForm.getCountryCode())
                || !Strings.isNullOrEmpty(addressForm.getNumber())) {
            return true;
        }
        return false;
    }

}