Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  aQute.bnd.annotation.ConsumerType
 *  com.adobe.cq.wcm.launches.utils.LaunchUtils
 *  com.day.cq.commons.Filter
 *  com.day.cq.commons.LabeledResource
 *  com.day.cq.commons.LanguageUtil
 *  com.day.cq.commons.SlingRepositoryException
 *  com.day.cq.tagging.Tag
 *  com.day.cq.tagging.TagManager
 *  com.day.cq.wcm.api.Page
 *  com.day.cq.wcm.api.PageManager
 *  com.day.cq.wcm.api.Template
 *  com.day.cq.wcm.api.WCMException
 *  com.day.cq.wcm.commons.DeepResourceIterator
 *  com.day.text.Text
 *  javax.jcr.AccessDeniedException
 *  javax.jcr.Node
 *  javax.jcr.Property
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.jcr.lock.Lock
 *  org.apache.sling.adapter.SlingAdaptable
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ResourceUtil
 *  org.apache.sling.api.resource.ValueMap
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.wcm.core.impl;

import aQute.bnd.annotation.ConsumerType;
import com.adobe.cq.wcm.launches.utils.LaunchUtils;
import com.day.cq.commons.Filter;
import com.day.cq.commons.LabeledResource;
import com.day.cq.commons.LanguageUtil;
import com.day.cq.commons.SlingRepositoryException;
import com.day.cq.tagging.Tag;
import com.day.cq.tagging.TagManager;
import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageManager;
import com.day.cq.wcm.api.Template;
import com.day.cq.wcm.api.WCMException;
import com.day.cq.wcm.commons.DeepResourceIterator;
import com.day.cq.wcm.core.impl.PageIterator;
import com.day.text.Text;
import java.util.Calendar;
import java.util.Iterator;
import java.util.Locale;
import javax.jcr.AccessDeniedException;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.lock.Lock;
import org.apache.sling.adapter.SlingAdaptable;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.ValueMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ConsumerType
public class PageImpl
extends SlingAdaptable
implements Page {
    private static final Logger log = LoggerFactory.getLogger(PageImpl.class);
    public static final String RESOURCE_TYPE = "cq:Page";
    private PageManager manager;
    private final Resource resource;
    protected final Node node;
    private ValueMap contentProps;
    private Tag[] tagCache;

    public PageImpl(Resource resource) {
        this.resource = resource;
        this.node = (Node)resource.adaptTo(Node.class);
        if (this.node == null) {
            throw new IllegalArgumentException("Resource argument must be adaptable to Node");
        }
    }

    public String getPath() {
        return this.resource.getPath();
    }

    public <AdapterType> AdapterType adaptTo(Class<AdapterType> type) {
        if (type == Resource.class) {
            return (AdapterType)this.resource;
        }
        if (type == LabeledResource.class) {
            return (AdapterType)((Object)this);
        }
        if (type == Node.class) {
            return (AdapterType)this.node;
        }
        Object ret = super.adaptTo(type);
        if (ret == null) {
            ret = this.resource.adaptTo(type);
        }
        return (AdapterType)ret;
    }

    public Resource getContentResource() {
        return this.resource.getResourceResolver().getResource(this.resource, "jcr:content");
    }

    public Resource getContentResource(String relPath) {
        if (relPath == null || relPath.length() == 0) {
            return this.getContentResource();
        }
        if (relPath.charAt(0) == '/') {
            throw new IllegalArgumentException("Relative path expected.");
        }
        return this.resource.getResourceResolver().getResource(this.resource, "jcr:content/" + relPath);
    }

    public PageManager getPageManager() {
        if (this.manager == null) {
            this.manager = (PageManager)this.resource.getResourceResolver().adaptTo(PageManager.class);
        }
        return this.manager;
    }

    public Iterator<Page> listChildren() {
        return this.listChildren(null);
    }

    public Iterator<Page> listChildren(Filter<Page> filter) {
        return new PageIterator(this.resource.getResourceResolver().listChildren(this.resource), filter);
    }

    public Iterator<Page> listChildren(Filter<Page> filter, boolean deep) {
        if (deep) {
            return new PageIterator((Iterator<Resource>)new DeepResourceIterator(this.resource), filter);
        }
        return new PageIterator(this.resource.getResourceResolver().listChildren(this.resource), filter);
    }

    public boolean hasChild(String name) {
        try {
            return this.node.hasNode(name);
        }
        catch (RepositoryException e) {
            throw new SlingRepositoryException(e);
        }
    }

    public Page getParent() {
        return this.getParent(1);
    }

    public int getDepth() {
        try {
            return this.node.getDepth();
        }
        catch (RepositoryException e) {
            throw new SlingRepositoryException(e);
        }
    }

    public Page getParent(int level) {
        if (level == 0) {
            return this;
        }
        String path = Text.getRelativeParent((String)this.resource.getPath(), (int)level);
        if (path.equals("") || path.equals("/")) {
            return null;
        }
        Resource parentRes = this.resource.getResourceResolver().getResource(path);
        return parentRes == null ? null : (Page)parentRes.adaptTo(Page.class);
    }

    public Page getAbsoluteParent(int level) {
        if (LaunchUtils.isLaunchBasedPath((String)this.resource.getPath())) {
            level += 3;
        }
        String path = Text.getAbsoluteParent((String)this.resource.getPath(), (int)level);
        Resource parentRes = this.resource.getResourceResolver().getResource(path);
        return parentRes == null ? null : (Page)parentRes.adaptTo(Page.class);
    }

    public ValueMap getProperties() {
        if (this.contentProps == null) {
            this.contentProps = ResourceUtil.getValueMap((Resource)this.getContentResource());
        }
        return this.contentProps;
    }

    public ValueMap getProperties(String relPath) {
        if (relPath == null || relPath.length() == 0) {
            return this.getProperties();
        }
        return ResourceUtil.getValueMap((Resource)this.getContentResource(relPath));
    }

    public String getName() {
        try {
            return this.node.getName();
        }
        catch (RepositoryException e) {
            return null;
        }
    }

    public String getTitle() {
        return (String)this.getProperties().get("jcr:title", String.class);
    }

    public String getDescription() {
        return (String)this.getProperties().get("jcr:description", String.class);
    }

    public String getPageTitle() {
        return (String)this.getProperties().get("pageTitle", String.class);
    }

    public String getNavigationTitle() {
        return (String)this.getProperties().get("navTitle", String.class);
    }

    public boolean isHideInNav() {
        return (Boolean)this.getProperties().get("hideInNav", (Object)Boolean.FALSE);
    }

    public boolean hasContent() {
        try {
            return this.node.hasNode("jcr:content");
        }
        catch (RepositoryException e) {
            log.warn("Repository error while accessing content of {}", (Object)this.getPath());
            return false;
        }
    }

    public boolean isValid() {
        return this.timeUntilValid() == 0;
    }

    public long timeUntilValid() {
        long timeUntilOff;
        long timeUntilOn;
        if (!this.hasContent()) {
            return Long.MIN_VALUE;
        }
        Calendar onTime = this.getOnTime();
        Calendar offTime = this.getOffTime();
        if (onTime == null && offTime == null) {
            return 0;
        }
        long now = System.currentTimeMillis();
        long l = timeUntilOn = onTime == null ? 0 : onTime.getTimeInMillis() - now;
        if (timeUntilOn > 0) {
            return timeUntilOn;
        }
        long l2 = timeUntilOff = offTime == null ? 0 : offTime.getTimeInMillis() - now;
        if (timeUntilOff < 0) {
            return timeUntilOff;
        }
        return 0;
    }

    public Calendar getOnTime() {
        return (Calendar)this.getProperties().get("onTime", Calendar.class);
    }

    public Calendar getOffTime() {
        return (Calendar)this.getProperties().get("offTime", Calendar.class);
    }

    public Calendar getDeleted() {
        return (Calendar)this.getProperties().get("deleted", Calendar.class);
    }

    public String getDeletedBy() {
        return (String)this.getProperties().get("deletedBy", String.class);
    }

    public String getLastModifiedBy() {
        String lm = (String)this.getProperties().get("cq:lastModifiedBy", String.class);
        if (lm == null) {
            lm = (String)this.getProperties().get("jcr:lastModifiedBy", String.class);
        }
        return lm;
    }

    public Calendar getLastModified() {
        Calendar lm = (Calendar)this.getProperties().get("cq:lastModified", Calendar.class);
        if (lm == null) {
            lm = (Calendar)this.getProperties().get("jcr:lastModified", Calendar.class);
        }
        return lm;
    }

    public String getVanityUrl() {
        return (String)this.getProperties().get("vanityUrl", this.getProperties().get("sling:vanityPath", String.class));
    }

    public Tag[] getTags() {
        if (this.tagCache == null) {
            Resource resource = this.getContentResource();
            TagManager tagManager = (TagManager)resource.getResourceResolver().adaptTo(TagManager.class);
            if (tagManager == null) {
                return new Tag[0];
            }
            this.tagCache = tagManager.getTags(resource);
        }
        return this.tagCache;
    }

    public void lock() throws WCMException {
        try {
            if (this.hasContent()) {
                Node content = this.node.getNode("jcr:content");
                if (content.canAddMixin("mix:lockable")) {
                    content.addMixin("mix:lockable");
                    content.save();
                }
                content.lock(true, false);
            }
        }
        catch (RepositoryException e) {
            throw new WCMException("Unable to lock page.", (Throwable)e);
        }
    }

    public boolean isLocked() {
        try {
            return this.node.getNode("jcr:content").isLocked();
        }
        catch (RepositoryException e) {
            log.warn("Repository error while checking lock status of {}", (Object)this.getPath());
            return false;
        }
    }

    public String getLockOwner() {
        try {
            Node content;
            if (this.hasContent() && (content = this.node.getNode("jcr:content")).isLocked()) {
                return content.getLock().getLockOwner();
            }
        }
        catch (RepositoryException e) {
            log.warn("Repository error while getting lock owner of {}", (Object)this.getPath());
        }
        return null;
    }

    public boolean canUnlock() {
        try {
            String lockOwner = this.getLockOwner();
            if (lockOwner != null) {
                return lockOwner.equals(this.node.getSession().getUserID());
            }
        }
        catch (RepositoryException e) {
            log.warn("Repository error while checking whether current user can unlock {}", (Object)this.getPath());
        }
        return false;
    }

    public void unlock() throws WCMException {
        try {
            if (this.hasContent()) {
                this.node.getNode("jcr:content").unlock();
            }
        }
        catch (RepositoryException e) {
            throw new WCMException("Unable to unlock page.", (Throwable)e);
        }
    }

    public Template getTemplate() {
        String tpPath = (String)this.getProperties().get("cq:template", String.class);
        if (tpPath == null) {
            return null;
        }
        Resource tpRes = this.resource.getResourceResolver().getResource(tpPath);
        if (tpRes == null) {
            return null;
        }
        return (Template)tpRes.adaptTo(Template.class);
    }

    /*
     * Unable to fully structure code
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     * Lifted jumps to return sites
     */
    public Locale getLanguage(boolean ignoreContent) {
        ISO_PROP_NAME = "jcr:content/jcr:language";
        locale = null;
        pathLocale = null;
        pageNode = this.node;
        try {
            while (pageNode != null) {
                if (ignoreContent || !pageNode.hasProperty("jcr:content/jcr:language")) ** GOTO lbl12
                iso = pageNode.getProperty("jcr:content/jcr:language").getString();
                locale = LanguageUtil.getLocale((String)iso);
                if (locale == null) {
                    PageImpl.log.warn("Invalid iso code stored in {}: {}", (Object)pageNode.getPath(), (Object)iso);
lbl12: // 2 sources:
                    if (pathLocale == null) {
                        pathLocale = LanguageUtil.getLocale((String)pageNode.getName());
                    }
                    pageNode = pageNode.getDepth() <= 1 ? null : pageNode.getParent();
                    continue;
                }
                break;
            }
        }
        catch (AccessDeniedException e) {
            try {
                PageImpl.log.info("Could not access parent of {} to look for the page language", (Object)pageNode.getPath());
            }
            catch (RepositoryException ignore) {}
        }
        catch (RepositoryException e) {
            PageImpl.log.error("Error while evaluating content language.", (Throwable)e);
        }
        if (locale == null) {
            locale = pathLocale;
        }
        if (locale != null) return locale;
        return Locale.getDefault();
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof PageImpl)) {
            return false;
        }
        PageImpl page = (PageImpl)((Object)o);
        return this.resource.getPath().equals(page.resource.getPath());
    }

    public int hashCode() {
        return this.resource.getPath().hashCode();
    }
}