Example usage for org.dom4j.dom DOMElement attributeValue

Introduction

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

Prototype

public String attributeValue(String name, String defaultValue) 

Source Link

Usage

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

License:Open Source License

/**
 * // w w w.j ava  2s .co  m
 * @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;
}

---