Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.aemds.guide.utils.CustomJSONWriter
 *  com.adobe.aemds.guide.utils.GuideUtils
 *  com.adobe.icc.dbforms.obj.ContainerLayout
 *  com.adobe.icc.dbforms.obj.ContainerLayoutAssignment
 *  com.adobe.icc.dbforms.obj.Field
 *  com.adobe.icc.dbforms.obj.Field$FieldType
 *  com.adobe.icc.dbforms.obj.FieldAssignment
 *  com.adobe.icc.dbforms.obj.Form
 *  com.adobe.icc.dbforms.obj.Letter
 *  com.adobe.icc.dbforms.obj.Table
 *  com.adobe.icc.dbforms.obj.TableColumnDetails
 *  com.adobe.icc.dbforms.obj.TableRow
 *  com.adobe.icc.dbforms.obj.TargetArea
 *  com.adobe.icc.dbforms.obj.TargetAreaAssignment
 *  org.apache.commons.collections.CollectionUtils
 *  org.apache.commons.lang3.StringUtils
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.fd.adaddon.internal.utils;

import com.adobe.aemds.guide.utils.CustomJSONWriter;
import com.adobe.aemds.guide.utils.GuideUtils;
import com.adobe.fd.adaddon.internal.utils.ADUtils;
import com.adobe.icc.dbforms.obj.ContainerLayout;
import com.adobe.icc.dbforms.obj.ContainerLayoutAssignment;
import com.adobe.icc.dbforms.obj.Field;
import com.adobe.icc.dbforms.obj.FieldAssignment;
import com.adobe.icc.dbforms.obj.Form;
import com.adobe.icc.dbforms.obj.Letter;
import com.adobe.icc.dbforms.obj.Table;
import com.adobe.icc.dbforms.obj.TableColumnDetails;
import com.adobe.icc.dbforms.obj.TableRow;
import com.adobe.icc.dbforms.obj.TargetArea;
import com.adobe.icc.dbforms.obj.TargetAreaAssignment;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LetterToJsonTransformer {
    private static final Logger log = LoggerFactory.getLogger(LetterToJsonTransformer.class);
    private static final String XFA_FIELD_TYPE_EXCL_GROUP = "exclGroup";
    private static final String XFA_FIELD_TYPE_CHOICE_LIST = "choiceList";
    private static final String XFA_FIELD_TYPE_CHECK_BUTTON = "checkButton";
    private final Map<String, FieldAssignment> fieldAssignmentMap = new HashMap<String, FieldAssignment>();
    private final Map<String, TargetAreaAssignment> targetAreaAssignmentMap = new HashMap<String, TargetAreaAssignment>();
    private final Map<String, ContainerLayoutAssignment> containerLayoutAssignmentMap = new HashMap<String, ContainerLayoutAssignment>();
    private final Letter letter;
    private final Map<String, Integer> taFieldOrder;
    private long timestamp = System.nanoTime();
    private int uniqCounter = 0;
    private String currentContainerSOM;
    private LetterModelTreeNode rootNode;
    private LetterModelTreeNode currentNode;
    private String jsonString;
    private static final int ORDER_MULTIPLIER = 100;

    public LetterToJsonTransformer(Letter letter, Map<String, Integer> taFieldOrder) {
        this.letter = letter;
        this.taFieldOrder = taFieldOrder;
    }

    private String treeToJsonString() {
        StringWriter sw = new StringWriter();
        CustomJSONWriter jw = new CustomJSONWriter((Writer)sw);
        jw.object();
        this.rootNode.sort();
        this.rootNode.toJSON(jw);
        jw.endObject();
        return sw.toString();
    }

    public String getJsonString() {
        if (this.jsonString == null) {
            this.transform();
            this.jsonString = this.treeToJsonString();
        }
        return this.jsonString;
    }

    private void transform() {
        if (this.letter == null) {
            log.error("letter object is null, empty object will be generated");
            return;
        }
        this.traverse(this.letter);
        if (this.letter.getForm() == null) {
            log.error("Form is null for letter: " + this.letter.getId() + ", empty object will be generated");
            return;
        }
        this.transform(this.letter.getForm());
    }

    private void traverse(Letter letter) {
        this.traverseFieldAssignments(letter.getFieldAssignments());
        this.traverseTargetAreaAssignments(letter.getTargetAreaAssignments());
    }

    private void traverseFieldAssignments(Set<FieldAssignment> fieldsAssignments) {
        if (CollectionUtils.isNotEmpty(fieldsAssignments)) {
            for (FieldAssignment fieldAssignment : fieldsAssignments) {
                this.traverse(fieldAssignment);
            }
        }
    }

    private void traverseTargetAreaAssignments(Set<TargetAreaAssignment> targetAreaAssignments) {
        if (CollectionUtils.isNotEmpty(targetAreaAssignments)) {
            for (TargetAreaAssignment targetAreaAssignment : targetAreaAssignments) {
                this.traverse(targetAreaAssignment);
            }
        }
    }

    private void traverse(FieldAssignment fieldAssignment) {
        this.fieldAssignmentMap.put(this.getAbsoluteSom(fieldAssignment.getField().getPath()), fieldAssignment);
    }

    private void traverse(TargetAreaAssignment targetAreaAssignment) {
        String absoluteSom = this.getAbsoluteSom(targetAreaAssignment.getTargetArea().getPath());
        this.targetAreaAssignmentMap.put(absoluteSom, targetAreaAssignment);
        if (CollectionUtils.isNotEmpty((Collection)targetAreaAssignment.getContainerLayoutAssignmentList())) {
            ContainerLayoutAssignment containerLayoutAssignment = (ContainerLayoutAssignment)targetAreaAssignment.getContainerLayoutAssignmentList().get(0);
            this.containerLayoutAssignmentMap.put(absoluteSom, containerLayoutAssignment);
            String oldContainerSom = this.currentContainerSOM;
            this.currentContainerSOM = absoluteSom;
            this.traverse(containerLayoutAssignment);
            this.currentContainerSOM = oldContainerSom;
        }
    }

    private void traverse(ContainerLayoutAssignment containerLayoutAssignment) {
        this.traverseFieldAssignments(containerLayoutAssignment.getFieldAssignments());
        this.traverseTargetAreaAssignments(containerLayoutAssignment.getTargetAreaAssignments());
    }

    private void transform(Form form) {
        this.currentNode = this.rootNode = new LetterModelTreeNode(null, this.unique(this.letter.getName()), "name", this.letter.getName(), "jcr:title", this.letter.getName(), "sling:resourceType", "fd/af/components/panel", "guideNodeClass", "guidePanel");
        this.transformFields(form.getFields());
        this.transformTargetAreas(form.getTargetAreas());
        this.transformTables(form.getTables());
        this.endChild();
    }

    private void transformFields(Set<Field> fields) {
        if (CollectionUtils.isNotEmpty(fields)) {
            for (Field field : fields) {
                this.transform(field);
            }
        }
    }

    private void transformTargetAreas(Set<TargetArea> targetAreas) {
        if (CollectionUtils.isNotEmpty(targetAreas)) {
            for (TargetArea targetArea : targetAreas) {
                this.transform(targetArea);
            }
        }
    }

    private void transformTables(Set<Table> tables) {
        if (CollectionUtils.isNotEmpty(tables)) {
            for (Table table : tables) {
                this.transform(table);
            }
        }
    }

    private void transform(Table table) {
        ArrayList<Float> colWidth = new ArrayList<Float>();
        boolean isWidthSpecified = false;
        if (table.getAdditionalTableColumns() != null) {
            List tcdList = table.getAdditionalTableColumns();
            for (TableColumnDetails tcd : tcdList) {
                if (tcd.getColumnWidth() > 0.0f) {
                    isWidthSpecified = true;
                }
                colWidth.add(Float.valueOf(tcd.getColumnWidth()));
            }
        }
        this.newChild(this.unique(table.getTableName()), "name", table.getTableName(), "jcr:title", table.getTableName(), "sling:resourceType", "fd/af/components/table", "guideNodeClass", "guideTable", "bindRef", table.getId());
        if (isWidthSpecified) {
            this.addProp("columnWidth", StringUtils.join(colWidth, (String)","));
        }
        this.addLayoutProp("sling:resourceType", "fd/af/layouts/tableLayout");
        this.addLayoutProp("mobileLayout", "headersLeft");
        if (table.getHeaderRow() != null && table.isShowHeaderRow()) {
            this.transform(table.getHeaderRow(), true, false, table);
        }
        if (CollectionUtils.isNotEmpty((Collection)table.getBodyRows())) {
            for (TableRow tableRow : table.getBodyRows()) {
                this.transform(tableRow, false, false, table);
            }
        }
        if (table.getFooterRow() != null && table.isShowFooterRow()) {
            this.transform(table.getFooterRow(), false, true, table);
        }
        this.endChild();
    }

    private void transformTableCells(Object[] cells, boolean isHeader, boolean isFooter) {
        int lastOrder = -1;
        for (int i = 0; i < cells.length; ++i) {
            Object cell = cells[i];
            if (cell instanceof Field) {
                this.transform((Field)cell);
                if (this.getLastAddedChildNode() == null) continue;
                lastOrder = this.getLastAddedChildNode().getOrder();
                continue;
            }
            if (cell instanceof TargetArea) {
                this.transform((TargetArea)cell);
                if (this.getLastAddedChildNode() == null) continue;
                lastOrder = this.getLastAddedChildNode().getOrder();
                continue;
            }
            if (cell instanceof TableColumnDetails) {
                TableColumnDetails columnDetails = (TableColumnDetails)cell;
                String id = this.getLastPart(columnDetails.getId());
                String nameString = isHeader ? columnDetails.getHeaderName() : (isFooter ? columnDetails.getFooterName() : null);
                nameString = nameString != null ? nameString : id;
                this.newChild(this.unique(id), "name", id, "jcr:title", nameString, "sling:resourceType", "fd/af/components/guidetextdraw", "guideNodeClass", "guideTextDraw", "bindRef", columnDetails.getId(), "_value", nameString);
                if (lastOrder > -1) {
                    this.currentNode.setOrder(lastOrder + 1);
                    lastOrder = this.currentNode.getOrder();
                }
                this.endChild();
                continue;
            }
            log.error("transformTableCells: Unknown cell type: " + cell);
        }
    }

    private Object[] getTableCells(TableRow tableRow, List<TableColumnDetails> columnDetailsList) {
        log.debug("getTableCells: columnDetailsListSize: " + columnDetailsList.size());
        Object[] cells = columnDetailsList.toArray();
        if (tableRow.getFields() != null) {
            for (Field field : tableRow.getFields()) {
                if (field.getPosition() >= cells.length) continue;
                cells[field.getPosition().intValue()] = field;
            }
        }
        if (tableRow.getTargetAreas() != null) {
            for (TargetArea ta : tableRow.getTargetAreas()) {
                if (ta.getPosition() >= cells.length) continue;
                cells[ta.getPosition().intValue()] = ta;
            }
        }
        return cells;
    }

    private String getLastPart(String id) {
        if (id != null && id.indexOf("/") > -1) {
            id = StringUtils.substringAfterLast((String)id, (String)"/");
        }
        return id;
    }

    private void transform(TableRow tableRow, boolean isHeader, boolean isFooter, Table table) {
        LetterModelTreeNode lastRowAdded = this.getLastAddedChildNode();
        String[] arrstring = new String[10];
        arrstring[0] = "name";
        arrstring[1] = tableRow.getName();
        arrstring[2] = "jcr:title";
        arrstring[3] = tableRow.getName();
        arrstring[4] = "sling:resourceType";
        arrstring[5] = isHeader ? "fd/af/components/tableHeader" : "fd/af/components/tableRow";
        arrstring[6] = "guideNodeClass";
        arrstring[7] = "guideTableRow";
        arrstring[8] = "bindRef";
        arrstring[9] = tableRow.getId();
        this.newChild(this.unique(tableRow.getName()), arrstring);
        if (table.isDynamicTable()) {
            this.addProp("maxOccur", -1);
        }
        this.addLayoutProp("sling:resourceType", isHeader ? "fd/af/layouts/table/headerLayout" : "fd/af/layouts/table/rowLayout");
        Object[] cells = this.getTableCells(tableRow, table.getAdditionalTableColumns());
        this.transformTableCells(cells, isHeader, isFooter);
        if (lastRowAdded != null && lastRowAdded.getOrder() > -1 && this.currentNode.getOrder() < 0) {
            this.currentNode.setOrder(lastRowAdded.getOrder() + 1);
        }
        this.endChild();
    }

    private Integer getMultipliedOrder(Integer order) {
        if (order != null) {
            order = 100 * order;
        }
        return order;
    }

    private void transform(TargetArea targetArea) {
        String absoluteSom = this.getAbsoluteSom(targetArea.getPath());
        Integer order = this.getMultipliedOrder(this.taFieldOrder.get(absoluteSom + ".ModuleContainer[0]"));
        TargetAreaAssignment targetAreaAssignment = this.targetAreaAssignmentMap.get(absoluteSom);
        ContainerLayoutAssignment containerLayoutAssignment = this.containerLayoutAssignmentMap.get(absoluteSom);
        boolean hasFragment = containerLayoutAssignment != null && containerLayoutAssignment.getContainerLayout() != null;
        String name = targetArea.getId().substring(targetArea.getId().lastIndexOf("/") + 1);
        String[] arrstring = new String[10];
        arrstring[0] = "name";
        arrstring[1] = name;
        arrstring[2] = "jcr:title";
        arrstring[3] = targetArea.getDisplayName();
        arrstring[4] = "sling:resourceType";
        arrstring[5] = hasFragment ? "fd/af/components/panel" : "fd/adaddon/components/guideAdModuleGroup";
        arrstring[6] = "guideNodeClass";
        arrstring[7] = hasFragment ? "guidePanel" : "guideAdModuleGroup";
        arrstring[8] = "assetRef";
        arrstring[9] = "TAA_ID:" + targetAreaAssignment.getId();
        this.newChild(this.unique(name), arrstring);
        this.currentNode.setOrder(order);
        if (hasFragment) {
            String oldContainerSOM = this.currentContainerSOM;
            this.currentContainerSOM = absoluteSom;
            this.traverse(containerLayoutAssignment.getContainerLayout());
            this.currentContainerSOM = oldContainerSOM;
        }
        this.endChild();
    }

    private void traverse(ContainerLayout containerLayout) {
        this.transformFields(containerLayout.getFields());
        this.transformTargetAreas(containerLayout.getTargetAreas());
        this.transformTables(containerLayout.getTables());
    }

    private void transform(Field field) {
        String absoluteSom = this.getAbsoluteSom(field.getPath());
        FieldAssignment fieldAssignment = this.fieldAssignmentMap.get(this.getAbsoluteSom(field.getPath()));
        Integer order = this.getMultipliedOrder(this.taFieldOrder.get(absoluteSom));
        String[] guideTypes = this.getGuideTypes(field);
        String name = field.getId().substring(field.getId().lastIndexOf("/") + 1);
        String title = field.getCaption() != null ? field.getCaption() : GuideUtils.humanize((String)field.getDisplayName());
        this.newChild(this.unique(name), "name", name, "jcr:title", title, "sling:resourceType", guideTypes[0], "guideNodeClass", guideTypes[1], "bindRef", "FA_ID:" + fieldAssignment.getId());
        boolean isRadioButton = "fd/af/components/guideradiobutton".equals(guideTypes[0]);
        boolean isDropDown = "fd/af/components/guidedropdownlist".equals(guideTypes[0]);
        boolean isCheckBox = "fd/af/components/guidecheckbox".equals(guideTypes[0]);
        if (isRadioButton || isDropDown || isCheckBox) {
            this.addProp("options", this.getFieldOptions(field, isCheckBox));
        }
        this.addProp("enabledExp", "false");
        this.currentNode.setOrder(order);
        this.endChild();
    }

    private String[] getFieldOptions(Field field, boolean isCheckBox) {
        List values = field.getValues();
        List labels = field.getLabels();
        if (values == null || values.size() < 1) {
            return new String[]{""};
        }
        if (isCheckBox) {
            return new String[]{(String)values.get(0) + "=" + field.getCaption()};
        }
        int labelsSize = labels != null ? labels.size() : 0;
        int valuesSize = values != null ? values.size() : 0;
        String[] options = new String[valuesSize];
        for (int i = 0; i < valuesSize; ++i) {
            String label = i < labelsSize ? (String)labels.get(i) : "";
            options[i] = (String)values.get(i) + "=" + label;
        }
        return options;
    }

    private String[] getGuideTypes(Field field) {
        String xfaFieldType = field.getXfaFieldType();
        log.debug("getGuideTypes:xfaFieldType for  {} is {} ", (Object)field.getId(), (Object)xfaFieldType);
        if (StringUtils.isNotBlank((CharSequence)xfaFieldType)) {
            if ("exclGroup".equals(xfaFieldType)) {
                return new String[]{"fd/af/components/guideradiobutton", "guideRadioButton"};
            }
            if ("checkButton".equals(xfaFieldType)) {
                return new String[]{"fd/af/components/guidecheckbox", "guideCheckBox"};
            }
            if ("choiceList".equals(xfaFieldType)) {
                return new String[]{"fd/af/components/guidedropdownlist", "guideDropDownList"};
            }
        }
        switch (field.getType()) {
            case DATE: 
            case DATETIME: 
            case TIME: {
                return new String[]{"fd/af/components/guidedatepicker", "guideDatePicker"};
            }
            case PLAINTEXT: 
            case RICHTEXT: {
                return new String[]{"fd/af/components/guidetextbox", "guideTextBox"};
            }
            case INTEGER: 
            case FLOAT: {
                return new String[]{"fd/af/components/guidenumericbox", "guideNumericBox"};
            }
            case IMAGE: {
                return new String[]{"fd/af/components/guideimage", "guideImage"};
            }
            case CHECKBOX: {
                return new String[]{"fd/af/components/guidecheckbox", "guideCheckBox"};
            }
            case RADIOBUTTON: {
                return new String[]{"fd/af/components/guideradiobutton", "guideRadioButton"};
            }
        }
        throw new RuntimeException("Unknown type " + (Object)field.getType());
    }

    private void addProp(String key, Object val) {
        this.currentNode.addProp(key, val);
    }

    private void addLayoutProp(String key, Object value) {
        this.currentNode.addLayoutProp(key, value);
    }

    private /* varargs */ void newChild(String key, String ... keyVal) {
        log.debug("newChild : " + key);
        this.currentNode = this.currentNode.addChild(new LetterModelTreeNode(this.currentNode, key, keyVal));
    }

    private void endChild() {
        log.debug("endChild currentNode: " + (this.currentNode != null ? this.currentNode.getKey() : null));
        this.currentNode = this.currentNode.getParent();
    }

    private LetterModelTreeNode getLastAddedChildNode() {
        LetterModelTreeNode lastAddedChild = null;
        if (this.currentNode != null && this.currentNode.getNumChildren() > 0) {
            int num = this.currentNode.getNumChildren();
            lastAddedChild = this.currentNode.getChild(num - 1);
        }
        return lastAddedChild;
    }

    private String unique(String prefix) {
        return prefix + "_" + this.timestamp + "_" + this.uniqCounter++;
    }

    private String getAbsoluteSom(String elementSom) {
        if (StringUtils.isNotBlank((CharSequence)this.currentContainerSOM)) {
            elementSom = ADUtils.computeAbsoluteSOM(this.currentContainerSOM, elementSom);
        }
        return elementSom;
    }

    private static class LetterModelTreeNode
    implements Comparable<LetterModelTreeNode> {
        private final LetterModelTreeNode parent;
        private final HashMap<String, Object> props = new HashMap();
        private final List<LetterModelTreeNode> children = new ArrayList<LetterModelTreeNode>();
        private int order = -1;
        private String key;
        private Map<String, Object> layout = new HashMap<String, Object>();

        public /* varargs */ LetterModelTreeNode(LetterModelTreeNode parent, String key, String ... keyVal) {
            this.parent = parent;
            this.key = key;
            int evenLen = 2 * (keyVal.length / 2);
            for (int i = 0; i < evenLen; i += 2) {
                this.addProp(keyVal[i], keyVal[i + 1]);
            }
            if (evenLen < keyVal.length) {
                this.addProp(keyVal[keyVal.length - 1], null);
            }
            this.addProp("jcr:primaryType", "nt:unstructured");
        }

        public void bubbleScore() {
            if (this.parent != null && this.parent.getOrder() < 0) {
                this.parent.setOrder(this.order);
            }
        }

        public void addProp(String key, Object value) {
            this.props.put(key, value);
        }

        public void setOrder(Integer order) {
            log.debug("setOrder: " + this.key + " : " + order);
            if (order != null) {
                this.order = order;
                this.bubbleScore();
            }
        }

        public int getOrder() {
            return this.order;
        }

        public LetterModelTreeNode getParent() {
            return this.parent;
        }

        public String getKey() {
            return this.key;
        }

        public void toJSON(CustomJSONWriter jsonWriter) {
            jsonWriter.key(this.key).object();
            for (Map.Entry<String, Object> me2 : this.props.entrySet()) {
                Object value = me2.getValue();
                if (value != null && value.getClass().isArray()) {
                    Object[] vals;
                    jsonWriter.key(me2.getKey()).array();
                    for (Object val : vals = (Object[])value) {
                        jsonWriter.value(val);
                    }
                    jsonWriter.endArray();
                    continue;
                }
                jsonWriter.key(me2.getKey()).value(me2.getValue());
            }
            if (this.getLayout() != null && this.getLayout().entrySet().size() > 0) {
                jsonWriter.key("layout").object();
                jsonWriter.key("jcr:primaryType").value((Object)"nt:unstructured");
                for (Map.Entry me : this.getLayout().entrySet()) {
                    jsonWriter.key((String)me.getKey()).value(me.getValue());
                }
                jsonWriter.endObject();
            }
            if (this.children.size() > 0) {
                jsonWriter.key("items").object();
                for (LetterModelTreeNode node : this.children) {
                    node.toJSON(jsonWriter);
                }
                jsonWriter.endObject();
            }
            jsonWriter.endObject();
        }

        @Override
        public int compareTo(LetterModelTreeNode o) {
            return this.order - o.getOrder();
        }

        public void sort() {
            Collections.sort(this.children);
            for (LetterModelTreeNode node : this.children) {
                node.sort();
            }
        }

        public LetterModelTreeNode addChild(LetterModelTreeNode node) {
            this.children.add(node);
            return node;
        }

        public void addLayoutProp(String key, Object value) {
            this.layout.put(key, value);
        }

        public Object getLayoutProp(String key) {
            return this.layout.get(key);
        }

        public void setLayout(Map<String, Object> map) {
            this.layout = map;
        }

        public Map<String, Object> getLayout() {
            return this.layout;
        }

        public LetterModelTreeNode getChild(int pos) {
            if (pos < this.children.size()) {
                return this.children.get(pos);
            }
            return null;
        }

        public int getNumChildren() {
            return this.children.size();
        }
    }

}