/*******************************************************************************
* 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
*
* http://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.ofbiz.service;
import java.io.IOException;
import java.io.Serializable;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.ofbiz.base.config.GenericConfigException;
import org.apache.ofbiz.base.config.ResourceHandler;
import org.apache.ofbiz.base.metrics.MetricsFactory;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GeneralException;
import org.apache.ofbiz.base.util.UtilTimer;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.base.util.UtilXml;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.model.ModelEntity;
import org.apache.ofbiz.entity.model.ModelField;
import org.apache.ofbiz.entity.model.ModelFieldType;
import org.apache.ofbiz.service.ModelParam.ModelParamValidator;
import org.apache.ofbiz.service.group.GroupModel;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* Generic Service - Service Definition Reader
*/
@SuppressWarnings("serial")
public class ModelServiceReader implements Serializable {
public static final String module = ModelServiceReader.class.getName();
/** is either from a URL or from a ResourceLoader (through the ResourceHandler) */
protected boolean isFromURL;
protected URL readerURL = null;
protected ResourceHandler handler = null;
protected Delegator delegator = null;
public static Map<String, ModelService> getModelServiceMap(URL readerURL, Delegator delegator) {
if (readerURL == null) {
Debug.logError("Cannot add reader with a null reader URL", module);
return null;
}
ModelServiceReader reader = new ModelServiceReader(true, readerURL, null, delegator);
return reader.getModelServices();
}
public static Map<String, ModelService> getModelServiceMap(ResourceHandler handler, Delegator delegator) {
ModelServiceReader reader = new ModelServiceReader(false, null, handler, delegator);
return reader.getModelServices();
}
private ModelServiceReader(boolean isFromURL, URL readerURL, ResourceHandler handler, Delegator delegator) {
this.isFromURL = isFromURL;
this.readerURL = readerURL;
this.handler = handler;
this.delegator = delegator;
}
private Map<String, ModelService> getModelServices() {
UtilTimer utilTimer = new UtilTimer();
Document document;
if (this.isFromURL) {
// utilTimer.timerString("Before getDocument in file " + readerURL);
document = getDocument(readerURL);
if (document == null) {
return null;
}
} else {
// utilTimer.timerString("Before getDocument in " + handler);
try {
document = handler.getDocument();
} catch (GenericConfigException e) {
Debug.logError(e, "Error getting XML document from resource", module);
return null;
}
}
Map<String, ModelService> modelServices = new HashMap<String, ModelService>();
if (this.isFromURL) {// utilTimer.timerString("Before getDocumentElement in file " + readerURL);
} else {// utilTimer.timerString("Before getDocumentElement in " + handler);
}
Element docElement = document.getDocumentElement();
if (docElement == null) {
return null;
}
docElement.normalize();
String resourceLocation = handler.getLocation();
try {
resourceLocation = handler.getURL().toExternalForm();
} catch (GenericConfigException e) {
Debug.logError(e, "Could not get resource URL", module);
}
int i = 0;
Node curChild = docElement.getFirstChild();
if (curChild != null) {
if (this.isFromURL) {
utilTimer.timerString("Before start of service loop in file " + readerURL);
} else {
utilTimer.timerString("Before start of service loop in " + handler);
}
do {
if (curChild.getNodeType() == Node.ELEMENT_NODE && "service".equals(curChild.getNodeName())) {
i++;
Element curServiceElement = (Element) curChild;
String serviceName = UtilXml.checkEmpty(curServiceElement.getAttribute("name"));
// check to see if service with same name has already been read
if (modelServices.containsKey(serviceName)) {
Debug.logWarning("Service " + serviceName + " is defined more than once, " +
"most recent will over-write previous definition(s)", module);
}
// utilTimer.timerString(" After serviceName -- " + i + " --");
ModelService service = createModelService(curServiceElement, resourceLocation);
// utilTimer.timerString(" After createModelService -- " + i + " --");
if (service != null) {
modelServices.put(serviceName, service);
// utilTimer.timerString(" After modelServices.put -- " + i + " --");
/*
int reqIn = service.getParameterNames(ModelService.IN_PARAM, false).size();
int optIn = service.getParameterNames(ModelService.IN_PARAM, true).size() - reqIn;
int reqOut = service.getParameterNames(ModelService.OUT_PARAM, false).size();
int optOut = service.getParameterNames(ModelService.OUT_PARAM, true).size() - reqOut;
if (Debug.verboseOn()) {
String msg = "-- getModelService: # " + i + " Loaded service: " + serviceName +
" (IN) " + reqIn + "/" + optIn + " (OUT) " + reqOut + "/" + optOut;
Debug.logVerbose(msg, module);
}
*/
} else {
Debug.logWarning(
"-- -- SERVICE ERROR:getModelService: Could not create service for serviceName: " +
serviceName, module);
}
}
} while ((curChild = curChild.getNextSibling()) != null);
} else {
Debug.logWarning("No child nodes found.", module);
}
if (this.isFromURL) {
utilTimer.timerString("Finished file " + readerURL + " - Total Services: " + i + " FINISHED");
Debug.logInfo("Loaded [" + i + "] Services from " + readerURL, module);
} else {
utilTimer.timerString("Finished document in " + handler + " - Total Services: " + i + " FINISHED");
if (Debug.infoOn()) {
Debug.logInfo("Loaded [" + i + "] Services from " + resourceLocation, module);
}
}
return modelServices;
}
private ModelService createModelService(Element serviceElement, String resourceLocation) {
ModelService service = new ModelService();
service.name = UtilXml.checkEmpty(serviceElement.getAttribute("name")).intern();
service.definitionLocation = resourceLocation;
service.engineName = UtilXml.checkEmpty(serviceElement.getAttribute("engine")).intern();
service.location = UtilXml.checkEmpty(serviceElement.getAttribute("location")).intern();
service.invoke = UtilXml.checkEmpty(serviceElement.getAttribute("invoke")).intern();
service.semaphore = UtilXml.checkEmpty(serviceElement.getAttribute("semaphore")).intern();
service.defaultEntityName = UtilXml.checkEmpty(serviceElement.getAttribute("default-entity-name")).intern();
service.fromLoader = isFromURL ? readerURL.toExternalForm() : handler.getLoaderName();
// these default to true; if anything but true, make false
service.auth = "true".equalsIgnoreCase(serviceElement.getAttribute("auth"));
service.export = "true".equalsIgnoreCase(serviceElement.getAttribute("export"));
service.debug = "true".equalsIgnoreCase(serviceElement.getAttribute("debug"));
// these defaults to false; if anything but false, make it true
service.validate = !"false".equalsIgnoreCase(serviceElement.getAttribute("validate"));
service.useTransaction = !"false".equalsIgnoreCase(serviceElement.getAttribute("use-transaction"));
service.requireNewTransaction = !"false".equalsIgnoreCase(serviceElement.getAttribute("require-new-transaction"));
if (service.requireNewTransaction && !service.useTransaction) {
// requireNewTransaction implies that a transaction is used
service.useTransaction = true;
Debug.logWarning("In service definition [" + service.name + "] the value use-transaction has been changed from false to true as required when require-new-transaction is set to true", module);
}
service.hideResultInLog = !"false".equalsIgnoreCase(serviceElement.getAttribute("hideResultInLog"));
// set the semaphore sleep/wait times
String semaphoreWaitStr = UtilXml.checkEmpty(serviceElement.getAttribute("semaphore-wait-seconds"));
int semaphoreWait = 300;
if (UtilValidate.isNotEmpty(semaphoreWaitStr)) {
try {
semaphoreWait = Integer.parseInt(semaphoreWaitStr);
} catch (NumberFormatException e) {
Debug.logWarning(e, "Setting semaphore-wait to 5 minutes (default)", module);
semaphoreWait = 300;
}
}
service.semaphoreWait = semaphoreWait;
String semaphoreSleepStr = UtilXml.checkEmpty(serviceElement.getAttribute("semaphore-sleep"));
int semaphoreSleep = 500;
if (UtilValidate.isNotEmpty(semaphoreSleepStr)) {
try {
semaphoreSleep = Integer.parseInt(semaphoreSleepStr);
} catch (NumberFormatException e) {
Debug.logWarning(e, "Setting semaphore-sleep to 1/2 second (default)", module);
semaphoreSleep = 500;
}
}
service.semaphoreSleep = semaphoreSleep;
// set the max retry field
String maxRetryStr = UtilXml.checkEmpty(serviceElement.getAttribute("max-retry"));
int maxRetry = -1;
if (UtilValidate.isNotEmpty(maxRetryStr)) {
try {
maxRetry = Integer.parseInt(maxRetryStr);
} catch (NumberFormatException e) {
Debug.logWarning(e, "Setting maxRetry to -1 (default)", module);
maxRetry = -1;
}
}
service.maxRetry = maxRetry;
// get the timeout and convert to int
String timeoutStr = UtilXml.checkEmpty(serviceElement.getAttribute("transaction-timeout"), serviceElement.getAttribute("transaction-timout"));
int timeout = 0;
if (UtilValidate.isNotEmpty(timeoutStr)) {
try {
timeout = Integer.parseInt(timeoutStr);
} catch (NumberFormatException e) {
Debug.logWarning(e, "Setting timeout to 0 (default)", module);
timeout = 0;
}
}
service.transactionTimeout = timeout;
service.description = getCDATADef(serviceElement, "description");
service.nameSpace = getCDATADef(serviceElement, "namespace");
// construct the context
service.contextInfo = new HashMap<String, ModelParam>();
this.createNotification(serviceElement, service);
this.createPermission(serviceElement, service);
this.createPermGroups(serviceElement, service);
this.createGroupDefs(serviceElement, service);
this.createImplDefs(serviceElement, service);
this.createAutoAttrDefs(serviceElement, service);
this.createAttrDefs(serviceElement, service);
this.createOverrideDefs(serviceElement, service);
// Get metrics.
Element metricsElement = UtilXml.firstChildElement(serviceElement, "metric");
if (metricsElement != null) {
service.metrics = MetricsFactory.getInstance(metricsElement);
}
return service;
}
private String getCDATADef(Element baseElement, String tagName) {
String value = "";
NodeList nl = baseElement.getElementsByTagName(tagName);
// if there are more then one decriptions we will use only the first one
if (nl.getLength() > 0) {
Node n = nl.item(0);
NodeList childNodes = n.getChildNodes();
if (childNodes.getLength() > 0) {
Node cdata = childNodes.item(0);
value = UtilXml.checkEmpty(cdata.getNodeValue());
}
}
return value;
}
private void createNotification(Element baseElement, ModelService model) {
List<? extends Element> n = UtilXml.childElementList(baseElement, "notification");
// default notification groups
ModelNotification nSuccess = new ModelNotification();
nSuccess.notificationEvent = "success";
nSuccess.notificationGroupName = "default.success." + model.fromLoader;
model.notifications.add(nSuccess);
ModelNotification nFail = new ModelNotification();
nFail.notificationEvent = "fail";
nFail.notificationGroupName = "default.fail." + model.fromLoader;
model.notifications.add(nFail);
ModelNotification nError = new ModelNotification();
nError.notificationEvent = "error";
nError.notificationGroupName = "default.error." + model.fromLoader;
model.notifications.add(nError);
if (n != null) {
for (Element e: n) {
ModelNotification notify = new ModelNotification();
notify.notificationEvent = e.getAttribute("event");
notify.notificationGroupName = e.getAttribute("group");
model.notifications.add(notify);
}
}
}
private void createPermission(Element baseElement, ModelService model) {
Element e = UtilXml.firstChildElement(baseElement, "permission-service");
if (e != null) {
model.permissionServiceName = e.getAttribute("service-name");
model.permissionMainAction = e.getAttribute("main-action");
model.permissionResourceDesc = e.getAttribute("resource-description");
model.auth = true; // auth is always required when permissions are set
}
}
private void createPermGroups(Element baseElement, ModelService model) {
for (Element element: UtilXml.childElementList(baseElement, "required-permissions")) {
ModelPermGroup group = new ModelPermGroup();
group.joinType = element.getAttribute("join-type");
createGroupPermissions(element, group, model);
model.permissionGroups.add(group);
}
}
private void createGroupPermissions(Element baseElement, ModelPermGroup group, ModelService service) {
// create the simple permissions
for (Element element: UtilXml.childElementList(baseElement, "check-permission")) {
ModelPermission perm = new ModelPermission();
perm.nameOrRole = element.getAttribute("permission").intern();
perm.action = element.getAttribute("action").intern();
if (UtilValidate.isNotEmpty(perm.action)) {
perm.permissionType = ModelPermission.ENTITY_PERMISSION;
} else {
perm.permissionType = ModelPermission.PERMISSION;
}
perm.serviceModel = service;
group.permissions.add(perm);
}
// create the role member permissions
for (Element element: UtilXml.childElementList(baseElement, "check-role-member")) {
ModelPermission perm = new ModelPermission();
perm.permissionType = ModelPermission.ROLE_MEMBER;
perm.nameOrRole = element.getAttribute("role-type").intern();
perm.serviceModel = service;
group.permissions.add(perm);
}
// Create the permissions based on permission services
for (Element element : UtilXml.childElementList(baseElement, "permission-service")) {
ModelPermission perm = new ModelPermission();
if (baseElement != null) {
perm.permissionType = ModelPermission.PERMISSION_SERVICE;
perm.permissionServiceName = element.getAttribute("service-name");
perm.action = element.getAttribute("main-action");
perm.permissionResourceDesc = element.getAttribute("resource-description");
perm.auth = true; // auth is always required when permissions are set
perm.serviceModel = service;
group.permissions.add(perm);
}
}
}
private void createGroupDefs(Element baseElement, ModelService service) {
List<? extends Element> group = UtilXml.childElementList(baseElement, "group");
if (UtilValidate.isNotEmpty(group)) {
Element groupElement = group.get(0);
groupElement.setAttribute("name", "_" + service.name + ".group");
service.internalGroup = new GroupModel(groupElement);
service.invoke = service.internalGroup.getGroupName();
if (Debug.verboseOn()) Debug.logVerbose("Created INTERNAL GROUP model [" + service.internalGroup + "]", module);
}
}
private void createImplDefs(Element baseElement, ModelService service) {
for (Element implement: UtilXml.childElementList(baseElement, "implements")) {
String serviceName = UtilXml.checkEmpty(implement.getAttribute("service")).intern();
boolean optional = UtilXml.checkBoolean(implement.getAttribute("optional"), false);
if (serviceName.length() > 0)
service.implServices.add(new ModelServiceIface(serviceName, optional));
//service.implServices.add(serviceName);
}
}
private void createAutoAttrDefs(Element baseElement, ModelService service) {
for (Element element: UtilXml.childElementList(baseElement, "auto-attributes")) {
createAutoAttrDef(element, service);
}
}
private void createAutoAttrDef(Element autoElement, ModelService service) {
// get the entity name; first from the auto-attributes then from the service def
String entityName = UtilXml.checkEmpty(autoElement.getAttribute("entity-name"));
if (UtilValidate.isEmpty(entityName)) {
entityName = service.defaultEntityName;
if (UtilValidate.isEmpty(entityName)) {
Debug.logWarning("Auto-Attribute does not specify an entity-name; not default-entity on service definition", module);
}
}
// get the include type 'pk|nonpk|all'
String includeType = UtilXml.checkEmpty(autoElement.getAttribute("include"));
boolean includePk = "pk".equals(includeType) || "all".equals(includeType);
boolean includeNonPk = "nonpk".equals(includeType) || "all".equals(includeType);
if (delegator == null) {
Debug.logWarning("Cannot use auto-attribute fields with a null delegator", module);
}
if (delegator != null && entityName != null) {
Map<String, ModelParam> modelParamMap = new LinkedHashMap<String, ModelParam>();
try {
ModelEntity entity = delegator.getModelEntity(entityName);
if (entity == null) {
throw new GeneralException("Could not find entity with name [" + entityName + "]");
}
Iterator<ModelField> fieldsIter = entity.getFieldsIterator();
if (fieldsIter != null) {
while (fieldsIter.hasNext()) {
ModelField field = fieldsIter.next();
if ((!field.getIsAutoCreatedInternal()) && ((field.getIsPk() && includePk) || (!field.getIsPk() && includeNonPk))) {
ModelFieldType fieldType = delegator.getEntityFieldType(entity, field.getType());
if (fieldType == null) {
throw new GeneralException("Null field type from delegator for entity [" + entityName + "]");
}
ModelParam param = new ModelParam();
param.entityName = entityName;
param.fieldName = field.getName();
param.name = field.getName();
param.type = fieldType.getJavaType();
// this is a special case where we use something different in the service layer than we do in the entity/data layer
if ("java.sql.Blob".equals(param.type)) {
param.type = "java.nio.ByteBuffer";
}
param.mode = UtilXml.checkEmpty(autoElement.getAttribute("mode")).intern();
param.optional = "true".equalsIgnoreCase(autoElement.getAttribute("optional")); // default to true
param.formDisplay = !"false".equalsIgnoreCase(autoElement.getAttribute("form-display")); // default to false
param.allowHtml = UtilXml.checkEmpty(autoElement.getAttribute("allow-html"), "none").intern(); // default to none
modelParamMap.put(field.getName(), param);
}
}
// get the excludes list; and remove those from the map
List<? extends Element> excludes = UtilXml.childElementList(autoElement, "exclude");
if (excludes != null) {
for (Element exclude: excludes) {
modelParamMap.remove(UtilXml.checkEmpty(exclude.getAttribute("field-name")));
}
}
// now add in all the remaining params
for (ModelParam thisParam: modelParamMap.values()) {
//Debug.logInfo("Adding Param to " + service.name + ": " + thisParam.name + " [" + thisParam.mode + "] " + thisParam.type + " (" + thisParam.optional + ")", module);
service.addParam(thisParam);
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problem loading auto-attributes [" + entityName + "] for " + service.name, module);
} catch (GeneralException e) {
Debug.logError(e, "Cannot load auto-attributes : " + e.getMessage() + " for " + service.name, module);
}
}
}
private void createAttrDefs(Element baseElement, ModelService service) {
// Add in the defined attributes (override the above defaults if specified)
for (Element attribute: UtilXml.childElementList(baseElement, "attribute")) {
ModelParam param = new ModelParam();
param.name = UtilXml.checkEmpty(attribute.getAttribute("name")).intern();
param.description = getCDATADef(attribute, "description");
param.type = UtilXml.checkEmpty(attribute.getAttribute("type")).intern();
param.mode = UtilXml.checkEmpty(attribute.getAttribute("mode")).intern();
param.entityName = UtilXml.checkEmpty(attribute.getAttribute("entity-name")).intern();
param.fieldName = UtilXml.checkEmpty(attribute.getAttribute("field-name")).intern();
param.requestAttributeName = UtilXml.checkEmpty(attribute.getAttribute("request-attribute-name")).intern();
param.sessionAttributeName = UtilXml.checkEmpty(attribute.getAttribute("session-attribute-name")).intern();
param.stringMapPrefix = UtilXml.checkEmpty(attribute.getAttribute("string-map-prefix")).intern();
param.stringListSuffix = UtilXml.checkEmpty(attribute.getAttribute("string-list-suffix")).intern();
param.formLabel = attribute.hasAttribute("form-label")?attribute.getAttribute("form-label").intern():null;
param.optional = "true".equalsIgnoreCase(attribute.getAttribute("optional")); // default to true
param.formDisplay = !"false".equalsIgnoreCase(attribute.getAttribute("form-display")); // default to false
param.allowHtml = UtilXml.checkEmpty(attribute.getAttribute("allow-html"), "none").intern(); // default to none
// default value
String defValue = attribute.getAttribute("default-value");
if (UtilValidate.isNotEmpty(defValue)) {
if (Debug.verboseOn()) Debug.logVerbose("Got a default-value [" + defValue + "] for service attribute [" + service.name + "." + param.name + "]", module);
param.setDefaultValue(defValue.intern());
}
// set the entity name to the default if not specified
if (param.entityName.length() == 0) {
param.entityName = service.defaultEntityName;
}
// set the field-name to the name if entity name is specified but no field-name
if (param.fieldName.length() == 0 && param.entityName.length() > 0) {
param.fieldName = param.name;
}
// set the validators
this.addValidators(attribute, param);
service.addParam(param);
}
// Add the default optional parameters
ModelParam def;
// responseMessage
def = new ModelParam();
def.name = ModelService.RESPONSE_MESSAGE;
def.type = "String";
def.mode = "OUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// errorMessage
def = new ModelParam();
def.name = ModelService.ERROR_MESSAGE;
def.type = "String";
def.mode = "OUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// errorMessageList
def = new ModelParam();
def.name = ModelService.ERROR_MESSAGE_LIST;
def.type = "java.util.List";
def.mode = "OUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// successMessage
def = new ModelParam();
def.name = ModelService.SUCCESS_MESSAGE;
def.type = "String";
def.mode = "OUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// successMessageList
def = new ModelParam();
def.name = ModelService.SUCCESS_MESSAGE_LIST;
def.type = "java.util.List";
def.mode = "OUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// userLogin
def = new ModelParam();
def.name = "userLogin";
def.type = "org.apache.ofbiz.entity.GenericValue";
def.mode = "INOUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// login.username
def = new ModelParam();
def.name = "login.username";
def.type = "String";
def.mode = "IN";
def.optional = true;
def.internal = true;
service.addParam(def);
// login.password
def = new ModelParam();
def.name = "login.password";
def.type = "String";
def.mode = "IN";
def.optional = true;
def.internal = true;
service.addParam(def);
// Locale
def = new ModelParam();
def.name = "locale";
def.type = "java.util.Locale";
def.mode = "INOUT";
def.optional = true;
def.internal = true;
service.addParam(def);
// timeZone
def = new ModelParam();
def.name = "timeZone";
def.type = "java.util.TimeZone";
def.mode = "INOUT";
def.optional = true;
def.internal = true;
service.addParam(def);
}
private void createOverrideDefs(Element baseElement, ModelService service) {
for (Element overrideElement: UtilXml.childElementList(baseElement, "override")) {
String name = UtilXml.checkEmpty(overrideElement.getAttribute("name"));
ModelParam param = service.getParam(name);
boolean directToParams = true;
if (param == null) {
if (!service.inheritedParameters && (service.implServices.size() > 0 || "group".equals(service.engineName))) {
// create a temp def to place in the ModelService
// this will get read when we read implemented services
directToParams = false;
param = new ModelParam();
param.name = name;
} else {
Debug.logWarning("No parameter found for override parameter named: " + name + " in service " + service.name, module);
}
}
if (param != null) {
// set only modified values
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("type"))) {
param.type = UtilXml.checkEmpty(overrideElement.getAttribute("type")).intern();
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("mode"))) {
param.mode = UtilXml.checkEmpty(overrideElement.getAttribute("mode")).intern();
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("entity-name"))) {
param.entityName = UtilXml.checkEmpty(overrideElement.getAttribute("entity-name")).intern();
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("field-name"))) {
param.fieldName = UtilXml.checkEmpty(overrideElement.getAttribute("field-name")).intern();
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("form-label"))) {
param.formLabel = UtilXml.checkEmpty(overrideElement.getAttribute("form-label")).intern();
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("optional"))) {
param.optional = "true".equalsIgnoreCase(overrideElement.getAttribute("optional")); // default to true
param.overrideOptional = true;
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("form-display"))) {
param.formDisplay = !"false".equalsIgnoreCase(overrideElement.getAttribute("form-display")); // default to false
param.overrideFormDisplay = true;
}
if (UtilValidate.isNotEmpty(overrideElement.getAttribute("allow-html"))) {
param.allowHtml = UtilXml.checkEmpty(overrideElement.getAttribute("allow-html")).intern();
}
// default value
String defValue = overrideElement.getAttribute("default-value");
if (UtilValidate.isNotEmpty(defValue)) {
param.setDefaultValue(defValue);
}
// override validators
this.addValidators(overrideElement, param);
if (directToParams) {
service.addParam(param);
} else {
service.overrideParameters.add(param);
}
}
}
}
private void addValidators(Element attribute, ModelParam param) {
List<? extends Element> validateElements = UtilXml.childElementList(attribute, "type-validate");
if (UtilValidate.isNotEmpty(validateElements)) {
// always clear out old ones; never append
param.validators = new LinkedList<ModelParamValidator>();
Element validate = validateElements.get(0);
String methodName = validate.getAttribute("method").intern();
String className = validate.getAttribute("class").intern();
Element fail = UtilXml.firstChildElement(validate, "fail-message");
if (fail != null) {
String message = fail.getAttribute("message").intern();
param.addValidator(className, methodName, message);
} else {
fail = UtilXml.firstChildElement(validate, "fail-property");
if (fail != null) {
String resource = fail.getAttribute("resource").intern();
String property = fail.getAttribute("property").intern();
param.addValidator(className, methodName, resource, property);
}
}
}
}
private Document getDocument(URL url) {
if (url == null)
return null;
Document document = null;
try {
document = UtilXml.readXmlDocument(url, true, true);
} catch (SAXException sxe) {
// Error generated during parsing)
Exception x = sxe;
if (sxe.getException() != null)
x = sxe.getException();
x.printStackTrace();
} catch (ParserConfigurationException pce) {
// Parser with specified options can't be built
pce.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
return document;
}
}