Source code: com/aendvari/griffin/validation/dataset/Property.java

   /*
    * Property.java
    *
    * Copyright (c) 2001, 2002 Aendvari, Ltd. All Rights Reserved.
    *
    * See the file LICENSE for terms of use.
    *
    */
   
  package com.aendvari.griffin.validation.dataset;
  
  import java.io.*;
  import java.util.*;
  import java.beans.*;
  
  import java.lang.reflect.*;
  import java.lang.NoSuchMethodException;
  import java.lang.IllegalAccessException;
  
  import com.aendvari.common.util.*;
  
  import com.aendvari.common.model.*;
  
  import com.aendvari.griffin.validation.*;
  import com.aendvari.griffin.validation.validator.*;
  
  
  /**
   * <p>Defines a {@link Property}.</p>
   *
   * <p>A property is a single item in which a validation is wish to be run upon.</p>
   *
   * @author  Scott Milne
   *
   */
  
  public class Property
  {
    /* Constants */
  
    /** Constants for the type of the property. */
    public interface Type
    {
      public static String None        = "";
      public static String Collection      = "collection";
    }
  
  
    /* Variables */
  
    /** The path to retrieve the value of the property. */
    private String path;
  
    /** The type of the property. */
    private String type;
  
    /**
     * The value of the property. This is only set within executeValidation and the value
     * is derived from the ModelNode that is passed into that method call.
     *
     */
    private Object value;
  
    /** The name of the {@link Validator} in which to call on this property. */
    private String validator;
  
    /** A <code>HashMap</code> of name/{@link ParameterDefine} pairs for the validator's method. */
    private HashMap validatorParameterDefines;
  
    /** The name of the {@link ErrorHandler} in which to call on this property. */
    private String errorHandler;
  
    /** A <code>HashMap</code> of name/{@link ParameterDefine} pairs for the error handler's method. */
    private HashMap errorHandlerParameterDefines;
  
  
    /* Constructors. */
  
  
    /**
     * Constructs an empty <code>Validator</code> instance.
     *
     */
  
    public Property()
    {
      validatorParameterDefines = new HashMap();
      errorHandlerParameterDefines = new HashMap();
  
      path = "";
      value = null;
      type = Type.None;
      validator = "";
    }
  
  
    /* Accessors */
  
    /**
    * Get the value of the property.
    *
    */
   public Object getValue()
   {
     return value;
   }
 
   /**
    * Get the path of the property.
    *
    * @return                  A string representing the path of the property.
    *
    */
 
   public String getPath()
   {
     return path;
   }
 
   /**
    * Set the path of the property.
    *
    * @param    setPath            A string representing the path of the property.
    *
    */
 
   public void setPath( String setPath )
   {
     path = setPath;
   }
 
   /**
    * Get the type of the property.
    *
    * @return                  A string representing the type of the property.
    *
    */
 
   public String getType()
   {
     return type;
   }
 
   /**
    * Set the type of the property.
    *
    * @param    setType            A string representing the type of the property.
    *
    */
 
   public void setType( String setType )
   {
     type = setType;
   }
 
   /**
    * Get the validator of the property.
    *
    * @return                  A string representing the validator of the property.
    *
    */
 
   public String getValidator()
   {
     return validator;
   }
 
   /**
    * Set the validator of the property.
    *
    * @param    setValidator        A string representing the validator of the property.
    *
    */
 
   public void setValidator( String setValidator )
   {
     validator = setValidator;
   }
 
   /**
    * Get the validator of the property.
    *
    * @return                  A string representing the validator of the property.
    *
    */
 
   public String setErrorHandler()
   {
     return errorHandler;
   }
 
   /**
    * Set the error handler of the property.
    *
    * @param    setErrorHandler        A string representing the error handler of the property.
    *
    */
 
   public void setErrorHandler( String setErrorHandler )
   {
     errorHandler = setErrorHandler;
   }
 
   /**
    * Add a validator parameter.
    *
    * @param    name            The name of the parameter define.
    * @param    value            The {@link ParameterDefine} instance for the parameter.
    *
    */
 
   public void setValidatorParameterDefine( String name, ParameterDefine value )
   {
     validatorParameterDefines.put(name, value);
   }
 
   /**
    * Get a validator parameter.
    *
    * @return                  A {@link ParameterDefine} of the parameter.
    *
    */
 
   public ParameterDefine getValidatorParameterDefine( String name )
   {
     return (ParameterDefine)validatorParameterDefines.get(name);
   }
 
   /**
    * Add a validator parameter.
    *
    * @param    name            The name of the parameter define.
    * @param    value            The {@link ParameterDefine} instance for the parameter.
    *
    */
 
   public void setErrorHandlerParameterDefine( String name, ParameterDefine value )
   {
     errorHandlerParameterDefines.put(name, value);
   }
 
   /**
    * Get a validator parameter.
    *
    * @param    name            The key for the error handler define.
    *
    * @return                  A {@link ParameterDefine} of the parameter.
    *
    */
 
   public ParameterDefine getErrorHandlerParameterDefine( String name )
   {
     return (ParameterDefine)errorHandlerParameterDefines.get(name);
   }
 
   /**
    * Sets the parameter values for each of the handlers' {@link ParameterDefine}.
    * The values of the parameter are derived from the defined values of this property.
    *
    * @param    modelTree          The {@link ModelTree} of which to do xpath queries.
    * @param    datasetNode          The {@link ModelNode} of which to extract the data to be validated from.
    * @param    Object            The default value as an <code>Object</code>.
    * @param    handler            A {@link ValidationHandler} instance.
    *
    */
 
   private void adjustParameters( ModelTree modelTree, ModelNode datasetNode, Object defaultValue, Handler handler )
   {
     // extract the values for each ParameterDefine
     Iterator paramIterator = null;
 
     if (handler instanceof Validator)
     {
       paramIterator = validatorParameterDefines.values().iterator();
     }
     else
     {
       paramIterator = errorHandlerParameterDefines.values().iterator();
     }
 
     while ( paramIterator.hasNext() )
     {
       ParameterDefine param = (ParameterDefine)paramIterator.next();
 
       // if the param type is property
       if (param.getType().equals(ParameterDefine.Type.Property))
       {
         param.setValue(defaultValue);
       }
       // if there is a valid xpath
       else if (!param.getPath().equals(""))
       {
         // if the type is collection, collect all the xpath values
         // and set the param type to this collection
         if (param.getType().equals(ParameterDefine.Type.Collection))
         {
           ArrayList propertyParams = new ArrayList();
 
           // collect a list of all the items (could be only 1)
           // and run this validation on each one.
           Iterator iterator = modelTree.getNodes(datasetNode, param.getPath()).iterator();
 
           // if there were item(s) selected
           if (iterator.hasNext())
           {
             while ( iterator.hasNext() )
             {
               ModelNode valueNode = (ModelNode)iterator.next();
 
               String tmpValue = valueNode.getNodeValue();
 
               propertyParams.add(tmpValue);
             }
 
             param.setValue( propertyParams );
           }
         }
         // the type is not collection, so even if the xpath returns more than
         // one value, only use the first one found
         else
         {
           // get the node list
           Iterator iterator = modelTree.getNodes(datasetNode, param.getPath()).iterator();
 
           // if there were item(s) selected
           if (iterator.hasNext())
           {
             ModelNode paramValueNode = (ModelNode)iterator.next();
 
             if (paramValueNode != null)
             {
               param.setValue( paramValueNode.getNodeValue() );
             }
           }
         }
       }
 
       // add this altered parameter to the handler list of defined params
       handler.setParameterDefine( param.getName(), param );
     }
   }
 
   /**
    * Gets the matching {@link Validator} instance from the collection of instances.
    *
    * The matching {@link Validator} is found by matching the names of the {@link ParameterDefine}'s
    * of this <code>Property</code> and {@link MethodDefine}'s of the {@link Validator}.
    *
    * @param    list            The list of {@link Validator} instances.
    *
    */
 
   private Validator getMatchingValidator( Collection list )
   {
     Validator validator = null;
     
     Collection thisValues = validatorParameterDefines.values();
   
     Iterator iterator = list.iterator();
     while (iterator.hasNext())
     {
       Validator tempValidator = (Validator)iterator.next();
 
       // get the HandlerMethod of this validator
       HandlerMethod method = tempValidator.getValidateMethod();
 
       // get the list of params for this handler
       Collection params = method.getParameters();
       
       // create a temp list of params
       ArrayList tempParams = new ArrayList(params);
 
       // loop through the param defines, and it a match is found, remove it from the tempParams
       Iterator paramIterator = thisValues.iterator();
       while (paramIterator.hasNext())
       {
         ParameterDefine paramDefine = (ParameterDefine)paramIterator.next();
         
         Iterator tempParamsIter = tempParams.iterator();
         while (tempParamsIter.hasNext())
         {
           MethodParameter methodParam = (MethodParameter)tempParamsIter.next();
           
           if (methodParam.getName().equals(paramDefine.getName()))
           {
             int index = tempParams.indexOf(methodParam);
             tempParams.remove(index);
             break;
           }
         }
       }
       
       // if nothing is left inside the tempParams list return this validator
       if (tempParams.size() == 0)
       {
         validator = tempValidator;
       }
     }
 
     return validator;
   }
   
   /**
    * Executes this classes' part of a <code>Dataset</code> validation.
    *
    * @param    datasetNode          The {@link ModelNode} of which to extract the data to be validated from.
    * @param    validators          A <code>MultiHashMap</code> of {@link Validator} instances.
    * @param    handlers          A <code>HashMap</code> of {@link ValidationHandler} instances.
    *
    */
 
   public void executeValidation( ModelNode datasetNode, MultiHashMap validators, HashMap handlers )
     throws Exception
   {
     // get the validator instance derived from the configuration
     Collection collisionList = validators.getCollisionList(validator);
     Validator validatorInstance = getMatchingValidator(collisionList);
 
     // in case an incorrect name of validator is used
     if (validatorInstance == null )
     {
       throw new Exception("[executeValidation] Validator \""+validator+"\" could not be found.");
     }
 
     // get the error handler instance derived from the configuration
     ErrorHandler errorHandlerInstance = (ErrorHandler)handlers.get(errorHandler);
 
     // in case an incorrect name of validator is used
     if (errorHandlerInstance == null )
     {
       throw new Exception("[executeValidation] ErrorHandler \""+errorHandler+"\" could not be found.");
     }
 
     // get the owner ModelTree of the node so it can be used for querying other nodes
     ModelTree modelTree = datasetNode.getOwnerModelTree();
 
     //
     // extract the value of the property from the datasetNode
     //
 
     // if the type is collection, make a collection from the nodes
     if (type.equals(Property.Type.Collection) )
     {
       ArrayList propertyParams = new ArrayList();
 
       // collect a list of all the items (could be only 1)
       // and run this validation on each one.
       Iterator iterator = modelTree.getNodes(datasetNode, path).iterator();
 
       // if there were item(s) selected
       if (iterator.hasNext())
       {
         while ( iterator.hasNext() )
         {
           ModelNode valueNode = (ModelNode)iterator.next();
 
           String tmpValue = valueNode.getNodeValue();
 
           propertyParams.add(tmpValue);
         }
       }
 
       // set the property value
       value = propertyParams;
 
       // set the parameters for this handler from the parameters available in this property
       adjustParameters(modelTree, datasetNode, value, validatorInstance);
 
       // execute the handler
       boolean bSuccessful = validatorInstance.executeValidation( this, handlers );
 
       // if the validation failed, call the error message
       if (!bSuccessful)
       {
         // set the parameters for this handler from the parameters available in this property
         adjustParameters(modelTree, datasetNode, value, errorHandlerInstance);
 
         // execute the handler
         errorHandlerInstance.executeValidation( this, handlers );
       }
     }
     else
     {
       // collect a list of all the items (could be only 1)
       // and run this validation on each one.
       Iterator iterator = modelTree.getNodes(datasetNode, path).iterator();
 
       // if there were item(s) selected
       if (iterator.hasNext())
       {
         while ( iterator.hasNext() )
         {
           ModelNode valueNode = (ModelNode)iterator.next();
 
           value = valueNode.getNodeValue();
 
           // set the parameters for this handler from the parameters available in this property
           adjustParameters(modelTree, datasetNode, value, validatorInstance);
 
           // execute the handler
           boolean bSuccessful = validatorInstance.executeValidation( this, handlers );
 
           // if the validation failed, call the error message
           if (!bSuccessful)
           {
             // set the parameters for this handler from the parameters available in this property
             adjustParameters(modelTree, datasetNode, value, errorHandlerInstance);
 
             // execute the handler
             errorHandlerInstance.executeValidation( this, handlers );
           }
         }
       }
       // the property was empty, so it's still ok
       else
       {
         value = "";
 
         // set the parameters for this handler from the parameters available in this property
         adjustParameters(modelTree, datasetNode, value, validatorInstance);
 
         // execute the handler
         boolean bSuccessful = validatorInstance.executeValidation( this, handlers );
 
         // if the validation failed, call the error message
         if (!bSuccessful)
         {
           // set the parameters for this handler from the parameters available in this property
           adjustParameters(modelTree, datasetNode, value, errorHandlerInstance);
 
           // execute the handler
           errorHandlerInstance.executeValidation( this, handlers );
         }
       }
     }
   }
 
   /**
    * Convert this object into a String representation.
    *
    */
 
   public String toString()
   {
     String data = "Property[";
     data += "path="+path + ",";
     data += "value="+value + ",";
     data += "type="+type + ",";
     data += "validator="+validator + ",";
     data += "errorHandler="+errorHandler + ",";
     data += "]";
     return data;
   }
 }