Example usage for org.dom4j.dom DOMElement getTextTrim

List of usage examples for org.dom4j.dom DOMElement getTextTrim

Introduction

In this page you can find the example usage for org.dom4j.dom DOMElement getTextTrim.

Prototype

public String getTextTrim() 

Source Link

Usage

From source file:org.rivetlogic.export.components.AbstractXMLProcessor.java

License:Open Source License

/**
 * //from   w ww .  ja  v a2  s .  com
 * @param extractRequestElem
 * @return
 */
public int processExportRequest(DOMElement extractRequestElem) {

    // monitors the total number of results
    int totalNumResults = 0;

    List<DOMElement> queryElems = (List<DOMElement>) extractRequestElem.element(QUERIES).elements();
    DOMElement storeRefElem = (DOMElement) extractRequestElem.element(STORE_REF);
    DOMElement extractRequestsElem = (DOMElement) extractRequestElem.getParent();
    DOMElement filtersElem = (DOMElement) extractRequestElem.element(FILTERS);
    DOMElement transformersElem = (DOMElement) extractRequestElem.element(TRANSFORMERS);
    DOMElement deployersElem = (DOMElement) extractRequestElem.element(DEPLOYERS);
    DOMElement undeployersElem = (DOMElement) extractRequestElem.element(UNDEPLOYERS);
    DOMElement dependencyResolversElem = (DOMElement) extractRequestElem.element(DEPENDENCY_RESOLVER);
    DOMElement notifiersElem = (DOMElement) extractRequestElem.element(NOTIFIER);
    DOMElement filterDefinitionsElem = null;
    DOMElement transformerDefinitionsElem = null;
    DOMElement deployerDefinitionsElem = null;
    DOMElement undeployerDefinitionsElem = null;
    DOMElement notifierDefinitionsElem = null;
    DOMElement dependencyResolverDefinitionsElem = null;
    DOMElement definitionsElem = (DOMElement) extractRequestsElem.element(DEFINITIONS);
    if (definitionsElem != null) {
        filterDefinitionsElem = (DOMElement) definitionsElem.element(FILTER_DEFINITIONS);
        transformerDefinitionsElem = (DOMElement) definitionsElem.element(TRANSFORMER_DEFINITIONS);
        deployerDefinitionsElem = (DOMElement) definitionsElem.element(DEPLOYER_DEFINITIONS);
        undeployerDefinitionsElem = (DOMElement) definitionsElem.element(UNDEPLOYER_DEFINITIONS);
        notifierDefinitionsElem = (DOMElement) definitionsElem.element(NOTIFIER_DEFINITIONS);
        dependencyResolverDefinitionsElem = (DOMElement) definitionsElem
                .element(DEPENDENCY_RESOLVER_DEFINITIONS);
    }
    File tmpLocation = new File(IntegrationConstants.TMP_FOLDER + (numExports++) + '/');
    tmpLocation.mkdirs();

    String extractsId = extractRequestsElem.elementText(EXTRACTS_ID);
    /* append ID to milliseconds (fix for Jira ACIR-2) */
    String extractId = String.valueOf(System.currentTimeMillis())
            + extractRequestsElem.elementText(EXTRACTS_ID);

    /* build the XMLExportTO object */
    XMLExportTO xmlExportTO = buildBaseXMLExportTO(filtersElem, deployersElem, undeployersElem,
            dependencyResolversElem, filterDefinitionsElem, deployerDefinitionsElem, undeployerDefinitionsElem,
            dependencyResolverDefinitionsElem, transformerDefinitionsElem, transformersElem,
            notifierDefinitionsElem, notifiersElem, tmpLocation, extractsId, extractId);

    try {
        initialize();

        for (int j = 1; j <= queryElems.size(); j++) {
            DOMElement queryElem = queryElems.get(j - 1);

            xmlExportTO.setQueryElem(queryElem);

            int i = 1;
            boolean done = false;
            String queryId = queryElem.attributeValue(ID, extractId + String.valueOf(j));

            QueryReportData queryReportData = new QueryReportData();
            queryReportData.setExtractsId(extractsId);
            queryReportData.setExtractId(extractId);
            queryReportData.setQueryId(queryId);
            queryReportData.setNumResults(0);

            xmlExportTO.setQueryId(queryId);

            StoreRef storeRef = new StoreRef(storeRefElem.getTextTrim());
            xmlExportTO.setStoreRef(storeRef);

            try {

                /* initialize transform dependency resolver processor - to be used by dispatcher */
                TransformerDependencyResolver tdrp = new TransformerDependencyResolver(searchService,
                        contentService, properties, sortDefinitions, ticket);

                /* initialize request dispatcher */
                ExtractRequestDispatcher dispatcher = new ExtractRequestDispatcher(contentService, nodeService,
                        ticket, eventContext, tdrp);

                DependencyResolverProcessor drp = null;

                /* processing 100 at a time */
                while (!done) {
                    List<Node> nodes = searchService.query(ticket, storeRef, QueryLanguage.lucene,
                            queryElem.getTextTrim(), properties, false, false, false, false, null,
                            (i - 1) * 100, i * 100, sortDefinitions);

                    if (nodes != null) {

                        int parentNodeSize = nodes.size();

                        if (parentNodeSize < 100)
                            done = true;

                        logger.info("Processing nodes...");

                        for (Node node : nodes) {

                            /* Process any dependencies for each node (the Processor also handles the dispatch) */
                            if (dependencyResolversElem != null) {

                                /* initialise the dependency resolver */
                                if (drp == null) {
                                    drp = new DependencyResolverProcessor(searchService, contentService,
                                            properties, sortDefinitions, ticket, dispatcher, nodeService);
                                }

                                drp.processDependencies(node, xmlExportTO);

                                /* if transaction, would assume do here */
                            }

                            /* dispatch the root nodes */
                            dispatchNode(dispatcher, node, xmlExportTO);

                        }

                        i++;
                    } else {
                        done = true;
                    }

                    xmlExportTO.addToNumResults(nodes.size());
                }

                queryReportData.setNumResults(xmlExportTO.getNumResults());
                totalNumResults += xmlExportTO.getNumResults();
            } catch (Exception e) {
                /* ensure error notifier is sent */
                logger.error("Error thrown reading content", e);
                try {
                    eventContext.dispatchEvent(e);
                } catch (MuleException e1) {
                    logger.error("Could not dispatch error message.", e);
                    throw e1;
                }

                /* create query response */
                queryReportData.setErrorMsg(e.getLocalizedMessage());
                logger.error(queryElem.getTextTrim(), e);
            }

            try {
                eventContext.dispatchEvent(queryReportData);
            } catch (Exception e) {
                logger.error("could not dispatch QueryReportData", e);
                throw e;
            }
        }

        ExtractReportData extractReportData = new ExtractReportData();
        extractReportData.setExtractsId(extractsId);
        extractReportData.setExtractId(extractId);
        extractReportData.setNumQueries(queryElems.size());

        try {
            eventContext.dispatchEvent(extractReportData);
        } catch (MuleException e1) {
            logger.error("Could not dispatch ExtractReportData message.", e1);
            throw e1;
        }

    } catch (Exception e) {
        logger.error("Error in initialize()", e);
        try {
            eventContext.dispatchEvent(e);
        } catch (MuleException e1) {
            logger.error("Could not dispatch error message.", e);
        }
    }

    return totalNumResults;
}

From source file:org.rivetlogic.utils.reflection.ObjectFactory.java

License:Open Source License

public Object getObject(DOMElement objectDefinitionElem)
        throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException, ParseException, SecurityException, NoSuchMethodException {
    String objectClass = objectDefinitionElem.attributeValue(CLASS);

    Class cls = Class.forName(objectClass);
    Method[] methods = cls.getMethods();
    HashMap<String, Method> settersMap = new HashMap<String, Method>(methods.length);
    for (Method method : methods) {
        if (method.getName().startsWith("set")) {
            char[] propNameChars = method.getName().substring(3).toCharArray();
            propNameChars[0] = Character.toLowerCase(propNameChars[0]);
            String propName = new String(propNameChars);
            method.setAccessible(true);/* w ww . ja v a  2 s  .c  o m*/
            settersMap.put(propName, method);
        }
    }

    Object object = cls.newInstance();

    DOMElement propertiesElem = (DOMElement) objectDefinitionElem.element(PROPERTIES);

    if (propertiesElem != null) {
        List<DOMElement> propertyElems = propertiesElem.elements();

        for (DOMElement propertyElem : propertyElems) {
            String name = propertyElem.getAttribute(NAME);

            if (name != null && name.length() > 0 && settersMap.containsKey(name)) {
                Method method = settersMap.get(name);
                Class[] paramTypes = method.getParameterTypes();
                if (paramTypes.length == 1) {
                    String paramTypeName = paramTypes[0].getName();
                    String paramTypeNameLower = paramTypeName.toLowerCase();
                    Object param = null;

                    /* */
                    String value = null;
                    if (propertyElem.isTextOnly()) {
                        value = propertyElem.getTextTrim();
                    }

                    if (paramTypeNameLower.startsWith("int")) {
                        param = Integer.valueOf(value);
                    } else if (paramTypeNameLower.startsWith("short")) {
                        param = Short.valueOf(value);
                    } else if (paramTypeNameLower.startsWith("double")) {
                        param = Double.valueOf(value);
                    } else if (paramTypeNameLower.startsWith("float")) {
                        param = Float.valueOf(value);
                    } else if (paramTypeNameLower.startsWith("byte")) {
                        param = Byte.valueOf(value);
                    } else if (paramTypeNameLower.startsWith("char")) {
                        param = Character.valueOf(value.charAt(0));
                    } else if (paramTypeName.equals(Date.class.getName())) {
                        param = IntegrationConstants.xmlDateTimeFormat.parse(value);
                    } else if (List.class.isAssignableFrom(Class.forName(paramTypeName))) {
                        String propertyClassName = propertyElem.getAttribute(CLASS);
                        Class propertyClass = Class.forName(propertyClassName);
                        param = getList(propertyClass, propertyElem);
                    } else if (Map.class.isAssignableFrom(Class.forName(paramTypeName))) {
                        String propertyClassName = propertyElem.getAttribute(CLASS);
                        Class propertyClass = Class.forName(propertyClassName);
                        param = getMap(propertyClass, propertyElem);
                    } else {
                        param = value;
                    }

                    log.debug("Setting property '" + name + "' to '" + param + "'");
                    method.invoke(object, param);
                } else {
                    throw new IllegalArgumentException(
                            "Method should take only one parameter. Could not set property " + name
                                    + " of class " + objectClass);
                }
            }
        }
    }

    return object;
}

From source file:org.rivetlogic.utils.reflection.ObjectFactory.java

License:Open Source License

private Object getMap(Class<Map> mapClass, DOMElement mapElem)
        throws InstantiationException, IllegalAccessException, ClassNotFoundException, IllegalArgumentException,
        SecurityException, InvocationTargetException, ParseException, NoSuchMethodException {

    Object mapObj = mapClass.newInstance();
    DOMElement entriesElem = (DOMElement) mapElem.element(ENTRIES);

    if (entriesElem != null) {
        Method method = mapClass.getMethod(PUT_METHOD, Object.class, Object.class);

        List<DOMElement> entryElems = entriesElem.elements();
        for (DOMElement entryElem : entryElems) {
            String mapKey = entryElem.attributeValue(MAP_KEY);

            String value;//from   ww w.  ja v a  2 s  .  co  m
            if (entryElem.isTextOnly()) {
                value = entryElem.getTextTrim();

                method.invoke(mapObj, mapKey, value);

            } else {

                Object mapEntry = null;
                String className = entryElem.attributeValue(CLASS);
                Class propertyClass = Class.forName(className);
                if (List.class.isAssignableFrom(propertyClass)) {
                    mapEntry = getList(propertyClass, entryElem);
                } else {
                    mapEntry = getObject(entryElem);
                }

                method.invoke(mapObj, mapKey, mapEntry);
            }

        }

    }

    return mapObj;
}

From source file:org.rivetlogic.utils.reflection.ObjectFactory.java

License:Open Source License

private Object getList(Class<List> listClass, DOMElement listElem)
        throws IllegalArgumentException, ClassNotFoundException, InstantiationException, IllegalAccessException,
        InvocationTargetException, ParseException, SecurityException, NoSuchMethodException {

    Object listObj = listClass.newInstance();
    DOMElement entriesElem = (DOMElement) listElem.element(ENTRIES);

    if (entriesElem != null) {
        List<DOMElement> entryElems = entriesElem.elements();
        Method method = listClass.getMethod(ADD_METHOD, Object.class);

        for (DOMElement entryElem : entryElems) {

            String value;//from  w  w w  .jav a 2s.c o m
            if (entryElem.isTextOnly()) {
                value = entryElem.getTextTrim();

                method.invoke(listObj, value);

            } else {

                Object listEntry = getObject(entryElem);
                method.invoke(listObj, listEntry);
            }
        }
    }

    return listObj;

}