ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/FacsimileTelephoneNumberSyntaxChecker.java - directory-ldap-api - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you under the Apache License, Version 2.0 (the
  *  "License"); you may not use this file except in compliance
  *  with the License.  You may obtain a copy of the License at
  *
  *    https://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing,
  *  software distributed under the License is distributed on an
  *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *  KIND, either express or implied.  See the License for the
  *  specific language governing permissions and limitations
  *  under the License.
  *
  */
 package org.apache.directory.api.ldap.model.schema.syntaxCheckers;


 import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

 import org.apache.directory.api.i18n.I18n;
 import org.apache.directory.api.ldap.model.constants.SchemaConstants;
 import org.apache.directory.api.ldap.model.schema.SyntaxChecker;
 import org.apache.directory.api.util.Strings;


 /**
  * A SyntaxChecker which verifies that a value is a facsimile TelephoneNumber according
  * to ITU recommendation E.123 for the Telephone number part, and from RFC 4517, par.
  * 3.3.11 :
  *
  * <pre>
  * fax-number       = telephone-number *( DOLLAR fax-parameter )
  * telephone-number = PrintableString
  * fax-parameter    = "twoDimensional" |
  *                    "fineResolution" |
  *                    "unlimitedLength" |
  *                    "b4Length" |
  *                    "a3Width" |
  *                    "b4Width" |
  *                    "uncompressed"
  * </pre>
  *
  * If needed, and to allow more syntaxes, a list of regexps has been added
  * which can be initialized to other values
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  */
 @SuppressWarnings("serial")
 public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
 {
     /** The default pattern used to check a TelephoneNumber */
     private static final String DEFAULT_REGEXP = "^ *[+]? *((\\([0-9- ,;/#*]+\\))|[0-9- ,;/#*]+)+$";

     /** The compiled default pattern */
     private String defaultRegexp;

     /** The compiled default pattern */
     private Pattern defaultPattern = Pattern.compile( DEFAULT_REGEXP );

     /** Fax parameters possible values */
     private static final String TWO_DIMENSIONAL = "twoDimensional";
     private static final String FINE_RESOLUTION = "fineResolution";
     private static final String UNLIMITED_LENGTH = "unlimitedLength";
     private static final String B4_LENGTH = "b4Length";
     private static final String A3_LENGTH = "a3Width";
     private static final String B4_WIDTH = "b4Width";
     private static final String UNCOMPRESSED = "uncompressed";

     /** A set which contains all the possible fax parameters values */
     private static Set<String> faxParameters = new HashSet<>();

     /** Initialization of the fax parameters set of values */
     static
     {
         faxParameters.add( Strings.toLowerCaseAscii( TWO_DIMENSIONAL ) );
         faxParameters.add( Strings.toLowerCaseAscii( FINE_RESOLUTION ) );
         faxParameters.add( Strings.toLowerCaseAscii( UNLIMITED_LENGTH ) );
         faxParameters.add( Strings.toLowerCaseAscii( B4_LENGTH ) );
         faxParameters.add( Strings.toLowerCaseAscii( A3_LENGTH ) );
         faxParameters.add( Strings.toLowerCaseAscii( B4_WIDTH ) );
         faxParameters.add( Strings.toLowerCaseAscii( UNCOMPRESSED ) );
     }

     /**
      * A static instance of FacsimileTelephoneNumberSyntaxChecker
      */
     public static final FacsimileTelephoneNumberSyntaxChecker INSTANCE =
         new FacsimileTelephoneNumberSyntaxChecker( SchemaConstants.FACSIMILE_TELEPHONE_NUMBER_SYNTAX );

     /**
      * A static Builder for this class
      */
     public static final class Builder extends SCBuilder<FacsimileTelephoneNumberSyntaxChecker>
     {
         /** The compiled default pattern */
         private String defaultRegexp;

         /** The compiled default pattern */
         private Pattern defaultPattern;

         /**
          * The Builder constructor
          */
         private Builder()
         {
             super( SchemaConstants.FACSIMILE_TELEPHONE_NUMBER_SYNTAX );
             setDefaultRegexp( DEFAULT_REGEXP );
         }


         /**
          * Create a new instance of FacsimileTelephoneNumberSyntaxChecker
          *
          * @return A new instance of FacsimileTelephoneNumberSyntaxChecker
          */
         @Override
         public FacsimileTelephoneNumberSyntaxChecker build()
         {
             return new FacsimileTelephoneNumberSyntaxChecker( oid, defaultRegexp, defaultPattern );
         }


         /**
          * Set the default regular expression for the Telephone number
          *
          * @param regexp the default regular expression.
          * @return The FacsimileTelephneNumber Builder instance
          */
         public Builder setDefaultRegexp( String regexp )
         {
             defaultRegexp = regexp;

             try
             {
                 defaultPattern = Pattern.compile( regexp );
             }
             catch ( PatternSyntaxException pse )
             {
                 // Roll back to the default pattern
                 defaultPattern = Pattern.compile( DEFAULT_REGEXP );
             }

             return this;
         }
     }


     /**
      * Creates a new instance of TelephoneNumberSyntaxChecker.
      *
      * @param oid the OID
      */
     private FacsimileTelephoneNumberSyntaxChecker( String oid )
     {
         super( oid );
     }


     /**
      * Creates a new instance of TelephoneNumberSyntaxChecker.
      *
      * @param oid The OID
      * @param defaultRegexp the default regexp to use
      * @param defaultPattern The default pattern to use
      */
     private FacsimileTelephoneNumberSyntaxChecker( String oid, String defaultRegexp, Pattern defaultPattern )
     {
         super( oid );

         this.defaultPattern = defaultPattern;
         this.defaultRegexp = defaultRegexp;
     }


     /**
      * @return An instance of the Builder for this class
      */
     public static Builder builder()
     {
         return new Builder();
     }


     /**
      * Get the default regexp (either the original one, or the one that has been set)
      *
      * @return The default regexp
      */
     public String getRegexp()
     {
         if ( defaultRegexp == null )
         {
             return DEFAULT_REGEXP;
         }
         else
         {
             return defaultRegexp;
         }
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isValidSyntax( Object value )
     {
         String strValue;

         if ( value == null )
         {
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, "null" ) );
             }

             return false;
         }

         if ( value instanceof String )
         {
             strValue = ( String ) value;
         }
         else if ( value instanceof byte[] )
         {
             strValue = Strings.utf8ToString( ( byte[] ) value );
         }
         else
         {
             strValue = value.toString();
         }

         if ( strValue.length() == 0 )
         {
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
             }

             return false;
         }

         // The facsimile telephone number might be composed
         // of two parts separated by a '$'.
         int dollarPos = strValue.indexOf( '$' );

         if ( dollarPos == -1 )
         {
             // We have no fax-parameter : check the Telephone number
             boolean result = defaultPattern.matcher( strValue ).matches();

             if ( LOG.isDebugEnabled() )
             {
                 if ( result )
                 {
                     LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
                 }
                 else
                 {
                     LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
                 }
             }

             return result;
         }

         // First check the telephone number if the '$' is not at the first position
         if ( dollarPos > 0 )
         {
             boolean result = defaultPattern.matcher( strValue.substring( 0, dollarPos - 1 ) ).matches();

             if ( LOG.isDebugEnabled() )
             {
                 if ( result )
                 {
                     LOG.debug( I18n.err( I18n.MSG_13701_SYNTAX_VALID, value ) );
                 }
                 else
                 {
                     LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );

                     return false;
                 }
             }

             // Now, try to validate the fax-parameters : we may
             // have more than one, so we will store the seen params
             // in a set to check that we don't have the same param twice
             Set<String> paramsSeen = new HashSet<>();

             while ( dollarPos > 0 )
             {
                 String faxParam;
                 int newDollar = strValue.indexOf( '$', dollarPos + 1 );

                 if ( newDollar == -1 )
                 {
                     faxParam = strValue.substring( dollarPos + 1 );
                 }
                 else
                 {
                     faxParam = strValue.substring( dollarPos + 1, newDollar );
                 }

                 if ( faxParam.length() == 0 )
                 {
                     // Not allowed
                     if ( LOG.isDebugEnabled() )
                     {
                         LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
                     }

                     return false;
                 }

                 // Relax a little bit the syntax by lowercasing the param
                 faxParam = Strings.toLowerCaseAscii( faxParam );

                 if ( !faxParameters.contains( faxParam ) || paramsSeen.contains( faxParam ) )
                 {
                     // This parameter is not in the possible set
                     if ( LOG.isDebugEnabled() )
                     {
                         LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
                     }

                     return false;
                 }
                 else
                 {
                     // It's a correct param, let's add it to the seen
                     // params.
                     paramsSeen.add( faxParam );
                 }

                 dollarPos = newDollar;
             }

             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
             }

             return true;
         }

         // We must have a valid telephone number !
         if ( LOG.isDebugEnabled() )
         {
             LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
         }

         return false;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* https://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/
	package org.apache.directory.api.ldap.model.schema.syntaxCheckers;


	import java.util.HashSet;
	import java.util.Set;
	import java.util.regex.Pattern;
	import java.util.regex.PatternSyntaxException;

	import org.apache.directory.api.i18n.I18n;
	import org.apache.directory.api.ldap.model.constants.SchemaConstants;
	import org.apache.directory.api.ldap.model.schema.SyntaxChecker;
	import org.apache.directory.api.util.Strings;


	/**
	* A SyntaxChecker which verifies that a value is a facsimile TelephoneNumber according
	* to ITU recommendation E.123 for the Telephone number part, and from RFC 4517, par.
	* 3.3.11 :
	*
	* <pre>
	* fax-number = telephone-number *( DOLLAR fax-parameter )
	* telephone-number = PrintableString
	* fax-parameter = "twoDimensional" \|
	* "fineResolution" \|
	* "unlimitedLength" \|
	* "b4Length" \|
	* "a3Width" \|
	* "b4Width" \|
	* "uncompressed"
	* </pre>
	*
	* If needed, and to allow more syntaxes, a list of regexps has been added
	* which can be initialized to other values
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	*/
	@SuppressWarnings("serial")
	public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
	{
	/** The default pattern used to check a TelephoneNumber */
	private static final String DEFAULT_REGEXP = "^ [+]? ((\\([0-9- ,;/#]+\\))\|[0-9- ,;/#]+)+$";

	/** The compiled default pattern */
	private String defaultRegexp;

	/** The compiled default pattern */
	private Pattern defaultPattern = Pattern.compile( DEFAULT_REGEXP );

	/** Fax parameters possible values */
	private static final String TWO_DIMENSIONAL = "twoDimensional";
	private static final String FINE_RESOLUTION = "fineResolution";
	private static final String UNLIMITED_LENGTH = "unlimitedLength";
	private static final String B4_LENGTH = "b4Length";
	private static final String A3_LENGTH = "a3Width";
	private static final String B4_WIDTH = "b4Width";
	private static final String UNCOMPRESSED = "uncompressed";

	/** A set which contains all the possible fax parameters values */
	private static Set<String> faxParameters = new HashSet<>();

	/** Initialization of the fax parameters set of values */
	static
	{
	faxParameters.add( Strings.toLowerCaseAscii( TWO_DIMENSIONAL ) );
	faxParameters.add( Strings.toLowerCaseAscii( FINE_RESOLUTION ) );
	faxParameters.add( Strings.toLowerCaseAscii( UNLIMITED_LENGTH ) );
	faxParameters.add( Strings.toLowerCaseAscii( B4_LENGTH ) );
	faxParameters.add( Strings.toLowerCaseAscii( A3_LENGTH ) );
	faxParameters.add( Strings.toLowerCaseAscii( B4_WIDTH ) );
	faxParameters.add( Strings.toLowerCaseAscii( UNCOMPRESSED ) );
	}

	/**
	* A static instance of FacsimileTelephoneNumberSyntaxChecker
	*/
	public static final FacsimileTelephoneNumberSyntaxChecker INSTANCE =
	new FacsimileTelephoneNumberSyntaxChecker( SchemaConstants.FACSIMILE_TELEPHONE_NUMBER_SYNTAX );

	/**
	* A static Builder for this class
	*/
	public static final class Builder extends SCBuilder<FacsimileTelephoneNumberSyntaxChecker>
	{
	/** The compiled default pattern */
	private String defaultRegexp;

	/** The compiled default pattern */
	private Pattern defaultPattern;

	/**
	* The Builder constructor
	*/
	private Builder()
	{
	super( SchemaConstants.FACSIMILE_TELEPHONE_NUMBER_SYNTAX );
	setDefaultRegexp( DEFAULT_REGEXP );
	}


	/**
	* Create a new instance of FacsimileTelephoneNumberSyntaxChecker
	*
	* @return A new instance of FacsimileTelephoneNumberSyntaxChecker
	*/
	@Override
	public FacsimileTelephoneNumberSyntaxChecker build()
	{
	return new FacsimileTelephoneNumberSyntaxChecker( oid, defaultRegexp, defaultPattern );
	}


	/**
	* Set the default regular expression for the Telephone number
	*
	* @param regexp the default regular expression.
	* @return The FacsimileTelephneNumber Builder instance
	*/
	public Builder setDefaultRegexp( String regexp )
	{
	defaultRegexp = regexp;

	try
	{
	defaultPattern = Pattern.compile( regexp );
	}
	catch ( PatternSyntaxException pse )
	{
	// Roll back to the default pattern
	defaultPattern = Pattern.compile( DEFAULT_REGEXP );
	}

	return this;
	}
	}


	/**
	* Creates a new instance of TelephoneNumberSyntaxChecker.
	*
	* @param oid the OID
	*/
	private FacsimileTelephoneNumberSyntaxChecker( String oid )
	{
	super( oid );
	}


	/**
	* Creates a new instance of TelephoneNumberSyntaxChecker.
	*
	* @param oid The OID
	* @param defaultRegexp the default regexp to use
	* @param defaultPattern The default pattern to use
	*/
	private FacsimileTelephoneNumberSyntaxChecker( String oid, String defaultRegexp, Pattern defaultPattern )
	{
	super( oid );

	this.defaultPattern = defaultPattern;
	this.defaultRegexp = defaultRegexp;
	}


	/**
	* @return An instance of the Builder for this class
	*/
	public static Builder builder()
	{
	return new Builder();
	}


	/**
	* Get the default regexp (either the original one, or the one that has been set)
	*
	* @return The default regexp
	*/
	public String getRegexp()
	{
	if ( defaultRegexp == null )
	{
	return DEFAULT_REGEXP;
	}
	else
	{
	return defaultRegexp;
	}
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public boolean isValidSyntax( Object value )
	{
	String strValue;

	if ( value == null )
	{
	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, "null" ) );
	}

	return false;
	}

	if ( value instanceof String )
	{
	strValue = ( String ) value;
	}
	else if ( value instanceof byte[] )
	{
	strValue = Strings.utf8ToString( ( byte[] ) value );
	}
	else
	{
	strValue = value.toString();
	}

	if ( strValue.length() == 0 )
	{
	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
	}

	return false;
	}

	// The facsimile telephone number might be composed
	// of two parts separated by a '$'.
	int dollarPos = strValue.indexOf( '$' );

	if ( dollarPos == -1 )
	{
	// We have no fax-parameter : check the Telephone number
	boolean result = defaultPattern.matcher( strValue ).matches();

	if ( LOG.isDebugEnabled() )
	{
	if ( result )
	{
	LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
	}
	else
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
	}
	}

	return result;
	}

	// First check the telephone number if the '$' is not at the first position
	if ( dollarPos > 0 )
	{
	boolean result = defaultPattern.matcher( strValue.substring( 0, dollarPos - 1 ) ).matches();

	if ( LOG.isDebugEnabled() )
	{
	if ( result )
	{
	LOG.debug( I18n.err( I18n.MSG_13701_SYNTAX_VALID, value ) );
	}
	else
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );

	return false;
	}
	}

	// Now, try to validate the fax-parameters : we may
	// have more than one, so we will store the seen params
	// in a set to check that we don't have the same param twice
	Set<String> paramsSeen = new HashSet<>();

	while ( dollarPos > 0 )
	{
	String faxParam;
	int newDollar = strValue.indexOf( '$', dollarPos + 1 );

	if ( newDollar == -1 )
	{
	faxParam = strValue.substring( dollarPos + 1 );
	}
	else
	{
	faxParam = strValue.substring( dollarPos + 1, newDollar );
	}

	if ( faxParam.length() == 0 )
	{
	// Not allowed
	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
	}

	return false;
	}

	// Relax a little bit the syntax by lowercasing the param
	faxParam = Strings.toLowerCaseAscii( faxParam );

	if ( !faxParameters.contains( faxParam ) \|\| paramsSeen.contains( faxParam ) )
	{
	// This parameter is not in the possible set
	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
	}

	return false;
	}
	else
	{
	// It's a correct param, let's add it to the seen
	// params.
	paramsSeen.add( faxParam );
	}

	dollarPos = newDollar;
	}

	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
	}

	return true;
	}

	// We must have a valid telephone number !
	if ( LOG.isDebugEnabled() )
	{
	LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
	}

	return false;
	}
	}