615 lines
22 KiB
Java
615 lines
22 KiB
Java
/*
|
|
* To change this template, choose Tools | Templates
|
|
* and open the template in the editor.
|
|
*/
|
|
package com.sun.jbi.ldapbc.util;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.Enumeration;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import java.util.Map;
|
|
import java.util.HashMap;
|
|
import javax.jbi.messaging.MessagingException;
|
|
import javax.naming.directory.SearchControls;
|
|
import javax.wsdl.Binding;
|
|
import javax.wsdl.BindingInput;
|
|
import javax.wsdl.BindingOperation;
|
|
import javax.wsdl.BindingOutput;
|
|
import javax.wsdl.Definition;
|
|
import javax.wsdl.Operation;
|
|
import javax.wsdl.Port;
|
|
import javax.wsdl.PortType;
|
|
import javax.wsdl.Service;
|
|
import javax.wsdl.extensions.ExtensibilityElement;
|
|
import javax.wsdl.factory.WSDLFactory;
|
|
import javax.wsdl.xml.WSDLReader;
|
|
import javax.wsdl.WSDLException;
|
|
import javax.xml.namespace.QName;
|
|
|
|
import org.exolab.castor.xml.schema.Schema;
|
|
import org.exolab.castor.xml.schema.AttributeDecl;
|
|
import org.exolab.castor.xml.schema.ComplexType;
|
|
import org.exolab.castor.xml.schema.ElementDecl;
|
|
import org.exolab.castor.xml.schema.Group;
|
|
import org.exolab.castor.xml.schema.reader.SchemaReader;
|
|
import org.xml.sax.EntityResolver;
|
|
import org.apache.xml.resolver.tools.CatalogResolver;
|
|
import org.apache.xml.resolver.CatalogManager;
|
|
|
|
import com.ibm.wsdl.factory.WSDLFactoryImpl;
|
|
import com.sun.jbi.internationalization.Messages;
|
|
import com.sun.jbi.ldapbc.LDAPBindingDeployer;
|
|
import com.sun.jbi.ldapbc.OperationMetaData;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPAddress;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPBinding;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPExtensionRegistry;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPOperation;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPOperationInput;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPOperationOutput;
|
|
import com.sun.jbi.ldapbc.extensions.LDAPExtPreprocessDeserializer;
|
|
import com.sun.jbi.ldapbc.update.UpdateBean;
|
|
|
|
/**
|
|
*
|
|
* @author Gary Zheng
|
|
*/
|
|
public class LdapHelper {
|
|
|
|
private static final Logger mLogger = Messages.getLogger(LDAPBindingDeployer.class);
|
|
|
|
public static SearchControls getSearchControl(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
SearchControls ret = null;
|
|
ElementDecl scopeElem = request.getElementDecl("scope");
|
|
ElementDecl limitElem = request.getElementDecl("size");
|
|
ElementDecl timeoutElem = request.getElementDecl("timeout");
|
|
ElementDecl derefElem = request.getElementDecl("deref");
|
|
//ElementDecl recordsPerPageElem = request.getElementDecl("recordsperpage");
|
|
|
|
ret = new SearchControls();
|
|
|
|
ret.setCountLimit(Long.valueOf(limitElem.getDefaultValue()));
|
|
ret.setDerefLinkFlag(Boolean.valueOf(derefElem.getDefaultValue()));
|
|
ret.setSearchScope(Integer.valueOf(scopeElem.getDefaultValue()));
|
|
ret.setTimeLimit(Integer.valueOf(timeoutElem.getDefaultValue()));
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static String getReferral(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
String ret = null;
|
|
ElementDecl referralElem = request.getElementDecl("referral");
|
|
|
|
ret = referralElem.getDefaultValue();
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static int getRecordsPerPage(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
|
|
ElementDecl recordsPerPageElem = request.getElementDecl("recordsperpage");
|
|
|
|
return Integer.valueOf(recordsPerPageElem.getDefaultValue()).intValue();
|
|
}
|
|
|
|
public static String getDN(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
String ret = null;
|
|
ElementDecl dnElem = request.getElementDecl("dn");
|
|
|
|
ret = dnElem.getDefaultValue();
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static void setQueryAttributes(Schema schema, OperationMetaData meta) throws MessagingException {
|
|
ComplexType searchFilterType = schema.getComplexType("SearchFilterType");
|
|
int gCount = searchFilterType.getParticleCount();
|
|
if (gCount < 0) {
|
|
throw new MessagingException("LDAP schema searchFilterType have no sequence");
|
|
}
|
|
Group group = (Group) searchFilterType.getParticle(0);
|
|
int eleCount = group.getParticleCount();
|
|
for (int l = 0; l < eleCount; l++) {
|
|
ElementDecl element = (ElementDecl) group.getParticle(l);
|
|
String eleName = element.getName();
|
|
int positionIndex = -1;
|
|
int bracketDepth = -1;
|
|
int bracketBeginDepth = -1;
|
|
int bracketEndDepth = -1;
|
|
String logicOp = "";
|
|
String compareOp = "";
|
|
Enumeration attrs = ((ComplexType) element.getType()).getAttributeDecls();
|
|
while (attrs.hasMoreElements()) {
|
|
AttributeDecl attr = (AttributeDecl) attrs.nextElement();
|
|
String attrName = attr.getName();
|
|
if (attrName.equals("positionIndex")) {
|
|
positionIndex = Integer.parseInt(attr.getFixedValue());
|
|
continue;
|
|
}
|
|
if (attrName.equals("bracketDepth")) {
|
|
bracketDepth = Integer.parseInt(attr.getFixedValue());
|
|
continue;
|
|
}
|
|
if (attrName.equals("bracketBeginDepth")) {
|
|
bracketBeginDepth = Integer.parseInt(attr.getFixedValue());
|
|
continue;
|
|
}
|
|
if (attrName.equals("bracketEndDepth")) {
|
|
bracketEndDepth = Integer.parseInt(attr.getFixedValue());
|
|
continue;
|
|
}
|
|
if (attrName.equals("logicOp")) {
|
|
logicOp = attr.getFixedValue();
|
|
continue;
|
|
}
|
|
if (attrName.equals("compareOp")) {
|
|
compareOp = attr.getFixedValue();
|
|
}
|
|
}
|
|
element = null;
|
|
meta.addAttribute(positionIndex, bracketDepth, bracketBeginDepth, bracketEndDepth, logicOp, compareOp, eleName);
|
|
}
|
|
}
|
|
|
|
public static List<File> listXSDFiles(final File dir) {
|
|
final List<File> cumulativeResults = new ArrayList<File>();
|
|
final File[] filesInCurrentDir = dir.listFiles();
|
|
|
|
for (File element : filesInCurrentDir) {
|
|
|
|
if (element.isFile()) {
|
|
|
|
if (element.getName().toLowerCase().endsWith(".xsd")) {
|
|
cumulativeResults.add(element);
|
|
}
|
|
} else if (element.isDirectory()) {
|
|
final List<File> wsdlsInSubDirectories = listXSDFiles(element);
|
|
cumulativeResults.addAll(wsdlsInSubDirectories);
|
|
}
|
|
}
|
|
return cumulativeResults;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param f
|
|
* @return
|
|
* @throws java.lang.Exception
|
|
*/
|
|
public static Schema readXsd(File f) throws Exception {
|
|
SchemaReader reader = new SchemaReader(f);
|
|
Schema schema = reader.read();
|
|
return schema;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param bindingOutput
|
|
* @return
|
|
*/
|
|
public static LDAPOperationOutput getLDAPOperationOutput(
|
|
final BindingOutput bindingOutput) {
|
|
LDAPOperationOutput operationOutput = null;
|
|
|
|
final List extElems = bindingOutput.getExtensibilityElements();
|
|
|
|
// Look for ldap:output entries
|
|
final Iterator extIter = (extElems == null) ? null : extElems.iterator();
|
|
|
|
while ((extIter != null) && extIter.hasNext()) {
|
|
final ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
|
|
if (LDAPOperationOutput.class.isInstance(ee)) {
|
|
operationOutput = (LDAPOperationOutput) ee;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return operationOutput;
|
|
}
|
|
|
|
public static Map<String, String[]> parseForEnvironmentVariables(final File suDir, final Map<String, String[]> envVariableMap) throws Exception {
|
|
Map<String, String[]> envVariables =
|
|
new HashMap<String, String[]>(envVariableMap);
|
|
|
|
File catalog = new File(suDir.getAbsolutePath() + File.separator + "META-INF" + File.separator + "catalog.xml");
|
|
|
|
EntityResolver resolver = null;
|
|
|
|
if (catalog.exists()) {
|
|
CatalogManager catalogManager = new CatalogManager();
|
|
catalogManager.setCatalogFiles(catalog.getAbsolutePath());
|
|
catalogManager.setRelativeCatalogs(true);
|
|
catalogManager.setUseStaticCatalog(false);
|
|
resolver = new CatalogResolver(catalogManager);
|
|
}
|
|
|
|
for (File file : listWSDLFiles(suDir)) {
|
|
envVariables.putAll(
|
|
readWSDLForEnvVariables(file,
|
|
resolver,
|
|
envVariables));
|
|
}
|
|
|
|
return envVariables;
|
|
}
|
|
|
|
public static Map readWSDLForEnvVariables(final File f, final EntityResolver resolver,
|
|
final Map<String, String[]> envVariableMap) throws WSDLException {
|
|
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
WSDLReader reader = resolver == null ? ((WSDLFactoryImpl) wsdlFactory).newWSDLReader() : ((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
|
|
LDAPExtPreprocessDeserializer preProcessDeserializer = new LDAPExtPreprocessDeserializer(
|
|
envVariableMap);
|
|
reader.setExtensionRegistry(new LDAPExtensionRegistry(
|
|
preProcessDeserializer));
|
|
reader.readWSDL(f.getAbsolutePath());
|
|
return preProcessDeserializer.getEnvVariableMap();
|
|
}
|
|
|
|
public static List<File> listWSDLFiles(final File currentDir) {
|
|
final List<File> cumulativeResults = new ArrayList<File>();
|
|
final File[] filesInCurrentDir = currentDir.listFiles();
|
|
|
|
for (File element : filesInCurrentDir) {
|
|
|
|
if (element.isFile()) {
|
|
|
|
if (element.getName().toLowerCase().endsWith(".wsdl")) {
|
|
cumulativeResults.add(element);
|
|
}
|
|
} else if (element.isDirectory()) {
|
|
final List<File> wsdlsInSubDirectories = listWSDLFiles(element);
|
|
cumulativeResults.addAll(wsdlsInSubDirectories);
|
|
}
|
|
}
|
|
return cumulativeResults;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param f
|
|
* @param resolver
|
|
* @return
|
|
* @throws javax.wsdl.WSDLException
|
|
*/
|
|
/* public static Definition readWsdl(final File f, final EntityResolver resolver)
|
|
throws javax.wsdl.WSDLException {
|
|
final WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
final WSDLReader reader = ((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
reader.setExtensionRegistry(new LDAPExtensionRegistry());
|
|
|
|
final Definition def = reader.readWSDL(f.getAbsolutePath());
|
|
|
|
|
|
return def;
|
|
} */
|
|
public static Definition readWSDL(final File f, final EntityResolver resolver,
|
|
final Map<String, String[]> envVariableMap) throws WSDLException {
|
|
final WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
final WSDLReader reader = resolver == null ? ((WSDLFactoryImpl) wsdlFactory).newWSDLReader() : ((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
reader.setExtensionRegistry(new LDAPExtensionRegistry(envVariableMap));
|
|
final Definition def = reader.readWSDL(f.getAbsolutePath());
|
|
|
|
return def;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param def
|
|
* @param serviceName
|
|
* @param endpointName
|
|
* @return
|
|
*/
|
|
public static Binding getBinding(final Definition def, final String serviceName,
|
|
final String endpointName) {
|
|
final Service svc = def.getService(QName.valueOf(serviceName));
|
|
|
|
if (svc == null) {
|
|
return null;
|
|
}
|
|
|
|
final Port port = svc.getPort(QName.valueOf(endpointName).getLocalPart());
|
|
|
|
if (port == null) {
|
|
return null;
|
|
} else {
|
|
return port.getBinding();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param def
|
|
* @param portTypeName
|
|
* @param operationName
|
|
* @return
|
|
*/
|
|
public static Operation getOperation(final Definition def, final String portTypeName,
|
|
final String operationName) {
|
|
Operation operation = null;
|
|
final PortType pType = def.getPortType(QName.valueOf(portTypeName));
|
|
|
|
if (pType != null) {
|
|
operation = pType.getOperation(operationName, null, null);
|
|
}
|
|
|
|
return operation;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param def
|
|
* @param serviceName
|
|
* @param endpointName
|
|
* @return
|
|
*/
|
|
public static LDAPAddress getLDAPAddress(final Definition def, final String serviceName,
|
|
final String endpointName) {
|
|
LDAPAddress address = null;
|
|
final Service svc = def.getService(QName.valueOf(serviceName));
|
|
|
|
if (svc == null) {
|
|
return null;
|
|
}
|
|
|
|
final Port port = svc.getPort(QName.valueOf(endpointName).getLocalPart());
|
|
|
|
if (port != null) {
|
|
final List extElems = port.getExtensibilityElements();
|
|
|
|
// Look for ldap:address
|
|
final Iterator extIter = (extElems == null) ? null : extElems.iterator();
|
|
|
|
while ((extIter != null) && extIter.hasNext() &&
|
|
(address == null)) {
|
|
final ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
|
|
if (LDAPAddress.class.isInstance(ee)) {
|
|
address = (LDAPAddress) ee;
|
|
}
|
|
}
|
|
}
|
|
|
|
return address;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param def
|
|
* @param serviceName
|
|
* @param endpointName
|
|
* @return
|
|
*/
|
|
public static LDAPBinding getLDAPBinding(final Definition def, final String serviceName,
|
|
final String endpointName) {
|
|
LDAPBinding ldapBinding = null;
|
|
final Binding binding = getBinding(def, serviceName, endpointName);
|
|
|
|
if (binding != null) {
|
|
final List extElems = binding.getExtensibilityElements();
|
|
|
|
// Look for ldap:binding
|
|
final Iterator extIter = (extElems == null) ? null : extElems.iterator();
|
|
|
|
while ((extIter != null) && extIter.hasNext() &&
|
|
(ldapBinding == null)) {
|
|
final ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
|
|
if (LDAPBinding.class.isInstance(ee)) {
|
|
ldapBinding = (LDAPBinding) ee;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ldapBinding;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param def
|
|
* @param serviceName
|
|
* @param endpointName
|
|
* @return
|
|
*/
|
|
public static LDAPOperation[] getLDAPOperations(final Definition def,
|
|
final String serviceName, final String endpointName) {
|
|
final List<ExtensibilityElement> ldapOperations = new ArrayList<ExtensibilityElement>();
|
|
final Binding binding = LdapHelper.getBinding(def, serviceName, endpointName);
|
|
|
|
if (binding != null) {
|
|
final List bindingOperations = binding.getBindingOperations();
|
|
final Iterator operIter = (bindingOperations == null) ? null
|
|
: bindingOperations.iterator();
|
|
|
|
while ((operIter != null) && operIter.hasNext()) {
|
|
final BindingOperation oper = (BindingOperation) operIter.next();
|
|
final List extElems = oper.getExtensibilityElements();
|
|
|
|
// Look for file:operation entries
|
|
final Iterator extIter = (extElems == null) ? null
|
|
: extElems.iterator();
|
|
|
|
while ((extIter != null) && extIter.hasNext()) {
|
|
final ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
|
|
if (LDAPOperation.class.isInstance(ee)) {
|
|
ldapOperations.add(ee);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ldapOperations.toArray(new LDAPOperation[0]);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param bindingInput
|
|
* @return
|
|
*/
|
|
public static LDAPOperationInput getLDAPOperationInput(
|
|
final BindingInput bindingInput) {
|
|
LDAPOperationInput operationInput = null;
|
|
final List extElems = bindingInput.getExtensibilityElements();
|
|
|
|
// Look for ldap:input entries
|
|
final Iterator extIter = (extElems == null) ? null : extElems.iterator();
|
|
|
|
while ((extIter != null) && extIter.hasNext()) {
|
|
final ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
|
|
if (LDAPOperationInput.class.isInstance(ee)) {
|
|
operationInput = (LDAPOperationInput) ee;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return operationInput;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param ldapOperation
|
|
* @param def
|
|
* @param serviceName
|
|
* @param endpointName
|
|
* @return
|
|
*/
|
|
public static BindingOperation getParentBindingOperation(
|
|
final LDAPOperation ldapOperation, final Definition def, final String serviceName,
|
|
final String endpointName) {
|
|
BindingOperation bindingOperation = null;
|
|
|
|
final Binding binding = LdapHelper.getBinding(def, serviceName, endpointName);
|
|
|
|
if (binding != null) {
|
|
final List l = binding.getBindingOperations();
|
|
final Iterator it = l.iterator();
|
|
|
|
while (it.hasNext()) {
|
|
final BindingOperation bOperation = (BindingOperation) it.next();
|
|
final List exElements = bOperation.getExtensibilityElements();
|
|
|
|
if ((exElements != null) &&
|
|
exElements.contains(ldapOperation)) {
|
|
bindingOperation = bOperation;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bindingOperation;
|
|
}
|
|
|
|
public static Schema getSchema(String nsUri, File dir) {
|
|
Schema ret = null;
|
|
List<File> xsdFileList = LdapHelper.listXSDFiles(dir);
|
|
for (int k = 0; k < xsdFileList.size(); k++) {
|
|
File f = xsdFileList.get(k);
|
|
String uri = "";
|
|
try {
|
|
Schema schema = LdapHelper.readXsd(f);
|
|
uri = schema.getTargetNamespace();
|
|
if (nsUri.equals(uri)) {
|
|
ret = schema;
|
|
break;
|
|
}
|
|
} catch (Exception ex) {
|
|
LdapHelper.mLogger.log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static List<String> getResponseAttributes(Schema schema) throws MessagingException {
|
|
List<String> ret = new ArrayList<String>();
|
|
ComplexType responseType = schema.getComplexType("ResponseEntryType");
|
|
Group resGroup = (Group) responseType.getParticle(0);
|
|
int resGroupCount = resGroup.getParticleCount();
|
|
if (resGroupCount < 1) {
|
|
throw new MessagingException("LDAP schema ResponseType have no response element");
|
|
}
|
|
for (int n = 0; n < resGroupCount; n++) {
|
|
ElementDecl resEle = (ElementDecl) resGroup.getParticle(n);
|
|
ret.add(resEle.getName());
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static void setUpdateAttributes(Schema schema, OperationMetaData opMetaData) throws MessagingException {
|
|
ComplexType updateType = schema.getComplexType("UpdateElementsType");
|
|
Group updateGroup = (Group) updateType.getParticle(0);
|
|
int updateGroupCount = updateGroup.getParticleCount();
|
|
if (updateGroupCount < 1) {
|
|
throw new MessagingException("LDAP schema UpdateElementsType have no update element");
|
|
}
|
|
for (int l = 0; l < updateGroupCount; l++) {
|
|
ElementDecl element = (ElementDecl) updateGroup.getParticle(l);
|
|
String eleName = element.getName();
|
|
int index = eleName.indexOf(".");
|
|
String objName = eleName.substring(0, index);
|
|
String updateAttrName = eleName.substring(index + 1);
|
|
String opType = "";
|
|
Enumeration attrs = ((ComplexType) element.getType()).getAttributeDecls();
|
|
while (attrs.hasMoreElements()) {
|
|
AttributeDecl attr = (AttributeDecl) attrs.nextElement();
|
|
String attrName = attr.getName();
|
|
if ("opType".equals(attrName)) {
|
|
opType = attr.getFixedValue();
|
|
}
|
|
if ("".equals(opType)) {
|
|
throw new MessagingException("Can't get opType from schema");
|
|
}
|
|
UpdateBean updateBean = new UpdateBean(objName, updateAttrName, opType);
|
|
opMetaData.addUpdateAttribute(eleName, updateBean);
|
|
}
|
|
element = null;
|
|
}
|
|
}
|
|
|
|
public static List<String> getAddedReturnAttrs(Schema schema) throws MessagingException {
|
|
List<String> ret = new ArrayList<String>();
|
|
ComplexType responseType = schema.getComplexType("AddReturnAttributesType");
|
|
Group resGroup = (Group) responseType.getParticle(0);
|
|
int resGroupCount = resGroup.getParticleCount();
|
|
if (resGroupCount < 1) {
|
|
throw new MessagingException("LDAP schema ResponseType have no response element");
|
|
}
|
|
for (int n = 0; n < resGroupCount; n++) {
|
|
ElementDecl resEle = (ElementDecl) resGroup.getParticle(n);
|
|
ret.add(resEle.getName());
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static String getSortedByAttribute(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
|
|
ElementDecl recordsPerPageElem = request.getElementDecl("sortbyattribute");
|
|
|
|
return recordsPerPageElem.getDefaultValue();
|
|
}
|
|
|
|
public static String getSortedByType(Schema schema) throws MessagingException {
|
|
ComplexType request = schema.getComplexType("RequestPropertyType");
|
|
|
|
ElementDecl recordsPerPageElem = request.getElementDecl("sorttype");
|
|
|
|
return recordsPerPageElem.getDefaultValue();
|
|
}
|
|
}
|