Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.cq.commons.jcr.JcrUtil
 *  com.google.gson.Gson
 *  com.google.gson.GsonBuilder
 *  com.google.gson.JsonElement
 *  com.google.gson.JsonObject
 *  com.google.gson.JsonParser
 *  javax.jcr.Binary
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Property
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.jcr.Value
 *  javax.jcr.ValueFactory
 *  javax.jcr.Workspace
 *  javax.jcr.query.Query
 *  javax.jcr.query.QueryManager
 *  javax.jcr.query.QueryResult
 *  org.apache.commons.lang3.RandomStringUtils
 *  org.apache.commons.lang3.StringUtils
 *  org.apache.sling.api.resource.PersistenceException
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ResourceUtil
 *  org.apache.sling.jcr.resource.JcrResourceUtil
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.cq.wcm.translation.impl;

import com.adobe.cq.wcm.translation.impl.TranslationUtils;
import com.day.cq.commons.jcr.JcrUtil;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.jcr.Binary;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.ValueFactory;
import javax.jcr.Workspace;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
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.ResourceUtil;
import org.apache.sling.jcr.resource.JcrResourceUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class I18nDictionary {
    private static final Logger log = LoggerFactory.getLogger(I18nDictionary.class);
    private static final int DICT_NAME_RANDOM_STRING_LENGTH = 15;
    private static final String I18N_JCR_ENTRY_PREFIX = "entry_";
    private static String COMMENT_START_IDENTIFIER = " ((";
    private static String COMMENT_END_IDENTIFIER = "))";

    public static Resource fetchI18nDictionaryResource(Resource parent, String baseName, String language) throws UnsupportedEncodingException {
        log.trace("In function: fetchI18nDictionaryResource with Language:{} BaseName:{}", (Object)language, (Object)baseName);
        Iterable childList = parent.getChildren();
        for (Resource child : childList) {
            if (!I18nDictionary.isI18nDictionary(child) || !StringUtils.equalsIgnoreCase((CharSequence)TranslationUtils.getAttribute(child, "jcr:language", String.class), (CharSequence)language) || !StringUtils.equals((CharSequence)TranslationUtils.getAttribute(child, "sling:basename", String.class), (CharSequence)baseName)) continue;
            log.trace("I18n dictionary(Lang:{}) found at {}", (Object)language, (Object)child.getPath());
            return child;
        }
        log.trace("I18n dictionary(Lang:{}) not found at {}", (Object)language, (Object)parent.getPath());
        return null;
    }

    public static boolean isI18nDictionary(Resource resource) {
        String[] mixinTypes = TranslationUtils.getAttribute(resource, "jcr:mixinTypes", String[].class);
        String language = TranslationUtils.getAttribute(resource, "jcr:language", String.class);
        return mixinTypes != null && language != null && Arrays.asList(mixinTypes).contains("mix:language");
    }

    public static Resource getOrCreateI18nDictionaryResource(ResourceResolver resourceResolver, String parentPath, String language, String baseName, boolean isJson) {
        Resource resource;
        try {
            Resource parentResource = ResourceUtil.getOrCreateResource((ResourceResolver)resourceResolver, (String)parentPath, (String)"sling:Folder", (String)"sling:Folder", (boolean)false);
            resource = I18nDictionary.fetchI18nDictionaryResource(parentResource, baseName, language);
            if (resource == null) {
                resource = I18nDictionary.createI18nDictionaryResource(parentResource, language, baseName, isJson);
            }
        }
        catch (Exception e) {
            resource = null;
        }
        return resource;
    }

    private static Resource createI18nDictionaryResource(Resource parent, String language, String baseName, boolean isJson) throws UnsupportedEncodingException, RepositoryException, PersistenceException {
        Node i18nNode;
        log.trace("In function: createI18nDictionaryResource");
        log.trace("Create I18n dictionary at {}/{}", (Object)parent.getPath(), (Object)language);
        ResourceResolver resourceResolver = parent.getResourceResolver();
        if (isJson) {
            String dictionaryName = language + ".json";
            while (parent.getChild(dictionaryName) != null) {
                dictionaryName = language + "_" + RandomStringUtils.randomAlphanumeric((int)15) + ".json";
            }
            log.trace("Creating JSON based I18n dictionary({}) at {}", (Object)language, (Object)(parent.getPath() + "/" + dictionaryName));
            i18nNode = ((Node)parent.adaptTo(Node.class)).addNode(dictionaryName, "nt:file");
            Node content = i18nNode.addNode("jcr:content", "nt:resource");
            content.setPrimaryType("nt:resource");
            content.setProperty("jcr:mimeType", "application/json");
            content.setProperty("jcr:data", "{}");
        } else {
            Node parentNode = (Node)parent.adaptTo(Node.class);
            String dictionaryName = JcrUtil.createValidChildName((Node)parentNode, (String)language);
            log.trace("Creating JCR based I18n dictionary({}) at {}", (Object)language, (Object)(parent.getPath() + "/" + dictionaryName));
            i18nNode = JcrResourceUtil.createPath((Node)parentNode, (String)dictionaryName, (String)"nt:unstructured", (String)"sling:Folder", (boolean)false);
            if (!StringUtils.isEmpty((CharSequence)baseName)) {
                i18nNode.setProperty("sling:basename", baseName);
            }
        }
        i18nNode.addMixin("mix:language");
        i18nNode.setProperty("jcr:language", language);
        resourceResolver.commit();
        return resourceResolver.getResource(i18nNode.getPath());
    }

    public static boolean isI18nEntry(Resource resource) throws RepositoryException {
        Node node = (Node)resource.adaptTo(Node.class);
        if (node != null && node.hasProperty("sling:message")) {
            if (node.isNodeType("sling:MessageEntry")) {
                return true;
            }
            Property properties = node.getProperty("jcr:mixinTypes");
            for (Value value : properties.getValues()) {
                if (!StringUtils.equals((CharSequence)value.toString(), (CharSequence)"sling:Message")) continue;
                return true;
            }
        }
        return false;
    }

    public static ArrayList<Resource> getI18nJCREntryResourceList(Resource i18nDict) {
        Iterable childList = i18nDict.getChildren();
        ArrayList<Resource> resourceList = new ArrayList<Resource>();
        for (Resource child : childList) {
            try {
                if (!I18nDictionary.isI18nEntry(child)) continue;
                resourceList.add(child);
            }
            catch (RepositoryException e) {
                log.error("Error reading I18n JCR entries", (Throwable)e);
            }
        }
        return resourceList;
    }

    static String getI18nJCREntryKey(Resource jcrEntry) throws RepositoryException {
        String key = TranslationUtils.getAttribute(jcrEntry, "sling:key", String.class);
        if (key == null) {
            return jcrEntry.getName();
        }
        return key;
    }

    public static void getAllKeysFromDict(Resource i18nDict, HashSet<String> i18nKeySet) {
        if (TranslationUtils.checkFileExtension((Node)i18nDict.adaptTo(Node.class), ".json")) {
            I18nDictionary.getAllKeysFromJsonDict(i18nDict, i18nKeySet);
        } else {
            I18nDictionary.getAllKeysFromJcrDict(i18nDict, i18nKeySet);
        }
    }

    static void getAllKeysFromJsonDict(Resource i18nDict, HashSet<String> i18nKeySet) {
        try {
            JsonParser parser = new JsonParser();
            InputStream jsonStream = (InputStream)i18nDict.adaptTo(InputStream.class);
            InputStreamReader jsonReader = new InputStreamReader(jsonStream, "UTF-8");
            JsonObject jsonObject = parser.parse((Reader)jsonReader).getAsJsonObject();
            Set jsonEntries = jsonObject.entrySet();
            for (Map.Entry jsonEntry : jsonEntries) {
                i18nKeySet.add((String)jsonEntry.getKey());
            }
        }
        catch (UnsupportedEncodingException ignored) {
            // empty catch block
        }
    }

    static void getAllKeysFromJcrDict(Resource i18nDict, HashSet<String> i18nKeySet) {
        Iterable childList = i18nDict.getChildren();
        for (Resource child : childList) {
            try {
                if (!I18nDictionary.isI18nEntry(child)) continue;
                i18nKeySet.add(I18nDictionary.getI18nJCREntryKey(child));
            }
            catch (RepositoryException e) {
                log.error("Error reading I18n JCR entries", (Throwable)e);
            }
        }
    }

    public static void getAllEntriesFromDict(Resource i18nDict, HashMap<String, String> i18nEntryMap) {
        if (TranslationUtils.checkFileExtension((Node)i18nDict.adaptTo(Node.class), ".json")) {
            I18nDictionary.getAllEntriesFromJsonDict(i18nDict, i18nEntryMap);
        } else {
            I18nDictionary.getAllEntriesFromJcrDict(i18nDict, i18nEntryMap);
        }
    }

    static void getAllEntriesFromJsonDict(Resource i18nDict, HashMap<String, String> i18nEntryMap) {
        try {
            JsonParser parser = new JsonParser();
            InputStream jsonStream = (InputStream)i18nDict.adaptTo(InputStream.class);
            InputStreamReader jsonReader = new InputStreamReader(jsonStream, "UTF-8");
            JsonObject jsonObject = parser.parse((Reader)jsonReader).getAsJsonObject();
            Set jsonEntries = jsonObject.entrySet();
            for (Map.Entry jsonEntry : jsonEntries) {
                i18nEntryMap.put((String)jsonEntry.getKey(), ((JsonElement)jsonEntry.getValue()).getAsString());
            }
        }
        catch (UnsupportedEncodingException ignored) {
            // empty catch block
        }
    }

    static void getAllEntriesFromJcrDict(Resource i18nDict, HashMap<String, String> i18nEntryMap) {
        Iterable childList = i18nDict.getChildren();
        for (Resource child : childList) {
            try {
                if (!I18nDictionary.isI18nEntry(child)) continue;
                i18nEntryMap.put(I18nDictionary.getI18nJCREntryKey(child), TranslationUtils.getAttribute(child, "sling:message", String.class));
            }
            catch (RepositoryException e) {
                log.error("Error reading I18n JCR entries", (Throwable)e);
            }
        }
    }

    public static HashSet<String> getAllI18nDictKeys(ResourceResolver resolver, String language, String baseName) {
        HashSet<String> i18nKeySet = new HashSet<String>();
        List<Node> i18nDictNodeList = I18nDictionary.getAllI18nDicts(resolver, language, baseName);
        if (i18nDictNodeList != null) {
            for (Node i18nDict : i18nDictNodeList) {
                try {
                    I18nDictionary.getAllKeysFromDict(resolver.getResource(i18nDict.getPath()), i18nKeySet);
                }
                catch (RepositoryException ignored) {}
            }
        }
        return i18nKeySet;
    }

    static List<Node> getAllI18nDicts(ResourceResolver resolver, String language, String baseName) {
        log.trace("In function: getAllI18nDicts for {}", (Object)language);
        ArrayList<Node> i18nDicts = new ArrayList<Node>();
        try {
            Session session = (Session)resolver.adaptTo(Session.class);
            QueryManager qm = session.getWorkspace().getQueryManager();
            QueryResult result = baseName == null ? qm.createQuery("//element(*, mix:language)[@jcr:language=\"" + language + "\" ]", "xpath").execute() : qm.createQuery("//element(*, mix:language)[@sling:basename=\"" + baseName + "\" " + "and @jcr:language=\"" + language + "\" ]", "xpath").execute();
            NodeIterator nodes = result.getNodes();
            log.trace("{} dictionaries found", (Object)nodes.getSize());
            while (nodes.hasNext()) {
                Node node = nodes.nextNode();
                i18nDicts.add(node);
                log.trace("{}", (Object)node.getPath());
            }
        }
        catch (RepositoryException e) {
            return null;
        }
        return i18nDicts;
    }

    public static NodeIterator getAllI18nDictsAtPath(ResourceResolver resolver, String path, String baseName) {
        log.trace("In function: getAllI18nDictsAtPath path:{} basename:{}", (Object)path, (Object)baseName);
        try {
            Session session = (Session)resolver.adaptTo(Session.class);
            QueryManager qm = session.getWorkspace().getQueryManager();
            QueryResult result = baseName == null ? qm.createQuery("/jcr:root" + path + "//element(*, mix:language)", "xpath").execute() : qm.createQuery("/jcr:root" + path + "//element(*, mix:language)[@sling:basename=\"" + baseName + "\" ]", "xpath").execute();
            return result.getNodes();
        }
        catch (RepositoryException e) {
            log.error("Can't get i18n dictionaries from {}", (Object)path, (Object)e);
            return null;
        }
    }

    public static boolean addEntriesToDict(Resource i18nDict, HashMap<String, String> newEntries) {
        log.trace("In function: addEntriesToDict");
        if (TranslationUtils.checkFileExtension((Node)i18nDict.adaptTo(Node.class), ".json")) {
            return I18nDictionary.addEntriesToJsonDict(i18nDict, newEntries);
        }
        return I18nDictionary.addEntriesToJcrDict(i18nDict, newEntries);
    }

    private static boolean addEntriesToJsonDict(Resource jsonDict, HashMap<String, String> newEntries) {
        log.trace("In function: addEntriesToJsonDict");
        boolean bSave = false;
        try {
            JsonParser parser = new JsonParser();
            InputStream jsonStream = (InputStream)jsonDict.adaptTo(InputStream.class);
            InputStreamReader jsonReader = new InputStreamReader(jsonStream, "UTF-8");
            JsonObject jsonObject = parser.parse((Reader)jsonReader).getAsJsonObject();
            for (Map.Entry<String, String> newEntry : newEntries.entrySet()) {
                jsonObject.addProperty(newEntry.getKey(), newEntry.getValue());
                bSave = true;
            }
            if (bSave) {
                Gson gson = new GsonBuilder().setPrettyPrinting().create();
                ByteArrayInputStream inputStream = new ByteArrayInputStream(gson.toJson((JsonElement)jsonObject).getBytes(Charset.forName("UTF-8")));
                Node jsonJcrContent = ((Node)jsonDict.adaptTo(Node.class)).getNode("jcr:content");
                jsonJcrContent.setProperty("jcr:data", jsonJcrContent.getSession().getValueFactory().createBinary((InputStream)inputStream));
            }
        }
        catch (Exception e) {
            bSave = false;
        }
        return bSave;
    }

    private static boolean addEntriesToJcrDict(Resource i18nDict, HashMap<String, String> newEntries) {
        boolean bSave = false;
        HashMap<String, String> existingEntries = new HashMap<String, String>();
        I18nDictionary.getAllEntriesFromJcrDict(i18nDict, existingEntries);
        Node destDictNode = (Node)i18nDict.adaptTo(Node.class);
        if (existingEntries.size() > 0) {
            int entryCnt = existingEntries.size();
            for (Map.Entry<String, String> newEntry : newEntries.entrySet()) {
                String key = newEntry.getKey();
                if (existingEntries.containsKey(key)) continue;
                ++entryCnt;
                try {
                    bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, key, newEntry.getValue());
                }
                catch (RepositoryException ignored) {
                    log.error("Could not add entry:{}", (Object)key);
                }
            }
        } else {
            int entryCnt = 0;
            for (Map.Entry<String, String> newEntry : newEntries.entrySet()) {
                String key = newEntry.getKey();
                ++entryCnt;
                try {
                    bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, key, newEntry.getValue());
                }
                catch (RepositoryException ignored) {
                    log.error("Could not add entry:{}", (Object)key);
                }
            }
        }
        return bSave;
    }

    public static boolean addEntriesToDict(Resource i18nDict, HashSet<String> newEntries) {
        log.trace("In function: addEntriesToDict");
        if (TranslationUtils.checkFileExtension((Node)i18nDict.adaptTo(Node.class), ".json")) {
            return I18nDictionary.addEntriesToJsonDict(i18nDict, newEntries);
        }
        return I18nDictionary.addEntriesToJcrDict(i18nDict, newEntries);
    }

    private static boolean addEntriesToJsonDict(Resource jsonDict, HashSet<String> newEntries) {
        log.trace("In function: addEntriesToJsonDict");
        boolean bSave = false;
        try {
            JsonParser parser = new JsonParser();
            InputStream jsonStream = (InputStream)jsonDict.adaptTo(InputStream.class);
            InputStreamReader jsonReader = new InputStreamReader(jsonStream, "UTF-8");
            JsonObject jsonObject = parser.parse((Reader)jsonReader).getAsJsonObject();
            for (String newEntry : newEntries) {
                String[] stringAndComment;
                if (I18nDictionary.disJoinStringAndComment(newEntry, stringAndComment = new String[2])) {
                    jsonObject.addProperty(newEntry, stringAndComment[0]);
                } else {
                    jsonObject.addProperty(newEntry, newEntry);
                }
                bSave = true;
            }
            if (bSave) {
                Gson gson = new GsonBuilder().setPrettyPrinting().create();
                ByteArrayInputStream inputStream = new ByteArrayInputStream(gson.toJson((JsonElement)jsonObject).getBytes(Charset.forName("UTF-8")));
                Node jsonJcrContent = ((Node)jsonDict.adaptTo(Node.class)).getNode("jcr:content");
                jsonJcrContent.setProperty("jcr:data", jsonJcrContent.getSession().getValueFactory().createBinary((InputStream)inputStream));
            }
        }
        catch (Exception e) {
            bSave = false;
        }
        return bSave;
    }

    private static boolean addEntriesToJcrDict(Resource i18nDict, HashSet<String> newEntries) {
        boolean bSave = false;
        HashMap<String, String> existingEntries = new HashMap<String, String>();
        I18nDictionary.getAllEntriesFromJcrDict(i18nDict, existingEntries);
        Node destDictNode = (Node)i18nDict.adaptTo(Node.class);
        if (existingEntries.size() > 0) {
            int entryCnt = existingEntries.size();
            String[] stringAndComment = new String[2];
            for (String newEntry : newEntries) {
                if (existingEntries.containsKey(newEntry)) continue;
                ++entryCnt;
                try {
                    if (I18nDictionary.disJoinStringAndComment(newEntry, stringAndComment)) {
                        bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, newEntry, stringAndComment[0]);
                        continue;
                    }
                    bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, newEntry, newEntry);
                }
                catch (RepositoryException ignored) {
                    log.error("Could not add entry:{}", (Object)newEntry);
                }
            }
        } else {
            int entryCnt = 0;
            String[] stringAndComment = new String[2];
            for (String newEntry : newEntries) {
                ++entryCnt;
                try {
                    if (I18nDictionary.disJoinStringAndComment(newEntry, stringAndComment)) {
                        bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, newEntry, stringAndComment[0]);
                        continue;
                    }
                    bSave = I18nDictionary.addI18nJcrEntry(destDictNode, "entry_" + entryCnt, newEntry, newEntry);
                }
                catch (RepositoryException ignored) {
                    log.error("Could not add entry:{}", (Object)newEntry);
                }
            }
        }
        return bSave;
    }

    private static boolean addI18nJcrEntry(Node destDictNode, String name, String key, String value) throws RepositoryException {
        String nodeName = JcrUtil.createValidChildName((Node)destDictNode, (String)name);
        Node newEntry = destDictNode.addNode(nodeName, "nt:folder");
        if (newEntry != null) {
            log.trace("Creating I18n JCR entry at {}", (Object)newEntry.getPath());
            newEntry.addMixin("sling:Message");
            newEntry.setProperty("sling:key", key);
            newEntry.setProperty("sling:message", value);
            return true;
        }
        return false;
    }

    private static boolean disJoinStringAndComment(String srcString, String[] stringAndComment) {
        int commentStartIndex = srcString.indexOf(COMMENT_START_IDENTIFIER);
        int commentEndIndex = srcString.indexOf(COMMENT_END_IDENTIFIER);
        if (commentStartIndex >= 0 && commentEndIndex >= 0) {
            stringAndComment[1] = srcString.substring(commentStartIndex + COMMENT_START_IDENTIFIER.length(), commentEndIndex);
            stringAndComment[0] = srcString.substring(0, commentStartIndex);
            return true;
        }
        return false;
    }

    public static Resource getOrCreateLanguageCopyParentResource(Resource dictResource) throws PersistenceException {
        Resource parentResource = dictResource.getParent();
        String parentPath = parentResource.getPath();
        if (!parentPath.startsWith("/apps/") && !parentPath.startsWith("/content/")) {
            String relativePath = parentPath.substring(parentPath.substring(1).indexOf(47) + 2);
            parentPath = "/apps/" + relativePath;
            parentResource = ResourceUtil.getOrCreateResource((ResourceResolver)dictResource.getResourceResolver(), (String)parentPath, (String)"sling:Folder", (String)"sling:Folder", (boolean)false);
        }
        return parentResource;
    }

    public static Resource getOrCreateLanguageCopy(ResourceResolver resourceResolver, String strSrcDictPath, String targetLanguage) {
        Resource srcDictResource = resourceResolver.resolve(strSrcDictPath);
        try {
            Resource parentResource = I18nDictionary.getOrCreateLanguageCopyParentResource(srcDictResource);
            Resource languageCopyResource = null;
            if (parentResource != null) {
                String srcBaseName = TranslationUtils.getAttribute(srcDictResource, "sling:basename", String.class);
                boolean isJson = TranslationUtils.checkFileExtension((Node)srcDictResource.adaptTo(Node.class), ".json");
                languageCopyResource = I18nDictionary.getOrCreateI18nDictionaryResource(resourceResolver, parentResource.getPath(), targetLanguage, srcBaseName, isJson);
                I18nDictionary.copyDictionaryEntries(srcDictResource, languageCopyResource);
            }
            return languageCopyResource;
        }
        catch (PersistenceException e) {
            return null;
        }
    }

    public static void copyDictionaryEntries(Resource srcDictionary, Resource destDictionary) {
        HashMap<String, String> i18nEntryMap = new HashMap<String, String>();
        I18nDictionary.getAllEntriesFromDict(srcDictionary, i18nEntryMap);
        I18nDictionary.addEntriesToDict(destDictionary, i18nEntryMap);
    }
}