Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.cq.commons.Language
 *  com.day.cq.commons.LanguageUtil
 *  com.day.cq.wcm.api.LanguageManager
 *  com.day.cq.wcm.api.LanguageManager$Info
 *  com.day.cq.wcm.api.LanguageManager$Tree
 *  com.day.cq.wcm.api.LanguageManager$TreeNode
 *  com.day.cq.wcm.api.Page
 *  com.day.text.Text
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Property
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  org.apache.commons.collections.Predicate
 *  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.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ValueMap
 *  org.apache.sling.jcr.api.SlingRepository
 *  org.osgi.service.component.ComponentContext
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.wcm.core.impl;

import com.day.cq.commons.Language;
import com.day.cq.commons.LanguageUtil;
import com.day.cq.wcm.api.LanguageManager;
import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.core.impl.predicate.IsSiteAdminPredicate;
import com.day.text.Text;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.apache.commons.collections.Predicate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.jcr.api.SlingRepository;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(metatype=1, label="%langmgr.name", description="%langmgr.description")
@Service
public class LanguageManagerImpl
implements LanguageManager {
    private static final Logger log = LoggerFactory.getLogger(LanguageManagerImpl.class);
    private static final String LANGUAGE_MANAGER_SERVICE_USER = "language-manager-service";
    @org.apache.felix.scr.annotations.Property(value={"/libs/wcm/core/resources/languages"})
    private static final String LANGUAGE_LIST = "langmgr.list.path";
    private static final String PN_DEFAULT_COUNTRY = "defaultCountry";
    @org.apache.felix.scr.annotations.Property(cardinality=Integer.MAX_VALUE)
    private static final String DEFAULT_COUNTRIES = "langmgr.country.default";
    private static final Predicate PREDICATE = new IsSiteAdminPredicate();
    private Map<String, String> defaultCountries = new HashMap<String, String>();
    @Reference
    private SlingRepository repository;

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    protected void activate(ComponentContext context) {
        String[] defaultCountries;
        Dictionary props;
        props = context.getProperties();
        this.defaultCountries.clear();
        String path = (String)props.get("langmgr.list.path");
        if (path != null) {
            Session session = null;
            try {
                session = this.repository.loginService("language-manager-service", null);
                if (!session.hasPermission(path, "read")) {
                    log.warn("Not authorized to read the language list at location {}, please authorize service user {} accordingly", (Object)path, (Object)"language-manager-service");
                } else if (session.nodeExists(path)) {
                    Node languages = session.getNode(path);
                    NodeIterator nodes = languages.getNodes();
                    while (nodes.hasNext()) {
                        Node node = nodes.nextNode();
                        if (!node.hasProperty("defaultCountry")) continue;
                        this.addDefaultCountry(node.getProperty("defaultCountry").getString());
                    }
                }
            }
            catch (RepositoryException e) {
                log.warn("Could not read language list at " + path, (Throwable)e);
            }
            finally {
                if (session != null) {
                    session.logout();
                }
            }
        }
        if ((defaultCountries = (String[])props.get("langmgr.country.default")) != null) {
            for (String lang : defaultCountries) {
                this.addDefaultCountry(lang);
            }
        }
    }

    private void addDefaultCountry(String lang) {
        Locale locale = LanguageUtil.getLocale((String)lang);
        if (locale == null) {
            log.error("Invalid default country specified in config: {}. ignore it.", (Object)lang);
        } else {
            this.defaultCountries.put(locale.getLanguage(), locale.getCountry());
        }
    }

    public String getIsoCountry(Locale language) {
        String country = language.getCountry();
        if (country.length() == 0) {
            country = this.defaultCountries.get(language.getLanguage());
        }
        return country == null ? "" : country;
    }

    public Map<Locale, LanguageManager.Info> getAdjacentInfo(ResourceResolver resolver, String path) {
        Map<Language, LanguageManager.Info> infos = this.getAdjacentLanguageInfo(resolver, path);
        if (infos == null) {
            return null;
        }
        LinkedHashMap<Locale, LanguageManager.Info> ret = new LinkedHashMap<Locale, LanguageManager.Info>();
        for (Map.Entry<Language, LanguageManager.Info> e : infos.entrySet()) {
            ret.put(e.getKey().getLocale(), e.getValue());
        }
        return ret;
    }

    public Map<Language, LanguageManager.Info> getAdjacentLanguageInfo(ResourceResolver resolver, String path) {
        String root = LanguageUtil.getLanguageRoot((String)path);
        if (root == null) {
            return null;
        }
        String parent = Text.getRelativeParent((String)root, (int)1);
        String relPath = path.substring(root.length());
        LinkedHashMap<Language, LanguageManager.Info> infos = new LinkedHashMap<Language, LanguageManager.Info>();
        for (Language locale : this.getCqLanguages(resolver, path)) {
            String pPath = parent + "/" + locale.toString() + relPath;
            Resource res = resolver.getResource(pPath);
            Long lastModified = null;
            if (res != null) {
                lastModified = -1;
                Resource content = resolver.getResource(res, "jcr:content");
                if (content != null) {
                    lastModified = (Long)((ValueMap)content.adaptTo(ValueMap.class)).get("jcr:lastModified", (Object)0);
                }
            }
            InfoImpl info = new InfoImpl(pPath, lastModified);
            infos.put(locale, info);
        }
        return infos;
    }

    public Collection<Page> getLanguageRoots(ResourceResolver resolver, String path) {
        String root = LanguageUtil.getLanguageRoot((String)path);
        if (root == null) {
            return Collections.emptySet();
        }
        String parent = Text.getRelativeParent((String)root, (int)1);
        Resource parentResource = resolver.getResource(parent);
        if (parentResource == null) {
            return Collections.emptySet();
        }
        LinkedList<Page> pages = new LinkedList<Page>();
        Iterator iter = resolver.listChildren(parentResource);
        while (iter.hasNext()) {
            Page page;
            Resource r = (Resource)iter.next();
            Locale locale = LanguageUtil.getLocale((String)Text.getName((String)r.getPath()));
            if (locale == null || (page = (Page)r.adaptTo(Page.class)) == null) continue;
            pages.add(page);
        }
        return pages;
    }

    public Locale getLanguage(Resource res) {
        return this.getLanguage(res, true);
    }

    public Language getCqLanguage(Resource res) {
        return this.getCqLanguage(res, true);
    }

    public Locale getLanguage(Resource res, boolean respectContent) {
        Language l = this.getCqLanguage(res, respectContent);
        return l == null ? null : l.getLocale();
    }

    public Language getCqLanguage(Resource res, boolean respectContent) {
        String languageRoot;
        String path = res.getPath();
        if (respectContent) {
            int idx = path.indexOf("/jcr:content");
            if (idx > 0) {
                path = path.substring(0, idx);
            }
            try {
                for (Node node = (hr = res.getResourceResolver().getResource((String)path)) == null ? null : (Node)hr.adaptTo(Node.class); node != null && node.getDepth() > 0; node = node.getParent()) {
                    if (!node.hasProperty("jcr:content/jcr:language")) continue;
                    String iso = node.getProperty("jcr:content/jcr:language").getString();
                    Language locale = LanguageUtil.getLanguage((String)iso);
                    if (locale == null) {
                        log.warn("Invalid iso code stored in {}: {}", (Object)node.getPath(), (Object)iso);
                        continue;
                    }
                    return locale;
                }
            }
            catch (RepositoryException e) {
                log.warn("Error while retrieving language property.", (Throwable)e);
            }
        }
        if ((languageRoot = LanguageUtil.getLanguageRoot((String)path)) != null) {
            return new Language(Text.getName((String)languageRoot));
        }
        return null;
    }

    public Page getLanguageRoot(Resource res) {
        String root = LanguageUtil.getLanguageRoot((String)res.getPath());
        if (root == null) {
            return null;
        }
        Resource rootRes = res.getResourceResolver().getResource(root);
        if (rootRes == null) {
            return null;
        }
        return (Page)rootRes.adaptTo(Page.class);
    }

    public Collection<Locale> getLanguages(ResourceResolver resolver, String path) {
        LinkedList<Locale> locales = new LinkedList<Locale>();
        for (Language l : this.getCqLanguages(resolver, path)) {
            locales.add(l.getLocale());
        }
        return locales;
    }

    public Collection<Language> getCqLanguages(ResourceResolver resolver, String path) {
        String root = LanguageUtil.getLanguageRoot((String)path);
        if (root == null) {
            return Collections.emptySet();
        }
        String parent = Text.getRelativeParent((String)root, (int)1);
        Resource parentResource = resolver.getResource(parent);
        if (parentResource == null) {
            return Collections.emptySet();
        }
        LinkedList<Language> languages = new LinkedList<Language>();
        Iterator iter = resolver.listChildren(parentResource);
        while (iter.hasNext()) {
            Resource r = (Resource)iter.next();
            Language locale = LanguageUtil.getLanguage((String)Text.getName((String)r.getPath()));
            if (locale == null) continue;
            languages.add(locale);
        }
        return languages;
    }

    public LanguageManager.Tree compareLanguageTrees(ResourceResolver resolver, String path) {
        Set<Language> locales;
        String parent;
        String root = LanguageUtil.getLanguageRoot((String)path);
        if (root == null) {
            locales = LanguageManagerImpl.getChildLanguages(resolver, path);
            parent = path;
            if (locales.isEmpty()) {
                return null;
            }
            path = root = parent + "/" + locales.iterator().next().toString();
        } else {
            parent = Text.getRelativeParent((String)root, (int)1);
            locales = LanguageManagerImpl.getChildLanguages(resolver, parent);
        }
        TreeImpl tree = new TreeImpl(locales, parent);
        if (path.equals(root)) {
            for (Language locale : tree.getCqLanguages()) {
                String pRoot = parent + "/" + locale.toString();
                Resource res = resolver.getResource(pRoot);
                LanguageManagerImpl.fillTree(tree, locale, pRoot.length(), resolver, res);
            }
        } else {
            String relPath = path.substring(root.length());
            for (Language locale : tree.getCqLanguages()) {
                String pRoot = parent + "/" + locale.toString();
                String pPath = pRoot + relPath;
                Resource res = resolver.getResource(pPath);
                LanguageManagerImpl.fillTree(tree, locale, pRoot.length(), resolver, res);
            }
        }
        return tree;
    }

    private static Set<Language> getChildLanguages(ResourceResolver resolver, String path) {
        HashSet<Language> locales = new HashSet<Language>();
        Resource res = resolver.getResource(path);
        if (res != null) {
            Iterator iter = resolver.listChildren(res);
            while (iter.hasNext()) {
                res = (Resource)iter.next();
                Language locale = LanguageUtil.getLanguage((String)Text.getName((String)res.getPath()));
                if (locale == null) continue;
                locales.add(locale);
            }
        }
        return locales;
    }

    private static void fillTree(TreeImpl tree, Language language, int rootLength, ResourceResolver resolver, Resource res) {
        if (res != null && PREDICATE.evaluate((Object)res)) {
            Long lastModified = -1;
            Iterator iter = resolver.listChildren(res);
            while (iter.hasNext()) {
                Resource child = (Resource)iter.next();
                if (Text.getName((String)child.getPath()).equals("jcr:content")) {
                    lastModified = (Long)((ValueMap)child.adaptTo(ValueMap.class)).get("jcr:lastModified", (Object)0);
                    continue;
                }
                LanguageManagerImpl.fillTree(tree, language, rootLength, resolver, child);
            }
            String relPath = res.getPath();
            relPath = rootLength < relPath.length() ? relPath.substring(rootLength + 1) : "";
            tree.addInfo(language, relPath, lastModified);
        }
    }

    protected void bindRepository(SlingRepository slingRepository) {
        this.repository = slingRepository;
    }

    protected void unbindRepository(SlingRepository slingRepository) {
        if (this.repository == slingRepository) {
            this.repository = null;
        }
    }

    private static final class InfoImpl
    implements LanguageManager.Info {
        private final String path;
        private final Long lastModified;

        public InfoImpl(String path, Long lastModified) {
            this.path = path;
            this.lastModified = lastModified;
        }

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

        public boolean exists() {
            return this.lastModified != null;
        }

        public boolean hasContent() {
            return this.lastModified != null && this.lastModified >= 0;
        }

        public long getLastModified() {
            return this.lastModified == null ? 0 : this.lastModified;
        }
    }

    private static class TreeImpl
    implements LanguageManager.Tree {
        private final Map<Language, Integer> indexes = new HashMap<Language, Integer>();
        private final String root;
        private final TreeMap<String, Node> tree;

        public TreeImpl(Collection<Language> languages, String root) {
            this.tree = new TreeMap(new Comparator<String>(){

                @Override
                public int compare(String o1, String o2) {
                    return Text.compareHandles((String)o1, (String)o2);
                }
            });
            this.root = root;
            int i = 0;
            for (Language locale : languages) {
                this.indexes.put(locale, i++);
            }
        }

        public String getRoot() {
            return this.root;
        }

        public Collection<Locale> getLanguages() {
            ArrayList<Locale> locales = new ArrayList<Locale>();
            for (Language lang : this.indexes.keySet()) {
                locales.add(lang.getLocale());
            }
            return locales;
        }

        public Collection<Language> getCqLanguages() {
            return this.indexes.keySet();
        }

        public Collection<? extends LanguageManager.TreeNode> getNodes() {
            return this.tree.values();
        }

        private void addInfo(Language locale, String relPath, long lastModified) {
            Node node = this.tree.get(relPath);
            if (node == null) {
                node = new Node(relPath, this.indexes.size());
                this.tree.put(relPath, node);
            }
            Node.access$200((Node)node)[this.indexes.get((Object)locale).intValue()] = lastModified;
        }

        private class Node
        implements LanguageManager.TreeNode {
            private final String relPath;
            private final Long[] lastModified;

            private Node(String relPath, int numLanguages) {
                this.relPath = relPath;
                this.lastModified = new Long[numLanguages];
            }

            public String getRelativePath() {
                return this.relPath;
            }

            public LanguageManager.Info getInfo(Locale locale) {
                return this.getInfo(new Language(locale));
            }

            public LanguageManager.Info getInfo(Language locale) {
                Integer idx = (Integer)TreeImpl.this.indexes.get((Object)locale);
                if (idx == null) {
                    return null;
                }
                StringBuffer iPath = new StringBuffer(TreeImpl.this.root).append('/').append(locale.toString());
                if (this.relPath.length() > 0) {
                    iPath.append('/').append(this.relPath);
                }
                return new InfoImpl(iPath.toString(), this.lastModified[idx]);
            }

            static /* synthetic */ Long[] access$200(Node x0) {
                return x0.lastModified;
            }
        }

    }

}