Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
   * Copyright 2011 The Kuali Foundation
   *
   * Licensed under the Educational Community 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
   *
   * 	http://www.osedu.org/licenses/ECL-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.kuali.student.r2.common.datadictionary.util;
 
 
 import java.util.Date;
 import java.util.List;

 
A class that validates the criteria against the dictionary It also sets the parsedValues and parsedOperators so they may be used in the implementation The call sequence is sometehing like this:
  1. construct this validator
  2. Configure this validator with criteria to be valiated
  3. Get the dictionary entry of the object to be validated by calling DataDictionaryServiceInfc.getDataDictionaryEntry (the ref object's URI)
  4. Configure this validator with the dictionary entry that you just got from the dictionary
  5. Call the validate () method which will throw exceptions if problems
  6. get the parsed values (@see getParsedValues ()) and use them in the implementation
  7. Get the parsed operators and use in the implementation, if you want

Author(s):
nwright
 
 public class CriteriaValidatorParser {
 
     public enum Operator {
 
         EQ, IN, GT, LT, NEQ, GTE, LTE, LIKE, BETWEEN;
     }
     private Criteria criteria;
     private DictionaryEntry dictionaryEntry;
     private transient List<ObjectparsedValues;
     private transient List<OperatorparsedOperators;
 
     public CriteriaValidatorParser() {
     }
 
     public Criteria getCriteria() {
         return ;
     }
 
     public void setCriteria(Criteria criteria) {
         this. = criteria;
     }
 
     public DictionaryEntry getDictionaryEntry() {
         return ;
     }
 
     public void setDictionaryEntry(DictionaryEntry dictionaryEntry) {
         this. = dictionaryEntry;
     }

    
Get the string operators translated as an Operator enum

Returns:
list of operators in the same ordinal position as the supplied operators in the list of ComparisonInfc objects
 
     public List<OperatorgetParsedOperators() {
         return ;
     }

    
The values parsed as their respective data types, String, Date, Integer, etc. Special considerations: IN operators return a List of one or more parsed values who's order is the samne as the order in the ComparisonInfc BETWEEN operators return a list of two parsed values who's values coorespond to the from to values of a between operation.

Returns:
a list of parsed values in the same ordinal positions as the unparsed values in the list of ComparisonInfc objects
 
     public List<ObjectgetParsedValues() {
         return ;
     }



    
Validate the criteria thowing an InvalidParameterException if there are problems TODO: Consider getting all the errors and throw them as a group instead of as we find them

    public void validate()
            throws InvalidParameterException,
            OperationFailedException {
         = new ArrayList<Object>();
         = new ArrayList <Operator> ();
        if (this..getComparisons() == null) {
            throw new InvalidParameterException ("Comparisons list is null -- to select all specify an empty list");
        }
        int i = 0;
        for (Comparison comparison : this..getComparisons()) {
            this.validate(icomparison);
            i++;
        }
    }
    private void validate(int iComparison comparison)
            throws InvalidParameterException,
            OperationFailedException {
        String fieldKey = comparison.getFieldKey();
        String operator = comparison.getOperator();
        List<Stringvalues = comparison.getValues();
        AttributeDefinitionInfc ad = this.getAttributeDefinition(fieldKey);
        if (ad == null) {
            throw new InvalidParameterException("The " + i + "th comparison's field key " + fieldKey + " is not defined in the dictionary");
        }
        if (operator == null) {
            throw new InvalidParameterException("The " + i + "th comparison's operator is null");
        }
        if (operator.equals("=")) {
            this..add(.);
        } else if (operator.equals("<")) {
            this..add(.);
        } else if (operator.equals(">")) {
            this..add(.);
        } else if (operator.equals("!=")) {
            this..add(.);
        } else if (operator.equals("<=")) {
            this..add(.);
        } else if (operator.equals(">=")) {
            this..add(.);
        } else if (operator.equals("in")) {
            this..add(.);
        } else if (operator.equals("between")) {
            this..add(.);
        } else if (operator.equals("like")) {
            this..add(.);
            if (ad.getDataType().equals (.)) {
            throw new InvalidParameterException("The " + i + "th comparison's operator is LIKE which can only be applied to strings, " + ad.getDataType() + " is invalid.");
            }
        } else {
            throw new InvalidParameterException("The " + i + "th comparison's operator, " + operator + ", is invalid.");
        }
        if (values == null) {
            throw new InvalidParameterException("The " + i + "th comparison's values list is required and cannot be null");
        }
        if (values.isEmpty()) {
            throw new InvalidParameterException("The " + i + "th comparison's values list is required and cannot be an empty list");
        }
        if (values.get(0) == null) {
            if (!operator.equals("=") && !operator.equals("!=")) {
                throw new InvalidParameterException("The " + i + "th comparison's value is null but the operator " + operator + " is a comparison operator that does not apply");
            }
            return;
        }
        if (operator.equals("between")) {
            if (values.size() != 2) {
                throw new InvalidParameterException("The " + i + "th comparison is a between operator which requires two values, found " + values.size());
            }
            if (values.get(0) == null) {
                throw new InvalidParameterException("The " + i + "th comparison is a between operator but the first value is null");
            }
            if (values.get(1) == null) {
                throw new InvalidParameterException("The " + i + "th comparison is a between operator but the second value is null");
            }
        } else if (values.size() > 1) {
            if (!operator.equals("in")) {
                throw new InvalidParameterException("The " + i + "th comparison's value is a list but the operator " + operator + " is a comparison operator that does not apply");
            }
        }
        switch (ad.getDataType()) {
            case :
                break;
            case :
            case :
                break;
            case :
                if (! operator.equals("=") && !operator.equals("!=")) {
                    throw new InvalidParameterException("The " + i + "th comparison's operator " + operator + " is a comparison operator that does not apply to the field's boolean data type");
                }
            case :
            case :
            case :
            case :
                break;
//            case COMPLEX:
//                if (! operator.equals("=") && !operator.equals("!=")) {
//                    throw new InvalidParameterException("The " + i + "th comparison's operator " + operator + " is a comparison operator that does not apply to the field's complex data type");
//                }
//                if (values.get(0) == null) {
//                    throw new InvalidParameterException("The " + i + "th comparison's value is not null but attribute type is complex. Complex can only be checked to see if it is null or not null");
//                }
        }
        .add(parseValues(iad.getDataType(), comparison.getValues(), comparison.getIsIgnoreCase()));
    }
    private Object parseValues(int iDataType dataTypeList<Stringvaluesboolean ignoreCase)
            throws InvalidParameterException {
        if (values.size() == 1) {
            return parseValue(idataTypevalues.get(0), ignoreCase);
        }
        List<Objectlist = new ArrayList<Object>();
        for (String value : values) {
            list.add(parseValue(idataTypevalueignoreCase));
        }
        return list;
    }
    private Object parseValue(int iDataType dataTypeString valueboolean ignoreCase)
            throws InvalidParameterException {
        if (value == null) {
            return null;
        }
        switch (dataType) {
            case :
                return parseString(ivalueignoreCase);
            case :
                return parseDateTime(ivalue);
            case :
                return parseDate(ivalue);
            case :
                return parseBoolean(ivalue);
            case :
                return parseInteger(ivalue);
            case :
                return parseFloat(ivalue);
            case :
                return parseDouble(ivalue);
            case :
                return parseLong(ivalue);
//            case COMPLEX:
//                throw new InvalidParameterException("The " + i + "th comparison's value is not null but attribute type is complex. Complex can only be checked to see if it is null or not null");
            default:
                throw new IllegalArgumentException("Unknown/unhandled datatype " + dataType);
        }
    }
    private String parseString(int iString cvboolean ignoreCasethrows InvalidParameterException {
        if (cv == null) {
            return null;
        }
        if (ignoreCase) {
            return cv.toLowerCase();
        }
        return cv;
    }
    private Timestamp parseDateTime(int iString cvthrows InvalidParameterException {
        try {
            return new Timestamp(..parse(cv).getTime());
        } catch (IllegalArgumentException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a dateTime");
        }
    }
    private Date parseDate(int iString cvthrows InvalidParameterException {
        try {
            return ..parse(cv);
        } catch (IllegalArgumentException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a date");
        }
    }
    private Integer parseInteger(int iString cvthrows InvalidParameterException {
        try {
            return Integer.parseInt(cv);
        } catch (NumberFormatException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an integer");
        }
    }
    private Long parseLong(int iString cvthrows InvalidParameterException {
        try {
            return Long.parseLong(cv);
        } catch (NumberFormatException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a Long");
        }
    }
    private Boolean parseBoolean(int iString cvthrows InvalidParameterException {
        if (cv.equalsIgnoreCase("true")) {
            return .;
        }
        if (cv.equalsIgnoreCase("false")) {
            return .;
        }
        throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a Boolean");
    }
    private Float parseFloat(int iString cvthrows InvalidParameterException {
        try {
            return Float.parseFloat(cv);
        } catch (NumberFormatException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an float");
        }
    }
    private Double parseDouble(int iString cvthrows InvalidParameterException {
        try {
            return Double.parseDouble(cv);
        } catch (NumberFormatException ex) {
            throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an double");
        }
    }
    private String initLower(String str) {
        if (str == null) {
            return null;
        }
        if (str.length() == 0) {
            return str;
        }
        if (str.length() == 1) {
            return str.toLowerCase();
        }
        return str.substring(0, 1).toLowerCase() + str.substring(1);
    }
    private boolean calcIsList(AttributeDefinitionInfc ad) {
        if (ad.getMaxOccurs() == null) {
            return false;
        }
        if (ad.getMaxOccurs() <= 1) {
            return false;
        }
        return true;
    }
            throws InvalidParameterException,
            OperationFailedException {
        for (AttributeDefinitionInfc ad : this..getAttributes()) {
            if (ad.getName().equals(fk)) {
                return ad;
            }
        }
       return null;
    }
New to GrepCode? Check out our FAQ X