Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.cq.dam.api.Asset
 *  com.day.cq.dam.api.s7dam.set.SwatchSet
 *  com.day.cq.dam.commons.util.DamUtil
 *  com.day.cq.search.PredicateGroup
 *  com.day.cq.search.Query
 *  com.day.cq.search.QueryBuilder
 *  com.day.cq.search.result.SearchResult
 *  javax.jcr.Node
 *  javax.jcr.Property
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  org.apache.commons.lang.StringUtils
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.sling.api.resource.LoginException
 *  org.apache.sling.api.resource.ModifiableValueMap
 *  org.apache.sling.api.resource.NonExistingResource
 *  org.apache.sling.api.resource.PersistenceException
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ResourceResolverFactory
 *  org.apache.sling.api.resource.ResourceUtil
 *  org.apache.sling.api.resource.ValueMap
 *  org.apache.sling.event.jobs.Job
 *  org.apache.sling.event.jobs.consumer.JobConsumer
 *  org.apache.sling.event.jobs.consumer.JobConsumer$JobResult
 *  org.apache.sling.resource.collection.ResourceCollection
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.dam.core.impl;

import com.day.cq.dam.api.Asset;
import com.day.cq.dam.api.s7dam.set.SwatchSet;
import com.day.cq.dam.commons.util.DamUtil;
import com.day.cq.dam.core.impl.ui.preview.FolderPreviewUpdater;
import com.day.cq.search.PredicateGroup;
import com.day.cq.search.Query;
import com.day.cq.search.QueryBuilder;
import com.day.cq.search.result.SearchResult;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.apache.commons.lang.StringUtils;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.ModifiableValueMap;
import org.apache.sling.api.resource.NonExistingResource;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.event.jobs.Job;
import org.apache.sling.event.jobs.consumer.JobConsumer;
import org.apache.sling.resource.collection.ResourceCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(metatype=1, immediate=1)
@Service(value={JobConsumer.class})
@Property(name="job.topics", value={"com/adobe/cq/dam/assetmove"})
public class AssetMoveEventHandler
implements JobConsumer {
    private static final Logger logger = LoggerFactory.getLogger(AssetMoveEventHandler.class);
    private static final String XMP_MANIFEST_PATH = "jcr:content/metadata/xmpMM:Manifest";
    private static final String FILE_REFERENCE_PATH = "stMfs:reference";
    private static final String REF_FILE_PATH = "stRef:filePath";
    private static final String DAM_ORIG_PATH = "dam:originalPath";
    private static final String DAM_RES_PATH = "dam:resolvedPath";
    private static final String DAM_ASSET_RELATIVE_PATH = "dam:relativePath";
    private static final String CONTENT_DAM = "/content/dam";
    private static final String SUBSERVICE = "assetmove";
    private static final Map<String, Object> AUTH_INFO = Collections.singletonMap("sling.service.subservice", "assetmove");
    @Reference
    private ResourceResolverFactory resolverFactory;
    @Reference
    private QueryBuilder queryBuilder;
    @Reference
    private FolderPreviewUpdater folderPreviewUpdater;

    private void updateFolderThumbnail(ResourceResolver resolver, String path, String eventType, String assetNewPath) {
        NonExistingResource assetResource = new NonExistingResource(resolver, path);
        Resource parentFolderResource = assetResource.getParent();
        if (parentFolderResource == null) {
            return;
        }
        Node parentFolderNode = (Node)parentFolderResource.adaptTo(Node.class);
        if (parentFolderNode == null) {
            return;
        }
        boolean success = this.folderPreviewUpdater.initiateFolderPreviewUpdate(path);
        if (!success) {
            logger.error("Folder thumbnail update couldn't be initiated for ", (Object)path);
        }
        if (eventType.equals("move") && !(success = this.folderPreviewUpdater.initiateFolderPreviewUpdate(assetNewPath))) {
            logger.error("Folder thumbnail update couldn't be initiated for ", (Object)assetNewPath);
        }
    }

    private String getTenantHomeForDeletedResource(ResourceResolver resolver, String path) {
        NonExistingResource nonExistingResource = new NonExistingResource(resolver, path);
        return DamUtil.getTenantAssetsRoot((Resource)nonExistingResource);
    }

    private void updateAssetPath(ResourceResolver resolver, Session session, String path, String eventType, String folderPath, String nodeType) throws PersistenceException, RepositoryException {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("path", this.getTenantHomeForDeletedResource(resolver, path));
        map.put("property", "sling:resource");
        if (nodeType.equals("dam:Asset")) {
            map.put("property.value", path);
        } else {
            map.put("property.value", path + "%");
            map.put("property.operation", "like");
        }
        map.put("type", "nt:unstructured");
        map.put("p.limit", "0");
        Query query = this.queryBuilder.createQuery(PredicateGroup.create(map), session);
        SearchResult results = query.getResult();
        List<Resource> imagesetEntries = this.getSearchResultResources(results);
        for (Resource imagesetEntry : imagesetEntries) {
            ValueMap imagesetEntryProps;
            String assetOldPath;
            ResourceCollection collection = this.findCollection(imagesetEntry);
            if (collection == null || !(assetOldPath = (String)(imagesetEntryProps = ResourceUtil.getValueMap((Resource)imagesetEntry)).get("sling:resource", String.class)).equals(path) && assetOldPath.indexOf(path + "/") != 0) continue;
            NonExistingResource removedResource = new NonExistingResource(resolver, assetOldPath);
            Asset imagesetAsset = this.findAsset(imagesetEntry);
            if (eventType.equals("move")) {
                String assetNewPath = folderPath + assetOldPath.substring(path.length());
                this.updateReferences(collection, imagesetAsset, (Resource)removedResource, assetNewPath);
                Resource modified = resolver.getResource(assetNewPath);
                this.replace(resolver, collection, imagesetAsset, (Resource)removedResource, modified);
                continue;
            }
            collection.remove((Resource)removedResource);
            this.updateLastModified(resolver, collection, imagesetAsset);
        }
        session.save();
    }

    private List<Resource> getSearchResultResources(SearchResult results) {
        ArrayList<Resource> list = new ArrayList<Resource>((int)results.getTotalMatches());
        Iterator i = results.getResources();
        while (i.hasNext()) {
            Resource rr = (Resource)i.next();
            if (rr == null) continue;
            list.add(rr);
        }
        return list;
    }

    private boolean isDamAsset(ResourceResolver resolver, String folderPath) {
        Resource resource = resolver.getResource(folderPath);
        if (resource != null) {
            boolean isAsset = resource.adaptTo(Asset.class) != null;
            boolean hasRelatedPages = resource.getChild("jcr:content/related/pages") != null;
            return isAsset && !hasRelatedPages;
        }
        return false;
    }

    private void updateSwatchPath(ResourceResolver resolver, Session session, String path, String eventType, String assetNewPath) throws RepositoryException {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("path", this.getTenantHomeForDeletedResource(resolver, path));
        map.put("property", "dam:s7Swatch");
        map.put("property.value", path);
        map.put("type", "nt:unstructured");
        map.put("p.limit", "0");
        Query query = this.queryBuilder.createQuery(PredicateGroup.create(map), session);
        SearchResult results = query.getResult();
        List<Resource> imagesetEntries = this.getSearchResultResources(results);
        for (Resource imagesetEntry : imagesetEntries) {
            ModifiableValueMap vm = (ModifiableValueMap)imagesetEntry.adaptTo(ModifiableValueMap.class);
            String assetRef = (String)vm.get("sling:resource", (Object)"");
            if (StringUtils.isBlank((String)assetRef)) {
                logger.warn("swatch {} ref {} found, but asset Ref is missing ", (Object)path, (Object)imagesetEntry);
                continue;
            }
            Resource assetRefRes = resolver.getResource(assetRef);
            if (assetRefRes == null) {
                logger.warn("swatch {} ref {} found, but referenced asset is null", (Object)path, (Object)imagesetEntry);
                continue;
            }
            Asset refAsset = (Asset)assetRefRes.adaptTo(Asset.class);
            Asset imagesetAsset = this.findAsset(imagesetEntry);
            if (imagesetAsset == null) {
                logger.warn("swatch {} ref {} found, but parent asset missing ", (Object)path, (Object)imagesetEntry);
                continue;
            }
            SwatchSet imageset = (SwatchSet)((Resource)imagesetAsset.adaptTo(Resource.class)).adaptTo(SwatchSet.class);
            if (eventType.equals("move")) {
                Resource modified = resolver.getResource(assetNewPath);
                if (modified != null) {
                    imageset.setSwatch(refAsset, (Asset)modified.adaptTo(Asset.class));
                    continue;
                }
                imageset.setSwatch(refAsset, null);
                continue;
            }
            imageset.setSwatch(refAsset, null);
        }
        session.save();
    }

    private Asset findAsset(Resource assetRefResource) {
        return DamUtil.resolveToAsset((Resource)assetRefResource);
    }

    private ResourceCollection findCollection(Resource res) {
        if (res != null) {
            ResourceCollection rc = (ResourceCollection)res.adaptTo(ResourceCollection.class);
            if (rc != null) {
                return rc;
            }
            if (res.getParent() != null) {
                return this.findCollection(res.getParent());
            }
        }
        return null;
    }

    private void replace(ResourceResolver resolver, ResourceCollection collection, Asset imagesetAsset, Resource oldAsset, Resource newAsset) throws PersistenceException {
        if (!collection.contains(oldAsset)) {
            return;
        }
        HashMap props = new HashMap();
        ModifiableValueMap vm = collection.getProperties(oldAsset);
        if (vm != null) {
            props.putAll(vm);
        }
        if (collection.add(newAsset, props)) {
            collection.orderBefore(newAsset, oldAsset);
            collection.remove(oldAsset);
            this.updateLastModified(resolver, collection, imagesetAsset);
        } else {
            logger.warn("failed to add modified {} resource to collection {}", (Object)newAsset.getPath(), (Object)collection.getPath());
        }
    }

    private void updateLastModified(ResourceResolver resolver, ResourceCollection collection, Asset imagesetAsset) {
        Resource res;
        if (imagesetAsset != null) {
            Resource assetRes = (Resource)imagesetAsset.adaptTo(Resource.class);
            res = assetRes.getChild("jcr:content");
        } else {
            res = resolver.getResource(collection.getPath());
        }
        if (res != null) {
            ModifiableValueMap contentProps = (ModifiableValueMap)res.adaptTo(ModifiableValueMap.class);
            contentProps.put((Object)"jcr:lastModifiedBy", (Object)resolver.getUserID());
            contentProps.put((Object)"jcr:lastModified", (Object)Calendar.getInstance());
        }
    }

    private void updateReferences(ResourceCollection collection, Asset imagesetAsset, Resource existing, String assetNewPath) {
        if (!collection.contains(existing)) {
            return;
        }
        ModifiableValueMap props = collection.getProperties(existing);
        if (props != null && props.containsKey((Object)"dam:resolvedPath") && props.containsKey((Object)"dam:originalPath")) {
            String oldOrigPath = props.get((Object)"dam:originalPath").toString();
            String oldResPath = props.get((Object)"dam:resolvedPath").toString();
            props.put((Object)"dam:resolvedPath", (Object)assetNewPath);
            String resOrigPath = this.resolveOriginalPath(oldOrigPath, oldResPath, assetNewPath);
            if (resOrigPath != null) {
                props.put((Object)"dam:originalPath", (Object)resOrigPath);
                if (imagesetAsset != null && DamUtil.checkforAIFile((Asset)imagesetAsset)) {
                    this.updAIXmpManifest((Resource)imagesetAsset.adaptTo(Resource.class), oldOrigPath, resOrigPath);
                }
            }
        }
    }

    private String resolveOriginalPath(String origPath, String resPath, String assetNewPath) {
        if (origPath == null || resPath == null) {
            return null;
        }
        String suffix = resPath.substring("/content/dam".length());
        if (origPath.contains(suffix)) {
            String prefix = origPath.substring(0, origPath.indexOf(suffix));
            if (assetNewPath.length() > "/content/dam".length()) {
                return prefix + assetNewPath.substring("/content/dam".length());
            }
        }
        return null;
    }

    private void updateRelativePath(ResourceResolver resolver, Session session, String eventType, String assetNewPath) {
        if (eventType.equals("move")) {
            try {
                String assetsRoot = DamUtil.getTenantAssetsRoot((ResourceResolver)resolver, (String)assetNewPath);
                int idx = -1;
                idx = assetNewPath.indexOf(assetsRoot);
                if (0 <= idx) {
                    idx += assetsRoot.length();
                }
                Node assetJcrContent = session.getNode(assetNewPath).getNode("jcr:content");
                assetJcrContent.setProperty("dam:relativePath", assetNewPath.substring(idx + 1));
                session.save();
            }
            catch (Exception ign) {
                logger.warn("Couldn't update moved asset node", (Throwable)ign);
            }
        }
    }

    private void updAIXmpManifest(Resource resource, String oldOrigPath, String resOrigPath) {
        Resource linkNode;
        if (resource == null || resource.getChild("jcr:content/metadata/xmpMM:Manifest") == null) {
            return;
        }
        int linkNo = 1;
        do {
            String filePath;
            String property;
            ModifiableValueMap props;
            if ((linkNode = resource.getChild(property = "jcr:content/metadata/xmpMM:Manifest/" + String.valueOf(linkNo) + "/" + "stMfs:reference")) != null && (filePath = (String)(props = (ModifiableValueMap)linkNode.adaptTo(ModifiableValueMap.class)).get("stRef:filePath", String.class)) != null && filePath.equals(oldOrigPath)) {
                props.put((Object)"stRef:filePath", (Object)resOrigPath);
                return;
            }
            ++linkNo;
        } while (linkNode != null);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public JobConsumer.JobResult process(Job job) {
        ResourceResolver resolver = null;
        Session session = null;
        Object totalObj = job.getProperty("assets.total");
        int total = totalObj instanceof Long ? ((Long)totalObj).intValue() : ((Integer)totalObj).intValue();
        try {
            resolver = this.resolverFactory.getServiceResourceResolver(AUTH_INFO);
            session = (Session)resolver.adaptTo(Session.class);
            for (int i = 1; i < total + 1; ++i) {
                String path = (String)job.getProperty("" + i + "_path");
                String eventType = (String)job.getProperty("" + i + "_type");
                String assetNewPath = (String)job.getProperty("" + i + "_new_path");
                if (path.equals(assetNewPath)) continue;
                this.updateAssetPath(resolver, session, path, eventType, assetNewPath, (String)job.getProperty("node_type"));
                this.updateSwatchPath(resolver, session, path, eventType, assetNewPath);
                this.updateFolderThumbnail(resolver, path, eventType, assetNewPath);
                this.updateRelativePath(resolver, session, eventType, assetNewPath);
            }
        }
        catch (PersistenceException e) {
            logger.error("error occurred in updating collection/imageset: ", (Throwable)e);
            JobConsumer.JobResult path = JobConsumer.JobResult.FAILED;
            return path;
        }
        catch (RepositoryException e) {
            logger.error("error occurred in updating collection/imageset: ", (Throwable)e);
            JobConsumer.JobResult path = JobConsumer.JobResult.FAILED;
            return path;
        }
        catch (LoginException e) {
            logger.error("error occurred in updating collection/imageset: ", (Throwable)e);
            JobConsumer.JobResult path = JobConsumer.JobResult.FAILED;
            return path;
        }
        finally {
            if (session != null) {
                session.logout();
            }
            if (resolver != null) {
                resolver.close();
            }
        }
        return JobConsumer.JobResult.OK;
    }

    protected void bindResolverFactory(ResourceResolverFactory resourceResolverFactory) {
        this.resolverFactory = resourceResolverFactory;
    }

    protected void unbindResolverFactory(ResourceResolverFactory resourceResolverFactory) {
        if (this.resolverFactory == resourceResolverFactory) {
            this.resolverFactory = null;
        }
    }

    protected void bindQueryBuilder(QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
    }

    protected void unbindQueryBuilder(QueryBuilder queryBuilder) {
        if (this.queryBuilder == queryBuilder) {
            this.queryBuilder = null;
        }
    }

    protected void bindFolderPreviewUpdater(FolderPreviewUpdater folderPreviewUpdater) {
        this.folderPreviewUpdater = folderPreviewUpdater;
    }

    protected void unbindFolderPreviewUpdater(FolderPreviewUpdater folderPreviewUpdater) {
        if (this.folderPreviewUpdater == folderPreviewUpdater) {
            this.folderPreviewUpdater = null;
        }
    }
}