com.playtech.portal.platform.common.util.Validator.java Source code

Java tutorial

Introduction

Here is the source code for com.playtech.portal.platform.common.util.Validator.java

Source

/**
 * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 */

package com.playtech.portal.platform.common.util;

import org.apache.commons.lang.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Provides utility methods related to data validation and format checking.
 *
 * @author Brian Wing Shun Chan
 * @author Alysa Carver
 * @deprecated migrate to JSR 303 validation or use Apache Commons where JSR 303 is not applicable
 */
@Deprecated
public class Validator {

    /**
     * Returns <code>true</code> if the booleans are equal.
     *
     * @param  boolean1 the first boolean
     * @param  boolean2 the second boolean
     * @return <code>true</code> if the booleans are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(boolean boolean1, boolean boolean2) {
        if (boolean1 == boolean2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the bytes are equal.
     *
     * @param  byte1 the first byte
     * @param  byte2 the second byte
     * @return <code>true</code> if the bytes are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(byte byte1, byte byte2) {
        if (byte1 == byte2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the characters are equal.
     *
     * @param  char1 the first character
     * @param  char2 the second character
     * @return <code>true</code> if the characters are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(char char1, char char2) {
        if (char1 == char2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the doubles are equal.
     *
     * @param  double1 the first double
     * @param  double2 the second double
     * @return <code>true</code> if the doubles are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(double double1, double double2) {
        if (Double.compare(double1, double2) == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the floats are equal.
     *
     * @param  float1 the first float
     * @param  float2 the second float
     * @return <code>true</code> if the floats are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(float float1, float float2) {
        if (Float.compare(float1, float2) == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the integers are equal.
     *
     * @param  int1 the first integer
     * @param  int2 the second integer
     * @return <code>true</code> if the integers are equal; <code>false</code>
     *         otherwise
     */
    public static boolean equals(int int1, int int2) {
        if (int1 == int2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the long integers are equal.
     *
     * @param  long1 the first long integer
     * @param  long2 the second long integer
     * @return <code>true</code> if the long integers are equal;
     *         <code>false</code> otherwise
     */
    public static boolean equals(long long1, long long2) {
        if (long1 == long2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the objects are either equal, the same
     * instance, or both <code>null</code>.
     *
     * @param  obj1 the first object
     * @param  obj2 the second object
     * @return <code>true</code> if the objects are either equal, the same
     *         instance, or both <code>null</code>; <code>false</code> otherwise
     */
    public static boolean equals(Object obj1, Object obj2) {
        if ((obj1 == null) && (obj2 == null)) {
            return true;
        } else if ((obj1 == null) || (obj2 == null)) {
            return false;
        } else {
            return obj1.equals(obj2);
        }
    }

    /**
     * Returns <code>true</code> if the short integers are equal.
     *
     * @param  short1 the first short integer
     * @param  short2 the second short integer
     * @return <code>true</code> if the short integers are equal;
     *         <code>false</code> otherwise
     */
    public static boolean equals(short short1, short short2) {
        if (short1 == short2) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the string is an email address. The only
     * requirements are that the string consist of two parts separated by an @
     * symbol, and that it contain no whitespace.
     *
     * @param  address the string to check
     * @return <code>true</code> if the string is an email address;
     *         <code>false</code> otherwise
     */
    public static boolean isAddress(String address) {
        if (isNull(address)) {
            return false;
        }

        String[] tokens = address.split("@");

        if (tokens.length != 2) {
            return false;
        }

        for (String token : tokens) {
            for (char c : token.toCharArray()) {
                if (Character.isWhitespace(c)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is an alphanumeric name, meaning
     * it contains nothing but English letters, numbers, and spaces.
     *
     * @param  name the string to check
     * @return <code>true</code> if the string is an Alphanumeric name;
     *         <code>false</code> otherwise
     */
    public static boolean isAlphanumericName(String name) {
        if (isNull(name)) {
            return false;
        }

        for (char c : name.trim().toCharArray()) {
            if (!isChar(c) && !isDigit(c) && !Character.isWhitespace(c)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the character is in the ASCII character set.
     * This includes characters with integer values between 32 and 126
     * (inclusive).
     *
     * @param  c the character to check
     * @return <code>true</code> if the character is in the ASCII character set;
     *         <code>false</code> otherwise
     */
    public static boolean isAscii(char c) {
        int i = c;

        if ((i >= 32) && (i <= 126)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the character is an upper or lower case
     * English letter.
     *
     * @param  c the character to check
     * @return <code>true</code> if the character is an upper or lower case
     *         English letter; <code>false</code> otherwise
     */
    public static boolean isChar(char c) {
        int x = c;

        if (((x >= _CHAR_LOWER_CASE_BEGIN) && (x <= _CHAR_LOWER_CASE_END))
                || ((x >= _CHAR_UPPER_CASE_BEGIN) && (x <= _CHAR_UPPER_CASE_END))) {

            return true;
        }

        return false;
    }

    /**
     * Returns <code>true</code> if string consists only of upper and lower case
     * English letters.
     *
     * @param  s the string to check
     * @return <code>true</code> if the string consists only of upper and lower
     *         case English letters
     */
    public static boolean isChar(String s) {
        if (isNull(s)) {
            return false;
        }

        for (char c : s.toCharArray()) {
            if (!isChar(c)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the date is valid in the Gregorian calendar.
     *
     * @param  month the month to check
     * @param  day the day to check
     * @return <code>true</code> if the date is valid in the Gregorian calendar;
     *         <code>false</code> otherwise
     */
    public static boolean isDate(int month, int day, int year) {
        return isGregorianDate(month, day, year);
    }

    /**
     * Returns <code>true</code> if the character is a digit between 0 and 9
     * (inclusive).
     *
     * @param  c the character to check
     * @return <code>true</code> if the character is a digit between 0 and 9
     *         (inclusive); <code>false</code> otherwise
     */
    public static boolean isDigit(char c) {
        int x = c;

        if ((x >= _DIGIT_BEGIN) && (x <= _DIGIT_END)) {
            return true;
        }

        return false;
    }

    /**
     * Returns <code>true</code> if the string consists of only digits between 0
     * and 9 (inclusive).
     *
     * @param  s the string to check
     * @return <code>true</code> if the string consists of only digits between 0
     *         and 9 (inclusive); <code>false</code> otherwise
     */
    public static boolean isDigit(String s) {
        if (isNull(s)) {
            return false;
        }

        for (char c : s.toCharArray()) {
            if (!isDigit(c)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is a valid domain name. See
     * RFC-1034 (section 3), RFC-1123 (section 2.1), and RFC-952 (section B.
     * Lexical grammar).
     *
     * @param  domainName the string to check
     * @return <code>true</code> if the string is a valid domain name;
     *         <code>false</code> otherwise
     */
    public static boolean isDomain(String domainName) {

        // See RFC-1034 (section 3), RFC-1123 (section 2.1), and RFC-952
        // (section B. Lexical grammar)

        if (isNull(domainName)) {
            return false;
        }

        if (domainName.length() > 255) {
            return false;
        }

        if (domainName.startsWith(".") || domainName.endsWith(".")) {

            return false;
        }

        if (!domainName.contains(".") && !domainName.equals(_LOCALHOST)) {

            return false;
        }

        String[] domainNameArray = StringUtils.split(domainName, '.');

        for (String domainNamePart : domainNameArray) {
            char[] domainNamePartCharArray = domainNamePart.toCharArray();

            for (int i = 0; i < domainNamePartCharArray.length; i++) {
                char c = domainNamePartCharArray[i];

                if ((i == 0) && (c == '-')) {
                    return false;
                }

                if ((i == (domainNamePartCharArray.length - 1)) && (c == '-')) {

                    return false;
                }

                if ((!isChar(c)) && (!isDigit(c)) && (c != '-')) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is a valid email address.
     *
     * @param  emailAddress the string to check
     * @return <code>true</code> if the string is a valid email address;
     *         <code>false</code> otherwise
     */
    public static boolean isEmailAddress(String emailAddress) {
        Matcher matcher = _emailAddressPattern.matcher(emailAddress);

        return matcher.matches();
    }

    /**
     * Returns <code>true</code> if the character is a special character in an
     * email address.
     *
     * @param  c the character to check
     * @return <code>true</code> if the character is a special character in an
     *         email address; <code>false</code> otherwise
     */
    public static boolean isEmailAddressSpecialChar(char c) {

        // LEP-1445

        for (int i = 0; i < _EMAIL_ADDRESS_SPECIAL_CHAR.length; i++) {
            if (c == _EMAIL_ADDRESS_SPECIAL_CHAR[i]) {
                return true;
            }
        }

        return false;
    }

    /**
     * Returns <code>true</code> if the date is valid in the Gregorian calendar.
     *
     * @param  month the month (0-based, meaning 0 for January)
     * @param  day the day of the month
     * @param  year the year
     * @return <code>true</code> if the date is valid; <code>false</code>
     *         otherwise
     */
    public static boolean isGregorianDate(int month, int day, int year) {
        if ((month < 0) || (month > 11)) {
            return false;
        }

        int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

        if (month == 1) {
            int febMax = 28;

            if (((year % 4) == 0) && ((year % 100) != 0) || ((year % 400) == 0)) {

                febMax = 29;
            }

            if ((day < 1) || (day > febMax)) {
                return false;
            }
        } else if ((day < 1) || (day > months[month])) {
            return false;
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is a hexidecimal number. At
     * present the only requirement is that the string is not <code>null</code>;
     * it does not actually check the format of the string.
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is a hexidecimal number;
     *         <code>false</code> otherwise
     * @see    #isNull(String)
     */
    public static boolean isHex(String s) {
        if (isNull(s)) {
            return false;
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is a valid host name.
     *
     * @param  name the string to check
     * @return <code>true</code> if the string is a valid host name;
     *         <code>false</code> otherwise
     */
    public static boolean isHostName(String name) {
        if (isNull(name)) {
            return false;
        }

        char[] nameCharArray = name.toCharArray();

        if ((nameCharArray[0] == '-') || (nameCharArray[0] == '.')
                || (nameCharArray[nameCharArray.length - 1] == '-')) {

            return false;
        }

        for (char c : nameCharArray) {
            if (!isChar(c) && !isDigit(c) && (c != '-') && (c != '.')) {

                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is an HTML document. The only
     * requirement is that it contain the opening and closing html tags.
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is an HTML document;
     *         <code>false</code> otherwise
     */
    public static boolean isHTML(String s) {
        if (isNull(s)) {
            return false;
        }

        if (((s.indexOf("<html>") != -1) || (s.indexOf("<HTML>") != -1))
                && ((s.indexOf("</html>") != -1) || (s.indexOf("</HTML>") != -1))) {

            return true;
        }

        return false;
    }

    /**
     * Returns <code>true</code> if the string is a valid IPv4 IP address.
     *
     * @param  ipAddress the string to check
     * @return <code>true</code> if the string is an IPv4 IP address;
     *         <code>false</code> otherwise
     */
    public static boolean isIPAddress(String ipAddress) {
        Matcher matcher = _ipAddressPattern.matcher(ipAddress);

        return matcher.matches();
    }

    /**
     * Returns <code>true</code> if the date is valid in the Julian calendar.
     *
     * @param  month the month (0-based, meaning 0 for January)
     * @param  day the day of the month
     * @param  year the year
     * @return <code>true</code> if the date is valid; <code>false</code>
     *         otherwise
     */
    public static boolean isJulianDate(int month, int day, int year) {
        if ((month < 0) || (month > 11)) {
            return false;
        }

        int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

        if (month == 1) {
            int febMax = 28;

            if ((year % 4) == 0) {
                febMax = 29;
            }

            if ((day < 1) || (day > febMax)) {
                return false;
            }
        } else if ((day < 1) || (day > months[month])) {
            return false;
        }

        return true;
    }

    /**
      * Returns <code>true</code> if the string is a name, meaning it contains
      * nothing but English letters and spaces.
      *
      * @param  name the string to check
      * @return <code>true</code> if the string is a name; <code>false</code>
      *         otherwise
      */
    public static boolean isName(String name) {
        if (isNull(name)) {
            return false;
        }

        for (char c : name.trim().toCharArray()) {
            if (!isChar(c) && !Character.isWhitespace(c)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the long number object is not
     * <code>null</code>, meaning it is neither a <code>null</code> reference or
     * zero.
     *
     * @param  l the long number object to check
     * @return <code>true</code> if the long number object is not
     *         <code>null</code>; <code>false</code> otherwise
     */
    public static boolean isNotNull(Long l) {
        return !isNull(l);
    }

    /**
     * Returns <code>true</code> if the object is not <code>null</code>, using
     * the rules from {@link #isNotNull(Long)} or {@link #isNotNull(String)} if
     * the object is one of these types.
     *
     * @param  obj the object to check
     * @return <code>true</code> if the object is not <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNotNull(Object obj) {
        return !isNull(obj);
    }

    /**
     * Returns <code>true</code> if the array is not <code>null</code>, meaning
     * it is neither a <code>null</code> reference or empty.
     *
     * @param  array the array to check
     * @return <code>true</code> if the array is not <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNotNull(Object[] array) {
        return !isNull(array);
    }

    /**
     * Returns <code>true</code> if the string is not <code>null</code>, meaning
     * it is not a <code>null</code> reference, nothing but spaces, or the
     * string "<code>null</code>".
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is not <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNotNull(String s) {
        return !isNull(s);
    }

    /**
     * Returns <code>true</code> if the long number object is <code>null</code>,
     * meaning it is either a <code>null</code> reference or zero.
     *
     * @param  l the long number object to check
     * @return <code>true</code> if the long number object is <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNull(Long l) {
        if ((l == null) || (l.longValue() == 0)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the object is <code>null</code>, using the
     * rules from {@link #isNull(Long)} or {@link #isNull(String)} if the object
     * is one of these types.
     *
     * @param  obj the object to check
     * @return <code>true</code> if the object is <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNull(Object obj) {
        if (obj instanceof Long) {
            return isNull((Long) obj);
        } else if (obj instanceof String) {
            return isNull((String) obj);
        } else if (obj == null) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the array is <code>null</code>, meaning it
     * is either a <code>null</code> reference or empty.
     *
     * @param  array the array to check
     * @return <code>true</code> if the array is <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNull(Object[] array) {
        if ((array == null) || (array.length == 0)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the string is <code>null</code>, meaning it
     * is a <code>null</code> reference, nothing but spaces, or the string
     * "<code>null</code>".
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is <code>null</code>;
     *         <code>false</code> otherwise
     */
    public static boolean isNull(String s) {
        if (s == null) {
            return true;
        }

        int counter = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == ' ') {
                continue;
            } else if (counter > 3) {
                return false;
            }

            if (counter == 0) {
                if (c != 'n') {
                    return false;
                }
            } else if (counter == 1) {
                if (c != 'u') {
                    return false;
                }
            } else if ((counter == 2) || (counter == 3)) {
                if (c != 'l') {
                    return false;
                }
            }

            counter++;
        }

        if ((counter == 0) || (counter == 4)) {
            return true;
        }

        return false;
    }

    /**
     * Returns <code>true</code> if the string is a decimal integer number,
     * meaning it contains nothing but decimal digits.
     *
     * @param  number the string to check
     * @return <code>true</code> if the string is a decimal integer number;
     *         <code>false</code> otherwise
     */
    public static boolean isNumber(String number) {
        if (isNull(number)) {
            return false;
        }

        for (char c : number.toCharArray()) {
            if (!isDigit(c)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns <code>true</code> if the string is a valid password, meaning it
     * is at least four characters long and contains only letters and decimal
     * digits.
     *
     * @return <code>true</code> if the string is a valid password;
     *         <code>false</code> otherwise
     */
    public static boolean isPassword(String password) {
        if (isNull(password)) {
            return false;
        }

        if (password.length() < 4) {
            return false;
        }

        for (char c : password.toCharArray()) {
            if (!isChar(c) && !isDigit(c)) {
                return false;
            }
        }

        return true;
    }

    /**
      * Returns <code>true</code> if the string is a valid variable name in Java.
      *
      * @param  variableName the string to check
      * @return <code>true</code> if the string is a valid variable name in Java;
      *         <code>false</code> otherwise
      */
    public static boolean isVariableName(String variableName) {
        if (isNull(variableName)) {
            return false;
        }

        Matcher matcher = _variableNamePattern.matcher(variableName);

        if (matcher.matches()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the string is a valid variable term, meaning
     * it begins with "[$" and ends with "$]".
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is a valid variable term;
     *         <code>false</code> otherwise
     */
    public static boolean isVariableTerm(String s) {
        if (s.startsWith(_VARIABLE_TERM_BEGIN) && s.endsWith(_VARIABLE_TERM_END)) {

            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the character is whitespace, meaning it is
     * either the <code>null</code> character '0' or whitespace according to
     * {@link Character#isWhitespace(char)}.
     *
     * @param  c the character to check
     * @return <code>true</code> if the character is whitespace;
     *         <code>false</code> otherwise
     */
    public static boolean isWhitespace(char c) {
        int i = c;

        if ((i == 0) || Character.isWhitespace(c)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns <code>true</code> if the string is an XML document. The only
     * requirement is that it contain either the xml start tag "<?xml" or the
     * empty document tag "<root />".
     *
     * @param  s the string to check
     * @return <code>true</code> if the string is an XML document;
     *         <code>false</code> otherwise
     */
    public static boolean isXml(String s) {
        if (s.startsWith(_XML_BEGIN) || s.startsWith(_XML_EMPTY)) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean isValidArticleId(String articleId) {
        return (articleId == null || articleId.length() == 0) || !isNumber(articleId);
    }

    private static final int _CHAR_LOWER_CASE_BEGIN = 97;

    private static final int _CHAR_LOWER_CASE_END = 122;

    private static final int _CHAR_UPPER_CASE_BEGIN = 65;

    private static final int _CHAR_UPPER_CASE_END = 90;

    private static final int _DIGIT_BEGIN = 48;

    private static final int _DIGIT_END = 57;

    private static final char[] _EMAIL_ADDRESS_SPECIAL_CHAR = new char[] { '.', '!', '#', '$', '%', '&', '\'', '*',
            '+', '-', '/', '=', '?', '^', '_', '`', '{', '|', '}', '~' };

    private static final String _LOCALHOST = "localhost";

    private static final String _VARIABLE_TERM_BEGIN = "[$";

    private static final String _VARIABLE_TERM_END = "$]";

    private static final String _XML_BEGIN = "<?xml";

    private static final String _XML_EMPTY = "<root />";

    private static Pattern _emailAddressPattern = Pattern
            .compile("[\\w!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^_`{|}~-]+)*@"
                    + "(?:[\\w](?:[\\w-]*[\\w])?\\.)+[\\w](?:[\\w-]*[\\w])?");
    private static Pattern _ipAddressPattern = Pattern
            .compile("\\b" + "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\."
                    + "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\."
                    + "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\."
                    + "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])" + "\\b");
    private static Pattern _variableNamePattern = Pattern.compile("[_a-zA-Z]+[_a-zA-Z0-9]*");

}