JSFUtils.java
package org.andromda.cartridges.jsf;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.andromda.cartridges.jsf.metafacades.JSFAttribute;
import org.andromda.cartridges.jsf.metafacades.JSFManageableEntityAttribute;
import org.andromda.cartridges.jsf.metafacades.JSFParameter;
import org.andromda.metafacades.uml.AttributeFacade;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.FrontEndAction;
import org.andromda.metafacades.uml.FrontEndParameter;
import org.andromda.metafacades.uml.ModelElementFacade;
import org.andromda.metafacades.uml.OperationFacade;
import org.andromda.metafacades.uml.ParameterFacade;
import org.andromda.metafacades.uml.UMLMetafacadeUtils;
import org.andromda.utils.StringUtilsHelper;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.FastDateFormat;
/**
* Utilities for use within the JSF cartridge.
*
* @author Chad Brandon
*/
public class JSFUtils
{
/**
* Converts the argument into a web resource name, this means: all lowercase
* characters and words are separated with dashes.
*
* @param string any string
* @return the string converted to a value that would be well-suited for a
* web file name
*/
public static String toWebResourceName(final String string)
{
return StringUtilsHelper.separate(
string,
"-").toLowerCase();
}
private static final Pattern VALIDATOR_TAGGEDVALUE_PATTERN =
Pattern.compile("\\w+(\\(\\w+=[^,)]*(,\\w+=[^,)]*)*\\))?");
private static final String ANNOTATION_VALIDATOR_PREFIX = "@";
/**
* Reads the validator arguments from the the given tagged value.
* @param validatorTaggedValue
* @return returns a list of String instances or an empty list
* @throws IllegalArgumentException when the input string does not match the required pattern
*/
public static List<String> parseValidatorArgs(String validatorTaggedValue)
{
if (validatorTaggedValue == null)
{
throw new IllegalArgumentException("Validator tagged value cannot be null");
}
final List<String> validatorArgs = new ArrayList<String>();
//isn't it an annotation ?
if(!StringUtils.startsWith(validatorTaggedValue,ANNOTATION_VALIDATOR_PREFIX))
{
// check if the input tagged value matches the required pattern
if (!VALIDATOR_TAGGEDVALUE_PATTERN.matcher(validatorTaggedValue).matches())
{
throw new IllegalArgumentException(
"Illegal validator tagged value (this tag is used to specify custom validators " +
"and might look like myValidator(myVar=myArg,myVar2=myArg2), perhaps you wanted to use " +
"andromda_presentation_view_field_format?): " + validatorTaggedValue);
}
// only keep what is between parentheses (if any)
int left = validatorTaggedValue.indexOf('(');
if (left > -1)
{
final int right = validatorTaggedValue.indexOf(')');
validatorTaggedValue = validatorTaggedValue.substring(
left + 1,
right);
final String[] pairs = validatorTaggedValue.split(",");
for (int i = 0; i < pairs.length; i++)
{
final String pair = pairs[i];
final int equalsIndex = pair.indexOf('=');
// it's possible the argument is the empty string
if (equalsIndex < pair.length() - 1)
{
validatorArgs.add(pair.substring(equalsIndex + 1));
}
else
{
validatorArgs.add("");
}
}
}
}
return validatorArgs;
}
/**
* Reads the validator variable names from the the given tagged value.
* @param validatorTaggedValue
* @return never null, returns a list of String instances
* @throws IllegalArgumentException when the input string does not match the required pattern
*/
public static List<String> parseValidatorVars(String validatorTaggedValue)
{
if (validatorTaggedValue == null)
{
throw new IllegalArgumentException("Validator tagged value cannot be null");
}
final List<String> validatorVars = new ArrayList<String>();
//isn't it an annotation ?
if(!StringUtils.startsWith(validatorTaggedValue,ANNOTATION_VALIDATOR_PREFIX))
{
// check if the input tagged value matches the required pattern
if (!VALIDATOR_TAGGEDVALUE_PATTERN.matcher(validatorTaggedValue).matches())
{
throw new IllegalArgumentException("Illegal validator tagged value: " + validatorTaggedValue);
}
// only keep what is between parentheses (if any)
int left = validatorTaggedValue.indexOf('(');
if (left > -1)
{
int right = validatorTaggedValue.indexOf(')');
validatorTaggedValue = validatorTaggedValue.substring(
left + 1,
right);
final String[] pairs = validatorTaggedValue.split(",");
for (int i = 0; i < pairs.length; i++)
{
final String pair = pairs[i];
final int equalsIndex = pair.indexOf('=');
validatorVars.add(pair.substring(
0,
equalsIndex));
}
}
}
return validatorVars;
}
/**
* Parses the validator name for a tagged value.
* @param validatorTaggedValue
* @return validatorTaggedValue
* @throws IllegalArgumentException when the input string does not match the required pattern
*/
public static String parseValidatorName(final String validatorTaggedValue)
{
if (validatorTaggedValue == null)
{
throw new IllegalArgumentException("Validator tagged value cannot be null");
}
//isn't it an annotation ?
if(StringUtils.startsWith(validatorTaggedValue, ANNOTATION_VALIDATOR_PREFIX))
{
return validatorTaggedValue;
}
// check if the input tagged value matches the required pattern
if (!VALIDATOR_TAGGEDVALUE_PATTERN.matcher(validatorTaggedValue).matches())
{
throw new IllegalArgumentException("Illegal validator tagged value: " + validatorTaggedValue);
}
final int leftParen = validatorTaggedValue.indexOf('(');
return (leftParen == -1) ? validatorTaggedValue : validatorTaggedValue.substring(
0,
leftParen);
}
/**
* Constructs a string representing an array initialization in Java.
*
* @param name the name to give the array.
* @param count the number of items to give the array.
* @return A String representing Java code for the initialization of an array.
*/
public static String constructDummyArrayDeclaration(
final String name,
final int count)
{
final StringBuilder array = new StringBuilder("new Object[] {");
for (int ctr = 1; ctr <= count; ctr++)
{
array.append("\"" + name + "-" + ctr + "\"");
if (ctr != count)
{
array.append(", ");
}
}
array.append("}");
return array.toString();
}
/**
* @param format
* @return this field's date format
*/
public static String getDateFormat(String format)
{
format = StringUtils.trimToEmpty(format);
return format.endsWith(STRICT) ? getToken(format, 1, 2) : getToken(format, 0, 1);
}
private static String defaultDateFormat = "MM/dd/yyyy HH:mm:ssZ";
private static FastDateFormat df = FastDateFormat.getInstance(defaultDateFormat);
/**
* Returns the current Date in the specified format.
*
* @param format The format for the output date
* @return the current date in the specified format.
*/
public static String getDate(String format)
{
if (df == null || !format.equals(df.getPattern()))
{
df = FastDateFormat.getInstance(format);
}
return df.format(new Date());
}
/**
* Returns the current Date
*
* @return the current date in the default format.
*/
public static String getDate()
{
return getDate(defaultDateFormat);
}
private static final String STRICT = "strict";
/**
* @param format
* @return <code>true</code> if this field's value needs to conform to a
* strict date format, <code>false</code> otherwise
*/
public static boolean isStrictDateFormat(String format)
{
return strictDateTimeFormat ? strictDateTimeFormat : STRICT.equalsIgnoreCase(getToken(
format,
0,
2));
}
/**
* Indicates if the given <code>format</code> is an email format.
* @param format
* @return <code>true</code> if this field is to be formatted as an email
* address, <code>false</code> otherwise
*/
public static boolean isEmailFormat(String format)
{
return "email".equalsIgnoreCase(JSFUtils.getToken(
format,
0,
2));
}
/**
* Indicates if the given <code>format</code> is an equal format.
* @param format
* @return <code>true</code> if this field is to be formatted as an
* email address, <code>false</code> otherwise
*/
public static boolean isEqualFormat(String format)
{
return "equal".equalsIgnoreCase(JSFUtils.getToken(format, 0, 2));
}
/**
* Indicates if the given <code>format</code> is a credit card format.
* @param format
* @return <code>true</code> if this field is to be formatted as a credit card, <code>false</code> otherwise
*/
public static boolean isCreditCardFormat(final String format)
{
return "creditcard".equalsIgnoreCase(JSFUtils.getToken(format, 0, 2));
}
/**
* Indicates if the given <code>format</code> is a pattern format.
* @param format
* @return <code>true</code> if this field's value needs to respect a certain pattern, <code>false</code> otherwise
*/
public static boolean isPatternFormat(final String format)
{
return "pattern".equalsIgnoreCase(JSFUtils.getToken(format, 0, 2));
}
/**
* Indicates if the given <code>format</code> is a minlength format.
* @param format
* @return <code>true</code> if this field's value needs to consist of at least a certain
* number of characters, <code>false</code> otherwise
*/
public static boolean isMinLengthFormat(final String format)
{
return "minlength".equalsIgnoreCase(JSFUtils.getToken(
format,
0,
2));
}
/**
* Indicates if the given <code>format</code> is a maxlength format.
* @param format
* @return <code>true</code> if this field's value needs to consist of at maximum a certain
* number of characters, <code>false</code> otherwise
*/
public static boolean isMaxLengthFormat(String format)
{
return "maxlength".equalsIgnoreCase(JSFUtils.getToken(
format,
0,
2));
}
/**
* @param string
* @param index
* @param limit
* @return the i-th space delimited token read from the argument String, where i does not exceed the specified limit
*/
public static String getToken(
String string,
int index,
int limit)
{
String token = null;
if (string != null && string.length() > 0)
{
final String[] tokens = string.split(
"[\\s]+",
limit);
token = index >= tokens.length ? null : tokens[index];
}
return token;
}
/**
* Retrieves the input format (if one is defined), for the given
* <code>element</code>.
* @param element the model element for which to retrieve the input format.
* @return the input format.
*/
public static String getInputFormat(final ModelElementFacade element)
{
final Object value = element.findTaggedValue(JSFProfile.TAGGEDVALUE_INPUT_FORMAT);
final String format = value == null ? null : String.valueOf(value);
return format == null ? null : format.trim();
}
/**
* Indicates if the given <code>format</code> is a range format.
* @param format
* @return <code>true</code> if this field's value needs to be in a specific range, <code>false</code> otherwise
*/
public static boolean isRangeFormat(final String format)
{
return "range".equalsIgnoreCase(JSFUtils.getToken(
format,
0,
2));
}
/**
* @param type
* @return <code>true</code> if the type of this field is a byte, <code>false</code> otherwise
*/
public static boolean isByte(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.BYTE_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a short, <code>false</code> otherwise
*/
public static boolean isShort(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.SHORT_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is an integer, <code>false</code> otherwise
*/
public static boolean isInteger(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.INTEGER_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a long integer, <code>false</code> otherwise
*/
public static boolean isLong(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.LONG_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a floating point, <code>false</code> otherwise
*/
public static boolean isFloat(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.FLOAT_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a double precision floating point,
* <code>false</code> otherwise
*/
public static boolean isDouble(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.DOUBLE_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a date, <code>false</code> otherwise
*/
public static boolean isDate(final ClassifierFacade type)
{
return type != null && type.isDateType();
}
/**
* @param type
* @return <code>true</code> if the type of this field is a time, <code>false</code> otherwise
*/
public static boolean isTime(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.TIME_TYPE_NAME);
}
/**
* @param type
* @return <code>true</code> if the type of this field is a URL, <code>false</code> otherwise
*/
public static boolean isUrl(final ClassifierFacade type)
{
return isType(
type,
JSFProfile.URL_TYPE_NAME);
}
private static boolean isType(final ClassifierFacade type, String typeName)
{
boolean isType = UMLMetafacadeUtils.isType(
type,
typeName);
if (!isType)
{
// - handle abstract types that are mapped to java types
if (type.getLanguageMappings() != null)
{
final String javaTypeName = type.getLanguageMappings()
.getTo(type.getFullyQualifiedName(true));
if (javaTypeName != null)
{
isType = javaTypeName.replaceAll(".*\\.", "").equalsIgnoreCase(
type.getLanguageMappings().getTo(typeName));
}
}
}
return isType;
}
/**
* @param type
* @return <code>true</code> if the type of this field is a String,
* <code>false</code> otherwise
*/
public static boolean isString(final ClassifierFacade type)
{
return type != null && type.isStringType();
}
/**
* Indicates if the given element is read-only or not.
*
* @param element the element to check.
* @return true/false
*/
public static boolean isReadOnly(final ModelElementFacade element)
{
boolean readOnly = false;
if (element != null)
{
final Object value = element.findTaggedValue(JSFProfile.TAGGEDVALUE_INPUT_READONLY);
readOnly = Boolean.valueOf(ObjectUtils.toString(value)).booleanValue();
}
return readOnly;
}
/**
* Retrieves the "equal" value from the given element (if one is present).
*
* @param element the element from which to retrieve the equal value.
* @return the "equal" value.
*/
public static String getEqual(final ModelElementFacade element)
{
String equal = null;
if (element != null)
{
final Object value = element.findTaggedValue(JSFProfile.TAGGEDVALUE_INPUT_EQUAL);
equal = value == null ? null : value.toString();
}
return equal;
}
/**
* Retrieves the "equal" value from the given element (if one is present).
*
* @param element the element from which to retrieve the equal value.
* @param ownerParameter the optional owner parameter (specified if the element is an attribute).
* @return the "equal" value.
*/
public static String getEqual(final ModelElementFacade element, final ParameterFacade ownerParameter)
{
String equal = null;
if (element != null)
{
final Object value = element.findTaggedValue(JSFProfile.TAGGEDVALUE_INPUT_EQUAL);
equal = value == null ? null : value.toString();
if (StringUtils.isNotBlank(equal) && ownerParameter != null)
{
equal = ownerParameter.getName() + StringUtilsHelper.upperCamelCaseName(equal);
}
}
return equal;
}
/**
* Retrieves the "validwhen" value from the given element (if one is present).
*
* @param element the element from which to retrieve the validwhen value.
* @return the "validwhen" value.
*/
public static String getValidWhen(final ModelElementFacade element)
{
String validWhen = null;
if (element != null)
{
final Object value = element.findTaggedValue(JSFProfile.TAGGEDVALUE_INPUT_VALIDWHEN);
validWhen = value == null ? null : '(' + value.toString() + ')';
}
return validWhen;
}
/**
* @param format
* @return the lower limit for this field's value's range
*/
public static String getRangeStart(final String format)
{
return JSFUtils.getToken(
format,
1,
3);
}
/**
* @param format
* @return the upper limit for this field's value's range
*/
public static String getRangeEnd(final String format)
{
return JSFUtils.getToken(
format,
2,
3);
}
/**
* @param format
* @return the minimum number of characters this field's value must consist of
*/
public static String getMinLengthValue(final String format)
{
return JSFUtils.getToken(
format,
1,
2);
}
/**
* @param format
* @return the maximum number of characters this field's value must consist of
*/
public static String getMaxLengthValue(final String format)
{
return JSFUtils.getToken(
format,
1,
2);
}
/**
* @param format
* @return the pattern this field's value must respect
*/
public static String getPatternValue(final String format)
{
return '^' + JSFUtils.getToken(
format,
1,
2) + '$';
}
//validator strings
/** "required" */
public static final String VT_REQUIRED="required";
/** "url" */
public static final String VT_URL="url";
/** "intRange" */
public static final String VT_INT_RANGE="intRange";
/** "floatRange" */
public static final String VT_FLOAT_RANGE="floatRange";
/** "doubleRange" */
public static final String VT_DOUBLE_RANGE="doubleRange";
/** "email" */
public static final String VT_EMAIL="email";
/** "creditCard" */
public static final String VT_CREDIT_CARD="creditCard";
/** "minlength" */
public static final String VT_MIN_LENGTH="minlength";
/** "maxlength" */
public static final String VT_MAX_LENGTH="maxlength";
/** "mask" */
public static final String VT_MASK="mask";
/** "validwhen" */
public static final String VT_VALID_WHEN="validwhen";
/** "equal" */
public static final String VT_EQUAL="equal";
/**
* Retrieves the validator types as a collection from the given
* <code>element</code> (if any can be retrieved).
*
* @param element the element from which to retrieve the types.
* @param type the type of the element.
* @return the collection of validator types.
*/
public static Collection<String> getValidatorTypes(
final ModelElementFacade element,
final ClassifierFacade type)
{
final Collection<String> validatorTypesList = new ArrayList<String>();
if (element != null && type != null)
{
final String format = JSFUtils.getInputFormat(element);
final boolean isRangeFormat = format != null && isRangeFormat(format);
if (element instanceof AttributeFacade)
{
if (((AttributeFacade)element).isRequired())
{
validatorTypesList.add(VT_REQUIRED);
}
}
else if (element instanceof JSFParameter)
{
if (((JSFParameter)element).isRequired())
{
validatorTypesList.add(VT_REQUIRED);
}
}
if (JSFUtils.isByte(type))
{
validatorTypesList.add("byte");
}
else if (JSFUtils.isShort(type))
{
validatorTypesList.add("short");
}
else if (JSFUtils.isInteger(type))
{
validatorTypesList.add("integer");
}
else if (JSFUtils.isLong(type))
{
validatorTypesList.add("long");
}
else if (JSFUtils.isFloat(type))
{
validatorTypesList.add("float");
}
else if (JSFUtils.isDouble(type))
{
validatorTypesList.add("double");
}
else if (JSFUtils.isDate(type))
{
validatorTypesList.add("date");
}
else if (JSFUtils.isTime(type))
{
validatorTypesList.add("time");
}
else if (JSFUtils.isUrl(type))
{
validatorTypesList.add(VT_URL);
}
if (isRangeFormat)
{
if (JSFUtils.isInteger(type) || JSFUtils.isShort(type) || JSFUtils.isLong(type))
{
validatorTypesList.add(VT_INT_RANGE);
}
if (JSFUtils.isFloat(type))
{
validatorTypesList.add(VT_FLOAT_RANGE);
}
if (JSFUtils.isDouble(type))
{
validatorTypesList.add(VT_DOUBLE_RANGE);
}
}
if (format != null)
{
if (JSFUtils.isString(type) && JSFUtils.isEmailFormat(format))
{
validatorTypesList.add(VT_EMAIL);
}
else if (JSFUtils.isString(type) && JSFUtils.isCreditCardFormat(format))
{
validatorTypesList.add(VT_CREDIT_CARD);
}
else
{
Collection formats = element.findTaggedValues(JSFProfile.TAGGEDVALUE_INPUT_FORMAT);
for (final Iterator formatIterator = formats.iterator(); formatIterator.hasNext();)
{
String additionalFormat = String.valueOf(formatIterator.next());
if (JSFUtils.isMinLengthFormat(additionalFormat))
{
validatorTypesList.add(VT_MIN_LENGTH);
}
else if (JSFUtils.isMaxLengthFormat(additionalFormat))
{
validatorTypesList.add(VT_MAX_LENGTH);
}
else if (JSFUtils.isPatternFormat(additionalFormat))
{
validatorTypesList.add(VT_MASK);
}
}
}
}
if (JSFUtils.getValidWhen(element) != null)
{
validatorTypesList.add(VT_VALID_WHEN);
}
if (JSFUtils.getEqual(element) != null)
{
validatorTypesList.add(VT_EQUAL);
}
// - custom (paramterized) validators are allowed here
final Collection taggedValues = element.findTaggedValues(JSFProfile.TAGGEDVALUE_INPUT_VALIDATORS);
for (final Iterator iterator = taggedValues.iterator(); iterator.hasNext();)
{
String validator = String.valueOf(iterator.next());
validatorTypesList.add(JSFUtils.parseValidatorName(validator));
}
}
return validatorTypesList;
}
/**
* Gets the validator variables for the given <code>element</code> (if they can
* be retrieved).
*
* @param element the element from which to retrieve the variables
* @param type the type of the element.
* @param ownerParameter the optional owner parameter (if the element is an attribute for example).
* @return the collection of validator variables.
*/
public static Collection<List<String>> getValidatorVars(
final ModelElementFacade element,
final ClassifierFacade type,
final ParameterFacade ownerParameter)
{
final Map<String, List<String>> vars = new LinkedHashMap<String, List<String>>();
if (element != null && type != null)
{
final String format = JSFUtils.getInputFormat(element);
if (format != null)
{
final boolean isRangeFormat = JSFUtils.isRangeFormat(format);
if (isRangeFormat)
{
final String min = "min";
final String max = "max";
vars.put(
min,
Arrays.asList(min, JSFUtils.getRangeStart(format)));
vars.put(
max,
Arrays.asList(max, JSFUtils.getRangeEnd(format)));
}
else
{
final Collection formats = element.findTaggedValues(JSFProfile.TAGGEDVALUE_INPUT_FORMAT);
for (final Iterator formatIterator = formats.iterator(); formatIterator.hasNext();)
{
final String additionalFormat = String.valueOf(formatIterator.next());
final String minlength = "minlength";
final String maxlength = "maxlength";
final String mask = "mask";
if (JSFUtils.isMinLengthFormat(additionalFormat))
{
vars.put(
minlength,
Arrays.asList(minlength, JSFUtils.getMinLengthValue(additionalFormat)));
}
else if (JSFUtils.isMaxLengthFormat(additionalFormat))
{
vars.put(
maxlength,
Arrays.asList(maxlength, JSFUtils.getMaxLengthValue(additionalFormat)));
}
else if (JSFUtils.isPatternFormat(additionalFormat))
{
vars.put(
mask,
Arrays.asList(mask, JSFUtils.getPatternValue(additionalFormat)));
}
}
}
}
String inputFormat;
if (element instanceof JSFAttribute)
{
inputFormat = ((JSFAttribute)element).getFormat();
}
else if (element instanceof JSFParameter)
{
inputFormat = ((JSFParameter)element).getFormat();
}
else if (element instanceof JSFManageableEntityAttribute)
{
inputFormat = ((JSFManageableEntityAttribute)element).getFormat();
}
else
{
throw new RuntimeException("'element' is an invalid type, it must be either an instance of '" +
JSFAttribute.class.getName() + "' or '" + JSFParameter.class.getName() + "'");
}
if (JSFUtils.isDate(type))
{
final String datePatternStrict = "datePatternStrict";
if (format != null && JSFUtils.isStrictDateFormat(format))
{
vars.put(
datePatternStrict,
Arrays.asList(datePatternStrict, inputFormat));
}
else
{
final String datePattern = "datePattern";
vars.put(
datePattern,
Arrays.asList(datePattern, inputFormat));
}
}
if (JSFUtils.isTime(type))
{
final String timePattern = "timePattern";
vars.put(
timePattern,
Arrays.asList(timePattern, inputFormat));
}
final String validWhen = JSFUtils.getValidWhen(element);
if (validWhen != null)
{
final String test = "test";
vars.put(
test,
Arrays.asList(test, validWhen));
}
final String equal = JSFUtils.getEqual(element, ownerParameter);
if (equal != null)
{
final String fieldName = "fieldName";
vars.put(
fieldName,
Arrays.asList(fieldName, equal));
}
// - custom (parameterized) validators are allowed here
// in this case we will reuse the validator arg values
final Collection taggedValues = element.findTaggedValues(JSFProfile.TAGGEDVALUE_INPUT_VALIDATORS);
for (final Object value : taggedValues)
{
final String validator = String.valueOf(value);
// - guaranteed to be of the same length
final List<String> validatorVars = JSFUtils.parseValidatorVars(validator);
final List<String> validatorArgs = JSFUtils.parseValidatorArgs(validator);
for (int ctr = 0; ctr < validatorVars.size(); ctr++)
{
vars.put(validatorVars.get(ctr),
Arrays.asList(validatorVars.get(ctr), validatorArgs.get(ctr)));
}
}
}
return vars.values();
}
/**
* Gets the validator args for the <code>element</code> and the given <code>validatorType</code>.
*
* @param element the element for which to retrieve the arguments.
* @param validatorType the validator type name.
* @return the validator args as a collection.
*/
public static java.util.Collection getValidatorArgs(
final ModelElementFacade element,
final String validatorType)
{
final Collection<Object> args = new ArrayList<Object>();
if ("intRange".equals(validatorType) || "floatRange".equals(validatorType) ||
"doubleRange".equals(validatorType))
{
args.add("${var:min}");
args.add("${var:max}");
}
else if ("minlength".equals(validatorType))
{
args.add("${var:minlength}");
}
else if ("maxlength".equals(validatorType))
{
args.add("${var:maxlength}");
}
else if ("date".equals(validatorType))
{
final String validatorFormat = JSFUtils.getInputFormat(element);
if (JSFUtils.isStrictDateFormat(validatorFormat))
{
args.add("${var:datePatternStrict}");
}
else
{
args.add("${var:datePattern}");
}
}
else if ("time".equals(validatorType))
{
args.add("${var:timePattern}");
}
else if ("equal".equals(validatorType))
{
ModelElementFacade equalParameter = null;
final String equal = JSFUtils.getEqual(element);
if (element instanceof ParameterFacade)
{
final FrontEndParameter parameter = (FrontEndParameter)element;
final OperationFacade operation = parameter.getOperation();
if (operation != null)
{
equalParameter = operation.findParameter(equal);
}
if (equalParameter == null)
{
final FrontEndAction action = parameter.getAction();
if (action != null)
{
equalParameter = action.findParameter(equal);
}
}
}
else if (element instanceof AttributeFacade)
{
final AttributeFacade attribute = (AttributeFacade)element;
final ClassifierFacade owner = attribute.getOwner();
if (owner != null)
{
equalParameter = owner.findAttribute(equal);
}
}
args.add(equalParameter);
args.add("${var:fieldName}");
}
// custom (paramterized) validators are allowed here
final Collection taggedValues = element.findTaggedValues(JSFProfile.TAGGEDVALUE_INPUT_VALIDATORS);
for (final Iterator iterator = taggedValues.iterator(); iterator.hasNext();)
{
final String validator = String.valueOf(iterator.next());
if (validatorType.equals(JSFUtils.parseValidatorName(validator)))
{
args.addAll(JSFUtils.parseValidatorArgs(validator));
}
}
return args;
}
/**
* Whether or not date patterns should be treated as strict.
*/
private static boolean strictDateTimeFormat;
/**
* Sets whether or not the date patterns should be treated as strict.
*
* @param strictDateTimeFormat
*/
public void setStrictDateTimeFormat(final boolean strictDateTimeFormat)
{
JSFUtils.strictDateTimeFormat = strictDateTimeFormat;
}
/**
* Indicates whether or not the format for this element is a strict date
* format.
* @param element
* @return true/false
*/
public static boolean isStrictDateFormat(final ModelElementFacade element)
{
final String format = JSFUtils.getInputFormat(element);
return JSFUtils.isStrictDateFormat(format);
}
/**
* Gets the format string for the given <code>element</code>.
*
* @param element the element for which to retrieve the format.
* @param type the type of the element.
* @param defaultDateFormat
* @param defaultTimeFormat
* @return the format string (if one is present otherwise null).
*/
public static String getFormat(
final ModelElementFacade element,
final ClassifierFacade type,
final String defaultDateFormat,
final String defaultTimeFormat)
{
String format = null;
if (element != null && type != null)
{
format = JSFUtils.getInputFormat(element);
if (format == null)
{
if(type.isDateType() && type.isTimeType())
{
format = defaultDateFormat+" "+defaultTimeFormat;
}
else if (type.isTimeType())
{
format = defaultTimeFormat;
}
else if (type.isDateType())
{
format = defaultDateFormat;
}
}
else if (type.isDateType())
{
format = JSFUtils.getDateFormat(format);
}
}
return format;
}
/**
* The XHTML extension.
*/
private static final String EXTENSION_XHTML = "xhtml";
/**
* Gets the extension for the view type.
*
* @return the view type extension.
*/
public String getViewExtension()
{
return EXTENSION_XHTML;
}
private String portletContainer;
/**
* @param portletContainer
*/
public void setPortletContainer(String portletContainer)
{
this.portletContainer = portletContainer;
}
private boolean isPortlet()
{
return StringUtils.isNotBlank(this.portletContainer);
}
/**
* @return className
*/
public String getRequestClassName()
{
final String className;
if (this.isPortlet())
{
className = "javax.portlet.PortletRequest";
}
else
{
className = "javax.servlet.http.HttpServletRequest";
}
return className;
}
/**
* @return className
*/
public String getResponseClassName()
{
final String className;
if (this.isPortlet())
{
className = "javax.portlet.PortletResponse";
}
else
{
className = "javax.servlet.http.HttpServletResponse";
}
return className;
}
/**
* @return className
*/
public String getSessionClassName()
{
final String className;
if (this.isPortlet())
{
className = "javax.portlet.PortletSession";
}
else
{
className = "javax.servlet.http.HttpSession";
}
return className;
}
/**
* @param buffer
* @return the calculated SerialVersionUID
*/
public static String calcSerialVersionUID(StringBuilder buffer)
{
final String signature = buffer.toString();
String serialVersionUID = String.valueOf(0L);
try
{
MessageDigest md = MessageDigest.getInstance("SHA");
byte[] hashBytes = md.digest(signature.getBytes());
long hash = 0;
for (int ctr = Math.min(
hashBytes.length,
8) - 1; ctr >= 0; ctr--)
{
hash = (hash << 8) | (hashBytes[ctr] & 0xFF);
}
serialVersionUID = String.valueOf(hash);
}
catch (final NoSuchAlgorithmException exception)
{
throw new RuntimeException("Error performing JSFAction.getFormSerialVersionUID",exception);
}
return serialVersionUID;
}
/**
* @param string
* @return Integer.valueOf(string) * 6000
*/
public int calculateIcefacesTimeout(String string)
{
return string != null ? Integer.valueOf(string) * 6000 : 0;
}
}