com.adobe.aemds.guide.utils.FieldNameResolverForData Maven / Gradle / Ivy

Go to download
/*******************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 *
 ******************************************************************************/

package com.adobe.aemds.guide.utils;

import com.adobe.aemds.guide.transformer.api.ResourcePropertyTransformer;
import org.apache.commons.lang.StringUtils;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.commons.json.JSONException;
import org.apache.sling.commons.json.JSONObject;
import org.apache.sling.commons.json.xml.XML;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by sachjain on 5/18/2017.
 */
public class FieldNameResolverForData implements ResourcePropertyTransformer {
    private final Logger logger = LoggerFactory.getLogger(FieldNameResolverForData.class);

    private final String schemaRoot;
    private final Map fieldParamMap;
    private final Map mappedParameters;

    private final Document document;
    private final XPath xPath;
    private final Element boundData;
    private final Element unboundData;

    public FieldNameResolverForData(String data, String dataType, String[] fieldNames, String schemaRoot) {
        this.schemaRoot = schemaRoot;
        mappedParameters = new HashMap<>();

        fieldParamMap = GuideSubmitUtils.getMappedFieldParameters(fieldNames);

        if (GuideConstants.CONTENT_TYPE_APPLICATION_JSON.equals(dataType)) {
            try {
                JSONObject dataJson = new JSONObject(data);
                if(!dataJson.has(GuideConstants.WRAPPED_SUBMIT_JSON_ROOT)) {
                    JSONObject wrappedJson = new JSONObject().put(GuideConstants.UNWRAPPED_SUBMIT_ROOT, dataJson);
                    dataJson = wrappedJson;
                }
                data = XML.toString(dataJson);
            } catch (JSONException e) {
                logger.error("Failed to retrieve data from submit data JSON.", e);
            }
        }

        document = XMLUtils.strToDoc(data);
        xPath = XPathFactory.newInstance().newXPath();
        boundData = XMLUtils.getBoundDataXmlElement(document);
        unboundData = XMLUtils.getUnboundDataXmlElement(document);
    }

    @Override
    public JSONObject transform(Resource resource, String parentSOM) throws JSONException {
        if (fieldParamMap.isEmpty()) {
            return null;
        }

        ValueMap properties = resource.getValueMap();
        JSONObject formObject = new JSONObject(properties);
        String name = properties.get(GuideConstants.NAME, "");

        String resourceName = resource.getName();
        switch (resourceName) {
            case GuideConstants.LAYOUT_NODENAME:
            case GuideConstants.ITEMS_NODENAME:
                return formObject;
            default:
        }

        String guideNodeClass = properties.get(GuideConstants.GUIDE_NODE_CLASS, "");
        switch (guideNodeClass) {
            case GuideConstants.GUIDE_PANEL:
            case GuideConstants.GUIDE_TABLE:
            case GuideConstants.GUIDE_TABLE_ROW:
            case StringUtils.EMPTY:
                return formObject;
            default:
        }


        if (fieldParamMap.containsKey(name)) {
            String value = "";
            String bindRef = properties.get(GuideConstants.BIND_REF, "");
            String dataSom = properties.get(GuideConstants.DATA_SOM, "");

            bindRef = resolveBindRef(bindRef);

            try {
                Node node = null;
                if (StringUtils.isNotEmpty(bindRef)) {
                    if (StringUtils.isNotEmpty(dataSom)) {
                        dataSom = dataSom.replaceFirst("xfa\\[0\\]\\.", "").replaceAll("\\[\\s*\\d+\\s*\\]", "").replaceAll("\\.", "/");
                        String xPathExpression = XMLUtils.getRelativeXpath(dataSom, schemaRoot);
                        node = (Node) xPath.evaluate(xPathExpression, boundData, XPathConstants.NODE);
                    } else {
                        bindRef = StringUtils.replace(bindRef, "/text()", "");
                        String xPathExpression = XMLUtils.getRelativeXpath(bindRef, schemaRoot);
                        node = (Node) xPath.evaluate(xPathExpression, boundData, XPathConstants.NODE);
                    }
                } else {
                    String nameOfCompositeField = GuideSubmitUtils.getNameOfCompositeFieldFromChildResource(resource);
                    // special handling for composite fields
                    if (StringUtils.isNotBlank(nameOfCompositeField)) {
                        node = (Node) xPath.evaluate(nameOfCompositeField + "/" + name, unboundData, XPathConstants.NODE);
                    } else {
                        node = (Node) xPath.evaluate(name, unboundData, XPathConstants.NODE);
                    }
                }

                if (node != null) {
                    value = node.getTextContent();
                }
            } catch (XPathExpressionException e) {
                logger.error("Failed to get data corresponding to field " + name, e);
            }

            mappedParameters.put(fieldParamMap.get(name), value);
            fieldParamMap.remove(name);
        }

        return formObject;
    }

    public Map getMappedParameters() {
        return mappedParameters;
    }

    private String resolveBindRef(String bindRef) {
        GuideFragmentHolder guideFragmentHolder = null;
        try {
            guideFragmentHolder = GuideContainerThreadLocal.getGuideFragmentHolder();
            if (guideFragmentHolder != null) {
                String bindRefPrefixForFragment = guideFragmentHolder.getBindRefPrefixForFragment();
                String fragmentRoot = guideFragmentHolder.getFragmentModelRoot();
                bindRef = GuideUtils.manipulateBindRefForFragments(bindRefPrefixForFragment, bindRef, fragmentRoot);
            }
        } catch (Exception e) {
            logger.error("Unable to get fragment holder", e);
        }
        return bindRef;
    }
}