TextFormatter.java

/*
 * Copyright (c) 2010-2013 Evolveum
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.evolveum.midpoint.notifications.impl.formatters;

import com.evolveum.midpoint.notifications.impl.NotificationsUtil;
import com.evolveum.midpoint.prism.*;
import com.evolveum.midpoint.prism.delta.ItemDelta;
import com.evolveum.midpoint.prism.delta.ObjectDelta;
import com.evolveum.midpoint.prism.path.IdItemPathSegment;
import com.evolveum.midpoint.prism.path.ItemPath;
import com.evolveum.midpoint.prism.path.ItemPathSegment;
import com.evolveum.midpoint.prism.path.NameItemPathSegment;
import com.evolveum.midpoint.prism.polystring.PolyString;
import com.evolveum.midpoint.repo.api.RepositoryService;
import com.evolveum.midpoint.schema.result.OperationResult;
import com.evolveum.midpoint.schema.util.ValueDisplayUtil;
import com.evolveum.midpoint.util.PrettyPrinter;
import com.evolveum.midpoint.util.exception.ObjectNotFoundException;
import com.evolveum.midpoint.util.exception.SchemaException;
import com.evolveum.midpoint.util.logging.LoggingUtils;
import com.evolveum.midpoint.util.logging.Trace;
import com.evolveum.midpoint.util.logging.TraceManager;
import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowAssociationType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType;

import org.apache.commons.lang.Validate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import javax.xml.namespace.QName;

import java.util.*;

/**
 * @author mederly
 */
@Component
public class TextFormatter {

    @Autowired(required = true)
    @Qualifier("cacheRepositoryService")
    private transient RepositoryService cacheRepositoryService;

    private static final Trace LOGGER = TraceManager.getTrace(TextFormatter.class);

    public String formatObjectModificationDelta(ObjectDelta<? extends Objectable> objectDelta, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        return formatObjectModificationDelta(objectDelta, hiddenPaths, showOperationalAttributes, null, null);
    }

    // objectOld and objectNew are used for explaining changed container values, e.g. assignment[1]/tenantRef (see MID-2047)
    // if null, they are ignored
    public String formatObjectModificationDelta(ObjectDelta<? extends Objectable> objectDelta, List<ItemPath> hiddenPaths, boolean showOperationalAttributes,
                                                PrismObject objectOld, PrismObject objectNew) {
        Validate.notNull(objectDelta, "objectDelta is null");
        Validate.isTrue(objectDelta.isModify(), "objectDelta is not a modification delta");

        PrismObjectDefinition objectDefinition;
        if (objectNew != null && objectNew.getDefinition() != null) {
            objectDefinition = objectNew.getDefinition();
        } else if (objectOld != null && objectOld.getDefinition() != null) {
            objectDefinition = objectOld.getDefinition();
        } else {
            objectDefinition = null;
        }

        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("formatObjectModificationDelta: objectDelta = " + objectDelta.debugDump() + ", hiddenPaths = " + PrettyPrinter.prettyPrint(hiddenPaths));
        }

        StringBuilder retval = new StringBuilder();

        List<ItemDelta> toBeDisplayed = filterAndOrderItemDeltas(objectDelta, hiddenPaths, showOperationalAttributes);
        for (ItemDelta itemDelta : toBeDisplayed) {
            retval.append(" - ");
            retval.append(getItemDeltaLabel(itemDelta, objectDefinition));
            retval.append(":\n");
            formatItemDeltaContent(retval, itemDelta, hiddenPaths, showOperationalAttributes);
        }

        explainPaths(retval, toBeDisplayed, objectDefinition, objectOld, objectNew, hiddenPaths, showOperationalAttributes);

        return retval.toString();
    }

    private void explainPaths(StringBuilder sb, List<ItemDelta> deltas, PrismObjectDefinition objectDefinition, PrismObject objectOld, PrismObject objectNew, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        if (objectOld == null && objectNew == null) {
            return; // no data - no point in trying
        }
        boolean first = true;
        List<ItemPath> alreadyExplained = new ArrayList<>();
        for (ItemDelta itemDelta : deltas) {
            ItemPath pathToExplain = getPathToExplain(itemDelta);
            if (pathToExplain == null || ItemPath.containsSubpathOrEquivalent(alreadyExplained, pathToExplain)) {
                continue;       // null or already processed
            }
            PrismObject source = null;
            Object item = null;
            if (objectNew != null) {
                item = objectNew.find(pathToExplain);
                source = objectNew;
            }
            if (item == null && objectOld != null) {
                item = objectOld.find(pathToExplain);
                source = objectOld;
            }
            if (item == null) {
                LOGGER.warn("Couldn't find {} in {} nor {}, no explanation could be created.", new Object[] {pathToExplain, objectNew, objectOld});
                continue;
            }
            if (first) {
                sb.append("\nNotes:\n");
                first = false;
            }
            String label = getItemPathLabel(pathToExplain, itemDelta.getDefinition(), objectDefinition);
            // the item should be a PrismContainerValue
            if (item instanceof PrismContainerValue) {
                sb.append(" - ").append(label).append(":\n");
                formatContainerValue(sb, "   ", (PrismContainerValue) item, false, hiddenPaths, showOperationalAttributes);
            } else {
                LOGGER.warn("{} in {} was expected to be a PrismContainerValue; it is {} instead", new Object[]{pathToExplain, source, item.getClass()});
                if (item instanceof PrismContainer) {
                    formatPrismContainer(sb, "   ", (PrismContainer) item, false, hiddenPaths, showOperationalAttributes);
                } else if (item instanceof PrismReference) {
                    formatPrismReference(sb, "   ", (PrismReference) item, false);
                } else if (item instanceof PrismProperty) {
                    formatPrismProperty(sb, "   ", (PrismProperty) item);
                } else {
                    sb.append("Unexpected item: ").append(item).append("\n");
                }
            }
            alreadyExplained.add(pathToExplain);
        }
    }

    private void formatItemDeltaContent(StringBuilder sb, ItemDelta itemDelta, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        formatItemDeltaValues(sb, "ADD", itemDelta.getValuesToAdd(), false, hiddenPaths, showOperationalAttributes);
        formatItemDeltaValues(sb, "DELETE", itemDelta.getValuesToDelete(), true, hiddenPaths, showOperationalAttributes);
        formatItemDeltaValues(sb, "REPLACE", itemDelta.getValuesToReplace(), false, hiddenPaths, showOperationalAttributes);
    }

    private void formatItemDeltaValues(StringBuilder sb, String type, Collection<? extends PrismValue> values, boolean mightBeRemoved, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        if (values != null) {
            for (PrismValue prismValue : values) {
                sb.append("   - " + type + ": ");
                String prefix = "     ";
                formatPrismValue(sb, prefix, prismValue, mightBeRemoved, hiddenPaths, showOperationalAttributes);
                if (!(prismValue instanceof PrismContainerValue)) {         // container values already end with newline
                    sb.append("\n");
                }
            }
        }
    }

    // todo - should each hiddenAttribute be prefixed with something like F_ATTRIBUTE? Currently it should not be.
    public String formatAccountAttributes(ShadowType shadowType, List<ItemPath> hiddenAttributes, boolean showOperationalAttributes) {
        Validate.notNull(shadowType, "shadowType is null");

        StringBuilder retval = new StringBuilder();
        if (shadowType.getAttributes() != null) {
            formatContainerValue(retval, "", shadowType.getAttributes().asPrismContainerValue(), false, hiddenAttributes, showOperationalAttributes);
        }
        if (shadowType.getAssociation() != null) {
            for (ShadowAssociationType shadowAssociationType : shadowType.getAssociation()) {
                formatContainerValue(retval, "", shadowAssociationType.asPrismContainerValue(), false, hiddenAttributes, showOperationalAttributes);
            }
        }
        if (shadowType.getCredentials() != null) {
            formatContainerValue(retval, "", shadowType.getCredentials().asPrismContainerValue(), false, hiddenAttributes, showOperationalAttributes);
        }
        if (shadowType.getActivation() != null) {
            formatContainerValue(retval, "", shadowType.getActivation().asPrismContainerValue(), false, hiddenAttributes, showOperationalAttributes);
        }
        return retval.toString();
    }

    public String formatObject(PrismObject object, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {

        Validate.notNull(object, "object is null");

        StringBuilder retval = new StringBuilder();
        formatContainerValue(retval, "", object.getValue(), false, hiddenPaths, showOperationalAttributes);
        return retval.toString();
    }

    private void formatPrismValue(StringBuilder sb, String prefix, PrismValue prismValue, boolean mightBeRemoved, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        if (prismValue instanceof PrismPropertyValue) {
            sb.append(ValueDisplayUtil.toStringValue((PrismPropertyValue) prismValue));
        } else if (prismValue instanceof PrismReferenceValue) {
            sb.append(formatReferenceValue((PrismReferenceValue) prismValue, mightBeRemoved));
        } else if (prismValue instanceof PrismContainerValue) {
            sb.append("\n");
            formatContainerValue(sb, prefix, (PrismContainerValue) prismValue, mightBeRemoved, hiddenPaths, showOperationalAttributes);
        } else {
            sb.append("Unexpected PrismValue type: ");
            sb.append(prismValue);
            LOGGER.error("Unexpected PrismValue type: " + prismValue.getClass() + ": " + prismValue);
        }
    }

    private void formatContainerValue(StringBuilder sb, String prefix, PrismContainerValue containerValue, boolean mightBeRemoved, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
//        sb.append("Container of type " + containerValue.getParent().getDefinition().getTypeName());
//        sb.append("\n");

        List<Item> toBeDisplayed = filterAndOrderItems(containerValue.getItems(), hiddenPaths, showOperationalAttributes);

        for (Item item : toBeDisplayed) {
            if (item instanceof PrismProperty) {
                formatPrismProperty(sb, prefix, item);
            } else if (item instanceof PrismReference) {
                formatPrismReference(sb, prefix, item, mightBeRemoved);
            } else if (item instanceof PrismContainer) {
                formatPrismContainer(sb, prefix, item, mightBeRemoved, hiddenPaths, showOperationalAttributes);
            } else {
                sb.append("Unexpected Item type: ");
                sb.append(item);
                sb.append("\n");
                LOGGER.error("Unexpected Item type: " + item.getClass() + ": " + item);
            }
        }
    }

    private void formatPrismContainer(StringBuilder sb, String prefix, Item item, boolean mightBeRemoved, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        for (PrismContainerValue subContainerValue : ((PrismContainer<? extends Containerable>) item).getValues()) {
            sb.append(prefix);
            sb.append(" - ");
            sb.append(getItemLabel(item));
            if (subContainerValue.getId() != null) {
                sb.append(" #").append(subContainerValue.getId());
            }
            sb.append(":\n");
            String prefixSubContainer = prefix + "   ";
            formatContainerValue(sb, prefixSubContainer, subContainerValue, mightBeRemoved, hiddenPaths, showOperationalAttributes);
        }
    }

    private void formatPrismReference(StringBuilder sb, String prefix, Item item, boolean mightBeRemoved) {
        sb.append(prefix);
        sb.append(" - ");
        sb.append(getItemLabel(item));
        sb.append(": ");
        if (item.size() > 1) {
            for (PrismReferenceValue referenceValue : ((PrismReference) item).getValues()) {
                sb.append("\n");
                sb.append(prefix + "   - ");
                sb.append(formatReferenceValue(referenceValue, mightBeRemoved));
            }
        } else if (item.size() == 1) {
            sb.append(formatReferenceValue(((PrismReference) item).getValue(0), mightBeRemoved));
        }
        sb.append("\n");
    }

    private void formatPrismProperty(StringBuilder sb, String prefix, Item item) {
        sb.append(prefix);
        sb.append(" - ");
        sb.append(getItemLabel(item));
        sb.append(": ");
        if (item.size() > 1) {
            for (PrismPropertyValue propertyValue : ((PrismProperty<? extends Object>) item).getValues()) {
                sb.append("\n");
                sb.append(prefix + "   - ");
                sb.append(ValueDisplayUtil.toStringValue(propertyValue));
            }
        } else if (item.size() == 1) {
            sb.append(ValueDisplayUtil.toStringValue(((PrismProperty<? extends Object>) item).getValue(0)));
        }
        sb.append("\n");
    }

    private String formatReferenceValue(PrismReferenceValue value, boolean mightBeRemoved) {

        OperationResult result = new OperationResult("dummy");

        PrismObject<? extends ObjectType> object = value.getObject();

        if (object == null) {
            object = getPrismObject(value.getOid(), mightBeRemoved, result);
        }

        String qualifier = "";
        if (object != null && object.asObjectable() instanceof ShadowType) {
            ShadowType shadowType = (ShadowType) object.asObjectable();
            ResourceType resourceType = shadowType.getResource();
            if (resourceType == null) {
                PrismObject<? extends ObjectType> resource = getPrismObject(shadowType.getResourceRef().getOid(), false, result);
                if (resource != null) {
                    resourceType = (ResourceType) resource.asObjectable();
                }
            }
            if (resourceType != null) {
                qualifier = " on " + resourceType.getName();
            } else {
                qualifier = " on resource " + shadowType.getResourceRef().getOid();
            }
        }

        if (object != null) {
            return PolyString.getOrig(object.asObjectable().getName()) +
                    " (" + object.toDebugType() + ")" +
                    qualifier;
        } else {
            if (mightBeRemoved) {
                return "(cannot display the name of " + localPart(value.getTargetType()) + ":" + value.getOid() + ", as it might be already removed)";
            } else {
                return localPart(value.getTargetType()) + ":" + value.getOid();
            }
        }
    }

    private PrismObject<? extends ObjectType> getPrismObject(String oid, boolean mightBeRemoved, OperationResult result) {
        try {
            return cacheRepositoryService.getObject(ObjectType.class, oid, null, result);
        } catch (ObjectNotFoundException e) {
            if (!mightBeRemoved) {
                LoggingUtils.logException(LOGGER, "Couldn't resolve reference when displaying object name within a notification (it might be already removed)", e);
            } else {
            }
        } catch (SchemaException e) {
            LoggingUtils.logException(LOGGER, "Couldn't resolve reference when displaying object name within a notification", e);
        }
        return null;
    }

    private String localPartOfType(Item item) {
        if (item.getDefinition() != null) {
            return localPart(item.getDefinition().getTypeName());
        } else {
            return null;
        }
    }

    private String localPart(QName qname) {
        return qname == null ? null : qname.getLocalPart();
    }

    // we call this on filtered list of item deltas - all of they have definition set
    private String getItemDeltaLabel(ItemDelta itemDelta, PrismObjectDefinition objectDefinition) {
        return getItemPathLabel(itemDelta.getPath(), itemDelta.getDefinition(), objectDefinition);
    }

    private String getItemPathLabel(ItemPath path, Definition deltaDefinition, PrismObjectDefinition objectDefinition) {

        NameItemPathSegment lastNamedSegment = path.lastNamed();

        StringBuilder sb = new StringBuilder();
        for (ItemPathSegment segment : path.getSegments()) {
            if (segment instanceof NameItemPathSegment) {
                if (sb.length() > 0) {
                    sb.append("/");
                }
                Definition itemDefinition;
                if (objectDefinition == null) {
                    if (segment == lastNamedSegment) {  // definition for last segment is the definition taken from delta
                        itemDefinition = deltaDefinition;    // this may be null but we don't care
                    } else {
                        itemDefinition = null;          // definitions for previous segments are unknown
                    }
                } else {
                    // todo we could make this iterative (resolving definitions while walking down the path); but this is definitely simpler to implement and debug :)
                    itemDefinition = objectDefinition.findItemDefinition(path.allUpToIncluding(segment));
                }
                if (itemDefinition != null && itemDefinition.getDisplayName() != null) {
                    sb.append(itemDefinition.getDisplayName());
                } else {
                    sb.append(((NameItemPathSegment) segment).getName().getLocalPart());
                }
            } else if (segment instanceof IdItemPathSegment) {
                sb.append("[").append(((IdItemPathSegment) segment).getId()).append("]");
            }
        }
        return sb.toString();
    }

    // we call this on filtered list of item deltas - all of they have definition set
    private ItemPath getPathToExplain(ItemDelta itemDelta) {
        ItemPath path = itemDelta.getPath();

        for (int i = 0; i < path.size(); i++) {
            ItemPathSegment segment = path.getSegments().get(i);
            if (segment instanceof IdItemPathSegment) {
                if (i < path.size()-1 || itemDelta.isDelete()) {
                    return path.allUpToIncluding(i);
                } else {
                    // this means that the path ends with [id] segment *and* the value(s) are
                    // only added and deleted, i.e. they are shown in the delta anyway
                    // (actually it is questionable whether path in delta can end with [id] segment,
                    // but we test for this case just to be sure)
                    return null;
                }
            }
        }
        return null;
    }

    private List<ItemDelta> filterAndOrderItemDeltas(ObjectDelta<? extends Objectable> objectDelta, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        List<ItemDelta> toBeDisplayed = new ArrayList<ItemDelta>(objectDelta.getModifications().size());
        for (ItemDelta itemDelta: objectDelta.getModifications()) {
            if (itemDelta.getDefinition() != null) {
                if ((showOperationalAttributes || !itemDelta.getDefinition().isOperational()) && !NotificationsUtil.isAmongHiddenPaths(itemDelta.getPath(), hiddenPaths)) {
                    toBeDisplayed.add(itemDelta);
                }
            } else {
                LOGGER.error("ItemDelta " + itemDelta.getElementName() + " without definition - WILL NOT BE INCLUDED IN NOTIFICATION. In " + objectDelta);
            }
        }
        Collections.sort(toBeDisplayed, new Comparator<ItemDelta>() {
            @Override
            public int compare(ItemDelta delta1, ItemDelta delta2) {
                Integer order1 = delta1.getDefinition().getDisplayOrder();
                Integer order2 = delta2.getDefinition().getDisplayOrder();
                if (order1 != null && order2 != null) {
                    return order1 - order2;
                } else if (order1 == null && order2 == null) {
                    return 0;
                } else if (order1 == null) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });
        return toBeDisplayed;
    }

    // we call this on filtered list of items - all of them have definition set
    private String getItemLabel(Item item) {
        return item.getDefinition().getDisplayName() != null ?
                item.getDefinition().getDisplayName() : item.getElementName().getLocalPart();
    }

    private List<Item> filterAndOrderItems(List<Item> items, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) {
        List<Item> toBeDisplayed = new ArrayList<Item>(items.size());
        for (Item item : items) {
            if (item.getDefinition() != null) {
                boolean isHidden = NotificationsUtil.isAmongHiddenPaths(item.getPath(), hiddenPaths);
                if (!isHidden && (showOperationalAttributes || !item.getDefinition().isOperational())) {
                    toBeDisplayed.add(item);
                }
            } else {
                LOGGER.error("Item " + item.getElementName() + " without definition - WILL NOT BE INCLUDED IN NOTIFICATION.");
            }
        }
        Collections.sort(toBeDisplayed, new Comparator<Item>() {
            @Override
            public int compare(Item item1, Item item2) {
                Integer order1 = item1.getDefinition().getDisplayOrder();
                Integer order2 = item2.getDefinition().getDisplayOrder();
                if (order1 != null && order2 != null) {
                    return order1 - order2;
                } else if (order1 == null && order2 == null) {
                    return 0;
                } else if (order1 == null) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });
        return toBeDisplayed;
    }


}