Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.aemds.bedrock.CoreConfigService
 *  com.adobe.colorprofile.CSFInfo
 *  com.adobe.colorprofile.ColorProfileService
 *  com.adobe.colorprofile.ColorProfileServiceHelper
 *  com.adobe.colorprofile.ProfilesInfo
 *  com.adobe.granite.crypto.CryptoException
 *  com.adobe.granite.crypto.CryptoSupport
 *  com.adobe.pdfg.common.AESProperties
 *  com.adobe.pdfg.common.FileUtilities
 *  com.adobe.pdfg.common.StreamGobbler
 *  com.adobe.pdfg.common.Utils
 *  com.adobe.pdfg.config.PDFGConfigUtility
 *  com.adobe.pdfg.exception.ConfigException
 *  com.adobe.pdfg.exception.ConversionException
 *  com.adobe.pdfg.exception.ErrorCode
 *  com.adobe.pdfg.exception.PDFGBaseException
 *  com.adobe.pdfg.logging.PDFGLogger
 *  com.adobe.pdfg.service.api.PDFGConfigService
 *  com.adobe.ps2pdf.FontsInFolder
 *  com.adobe.ps2pdf.PsToPdfFontPaths
 *  com.adobe.ps2pdf.PsToPdfService
 *  com.adobe.ps2pdf.PsToPdfServiceHelper
 *  com.adobe.service.ConnectionFactory
 *  com.day.cq.dam.handler.gibson.fontmanager.FontManagerService
 *  javax.transaction.TransactionManager
 *  org.apache.commons.io.FileUtils
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Deactivate
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.sling.jcr.api.SlingRepository
 *  org.osgi.framework.BundleContext
 *  org.osgi.framework.ServiceRegistration
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.pdfg.impl;

import com.adobe.aemds.bedrock.CoreConfigService;
import com.adobe.colorprofile.CSFInfo;
import com.adobe.colorprofile.ColorProfileService;
import com.adobe.colorprofile.ColorProfileServiceHelper;
import com.adobe.colorprofile.ProfilesInfo;
import com.adobe.granite.crypto.CryptoException;
import com.adobe.granite.crypto.CryptoSupport;
import com.adobe.pdfg.common.AESProperties;
import com.adobe.pdfg.common.FileUtilities;
import com.adobe.pdfg.common.StreamGobbler;
import com.adobe.pdfg.common.Utils;
import com.adobe.pdfg.config.PDFGConfigUtility;
import com.adobe.pdfg.exception.ConfigException;
import com.adobe.pdfg.exception.ConversionException;
import com.adobe.pdfg.exception.ErrorCode;
import com.adobe.pdfg.exception.PDFGBaseException;
import com.adobe.pdfg.impl.CleanUpAcrFilesTask;
import com.adobe.pdfg.impl.CleanupTask;
import com.adobe.pdfg.logging.PDFGLogger;
import com.adobe.pdfg.service.api.PDFGConfigService;
import com.adobe.pdfg.transaction.TransactionCallback;
import com.adobe.pdfg.transaction.TransactionTemplate;
import com.adobe.ps2pdf.FontsInFolder;
import com.adobe.ps2pdf.PsToPdfFontPaths;
import com.adobe.ps2pdf.PsToPdfService;
import com.adobe.ps2pdf.PsToPdfServiceHelper;
import com.adobe.service.ConnectionFactory;
import com.day.cq.dam.handler.gibson.fontmanager.FontManagerService;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import javax.transaction.TransactionManager;
import org.apache.commons.io.FileUtils;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.jcr.api.SlingRepository;
import org.omg.CORBA.Object;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
 * This class specifies class file version 49.0 but uses Java 6 signatures.  Assumed Java 6.
 */
@Component(metatype=1, immediate=0, label="%pdfg.config.name", description="%pdfg.config.description")
@Service
public class PDFGConfigServiceImpl
implements PDFGConfigService {
    private static final PDFGLogger log = PDFGLogger.getPDFGLogger(PDFGConfigServiceImpl.class);
    private static final String osName = System.getProperty("os.name").toLowerCase();
    private static final String PDFG_JOB_OPTIONS_DIR = "pdfg_jo_dir";
    private static final String PDFG_PS_STARTUP_DIR = "pdfg_ps_dir";
    private static final String PDFG_PS_STARTUP_FILE = "pdfg_ps_file";
    private static final String PDFG_CONVERSION_TIMEOUT = "pdfg_conv_timeout";
    private static final String PDFG_GLOBAL_TIMEOUT = "pdfg_global_timeout";
    private static final String PDFG_JOB_OPTIONS_PREFIX = "pdfg_jo_prefix";
    private static final String PDFG_NON_UNICODE_APPS = "pdfg_non_unicode_apps";
    private static final String PDFG_CLEANUP_SCAN_SECONDS = "pdfg_cleanup_scan";
    private static final String PDFG_JOB_EXPIRATION_SECONDS = "pdfg_job_expiration";
    private static final String PDFG_DEFAULT_LOCALE = "pdfg_def_locale";
    private static PDFGConfigUtility ch = null;
    private static List<List<String>> listOfCSFAndEmbeddedProfiles = null;
    private static List<List<String>> listOfColorProfiles = null;
    private static String ContentMSODir = "Content.MSO";
    private static String ContentWordDir = "Content.Word";
    private static String CacheRegKey = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\Cache";
    private Logger logger;
    private CleanUpAcrFilesTask acrobatFilesCleanUpTask;
    @Reference
    private FontManagerService fontManager;
    @Reference(target="(bmc.service.name=PsToPdfSvc)")
    private ConnectionFactory psToPdfSvc;
    @Reference(target="(bmc.service.name=ColorProfileSvc)")
    private ConnectionFactory colorProfileSvc;
    @Reference
    private CryptoSupport cryptoSupport;
    @Reference
    private SlingRepository repository;
    @Reference
    private CoreConfigService coreConfigService;
    @Reference
    private TransactionManager transactionManager;
    private boolean credentialsValidated;
    private String pdfgTempDirPath;
    private BundleContext bundleContext;
    private List<ServiceRegistration> services;
    private Map configSettingsMap;

    public PDFGConfigServiceImpl() {
        this.logger = LoggerFactory.getLogger(this.getClass());
        this.acrobatFilesCleanUpTask = null;
        this.services = new ArrayList<ServiceRegistration>();
        this.configSettingsMap = new HashMap();
    }

    @Activate
    private void activate(BundleContext ctx, Map<String, java.lang.Object> config) throws ConfigException, CryptoException, IOException {
        this.bundleContext = ctx;
        this.initConfig(true);
    }

    @Deactivate
    private void deactivate() {
        this.unregisterJobs();
    }

    private void unregisterJobs() {
        for (ServiceRegistration sr : this.services) {
            if (sr == null) continue;
            sr.unregister();
        }
    }

    private void initConfig(boolean activating) throws ConfigException, CryptoException, IOException {
        ch = PDFGConfigUtility.getInstance((SlingRepository)this.repository, (CryptoSupport)this.cryptoSupport);
        String locale = ((String[])ch.getGeneralConfigMap().get("pdfg_def_locale"))[0];
        String userJobOptionsDir = ((String[])ch.getGeneralConfigMap().get("pdfg_jo_dir"))[0];
        String psStartupDir = ((String[])ch.getGeneralConfigMap().get("pdfg_ps_dir"))[0];
        String psStartupFile = ((String[])ch.getGeneralConfigMap().get("pdfg_ps_file"))[0];
        String jobOptionsPrefix = ((String[])ch.getGeneralConfigMap().get("pdfg_jo_prefix"))[0];
        String nonunicodeApps = ((String[])ch.getGeneralConfigMap().get("pdfg_non_unicode_apps"))[0];
        String cleanupScanSeconds = ((String[])ch.getGeneralConfigMap().get("pdfg_cleanup_scan"))[0];
        String jobExpirationSeconds = ((String[])ch.getGeneralConfigMap().get("pdfg_job_expiration"))[0];
        String conversionTimeout = ((String[])ch.getGeneralConfigMap().get("pdfg_conv_timeout"))[0];
        String globalTimeout = ((String[])ch.getGeneralConfigMap().get("pdfg_global_timeout"))[0];
        this.setDefaultLocale(locale);
        this.setUserJobOptionsDir(userJobOptionsDir);
        this.setPsStartupDir(psStartupDir);
        this.setPsStartupFile(psStartupFile);
        this.setJobOptionsPrefix(jobOptionsPrefix);
        this.setNonunicodeApps(nonunicodeApps);
        this.setCleanupScanSeconds(cleanupScanSeconds);
        this.setJobExpirationSeconds(jobExpirationSeconds);
        this.setConversionTimeout(conversionTimeout);
        this.setGlobalTimeout(globalTimeout);
        AESProperties.initialize((Map)this.configSettingsMap);
        if (activating) {
            this.createTempDirectory();
        } else {
            this.unregisterJobs();
            this.services.clear();
        }
        this.acrobatFilesCleanUpTask = new CleanUpAcrFilesTask();
        this.acrobatFilesCleanUpTask.populateUsersSet(ch.getUserAccounts());
        this.services.add(this.scheduleJob(this.acrobatFilesCleanUpTask, Long.parseLong(cleanupScanSeconds)));
        this.services.add(this.scheduleJob(new CleanupTask(this), Long.parseLong(cleanupScanSeconds)));
    }

    private ServiceRegistration scheduleJob(Runnable r, long periodInSeconds) {
        String[] interfaces = new String[]{Runnable.class.getName()};
        Hashtable<String, Comparable> properties = new Hashtable<String, Comparable>();
        properties.put("scheduler.concurrent", Boolean.FALSE);
        properties.put("scheduler.period", (Long)periodInSeconds);
        return this.bundleContext.registerService(interfaces, (java.lang.Object)r, properties);
    }

    public Map getJobOptionsMap() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getJobOptionsMap()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getJobOptionsMap();
    }

    public Map getSecuritySettingsMap() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getSecuritySettingsMap()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getSecuritySettingsMap();
    }

    public Map getFiletypeSettingsMap() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getFiletypeSettingsMap()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getFiletypeSettingsMap();
    }

    public String getClearText(String enc) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getClearText()");
            }
            return ch.getClearText(enc);
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
    }

    public Map getJobOptionMapByName(String jname) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getJobOptionMapByName()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getJobOptionsMapByName(jname);
    }

    public String getJobOptionStringByName(String jname) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getJobOptionStringByName()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getJobOptionsStringByName(jname);
    }

    public Map getSecuritySettingByName(String sname) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getSecuritySettingByName()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getSecuritySettingMapByName(sname);
    }

    public Map getFiletypeSettingByName(String fsname) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getFiletypeSettingByName()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getFiletypeSettingMapByName(fsname);
    }

    public String getConfigurationXML() throws ConfigException {
        return ch.getDefaultConfigurationXML();
    }

    public String getConfigurationXML(String sName, String jName, String fName) throws ConfigException {
        return ch.getNamedConfigurationXML(sName, jName, fName);
    }

    public String getPDFExportXML(String exportFormat, int timeout) throws ConfigException, ConversionException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getPDFExportXML()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getPDFExportXML(exportFormat, timeout);
    }

    public String getActionTaggedXML(String sName, String jName, String fName, int timeout, boolean skipValidation) throws ConfigException, ConversionException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getActionTaggedXML()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getActionTaggedXML(sName, jName, fName, timeout, skipValidation);
    }

    public Map getDefaultSettingsNames() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getDefaultSettingsNames()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getDefaultSettingsNames();
    }

    public Map getPDFGProductInfo() throws ConfigException {
        this.loadConfig(ch);
        return ch.getPDFGProductInfo();
    }

    public Map getPrologue() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getPrologue()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        return ch.getPrologue();
    }

    public List getFontFolders() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getFontFolders()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        try {
            PsToPdfFontPaths fontPaths = this.retrievePsToPdfFontPaths();
            LinkedList<String> folders = new LinkedList<String>();
            if (!"".equals(fontPaths.customerFontPath)) {
                folders.add(fontPaths.customerFontPath);
            }
            if (!"".equals(fontPaths.systemFontPath)) {
                StringTokenizer tokenizer = new StringTokenizer(fontPaths.systemFontPath, ";");
                while (tokenizer.hasMoreTokens()) {
                    String sysFont = tokenizer.nextToken();
                    if ("".equals(sysFont.trim())) continue;
                    folders.add(sysFont);
                }
            }
            if (!"".equals(fontPaths.adobeFontPath)) {
                folders.add(fontPaths.adobeFontPath);
            }
            return folders;
        }
        catch (Exception e) {
            throw new ConfigException((Throwable)e);
        }
    }

    public boolean validateUserCredentials(String userName, String domainName, String password) throws ConfigException {
        boolean result;
        block16 : {
            if (userName == null) {
                return false;
            }
            if ("".equals(userName = userName.trim())) {
                return false;
            }
            if (osName.contains("windows")) {
                if (password != null) {
                    password = password.trim();
                }
                if (domainName == null) {
                    domainName = "";
                    int indexOfForwardSlash = (userName = userName.replaceAll("\\\\", "/")).indexOf("/");
                    if (indexOfForwardSlash != -1) {
                        String usrName = userName.substring(indexOfForwardSlash + 1);
                        domainName = userName.substring(0, indexOfForwardSlash);
                        userName = usrName;
                        if ("".equals(userName) || "".equals(domainName)) {
                            return false;
                        }
                    }
                }
                try {
                    final String finalUserName = userName;
                    final String finalDomainName = domainName;
                    final String finalPassword = password;
                    boolean isValidUser = (Boolean)this.getTransactionTemplate().execute(new TransactionCallback<Boolean>(){

                        @Override
                        public Boolean doInTransaction() {
                            try {
                                return PDFGConfigServiceImpl.this.getColorProfileService().validateUserCredentials(finalUserName, finalDomainName, finalPassword);
                            }
                            catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }
                    });
                    if (!isValidUser) {
                        this.logger.warn("User credentials not found to be valid for user {}", (java.lang.Object)userName);
                    }
                    return isValidUser;
                }
                catch (Exception e) {
                    throw new ConfigException((Throwable)e);
                }
            }
            result = false;
            try {
                int retValue = this.runCmd(new String[]{"sudo", "-u", userName, "id"});
                if (0 == retValue) {
                    result = true;
                    break block16;
                }
                if (-1 != retValue) break block16;
                if (!osName.contains("sunos")) {
                    throw new ConfigException(80030, (java.lang.Object)"PDFGConfigService:validateUserCredentials");
                }
                File sudoLoc = new File("/opt/sfw/bin/sudo");
                if (sudoLoc.exists()) {
                    if (0 == this.runCmd(new String[]{"/opt/sfw/bin/sudo", "-u", userName, "id"})) {
                        result = true;
                    }
                    break block16;
                }
                throw new ConfigException(80030, (java.lang.Object)"PDFGConfigService:validateUserCredentials");
            }
            catch (Exception exc) {
                throw new ConfigException((Throwable)exc);
            }
        }
        return result;
    }

    private int runCmd(String[] cmd) {
        Process proc;
        int retVal;
        try {
            proc = Runtime.getRuntime().exec(cmd);
        }
        catch (IOException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            return -1;
        }
        try {
            proc.getOutputStream().close();
        }
        catch (IOException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
        }
        String cmdLine = Utils.unsplit((String[])cmd);
        StreamGobbler errorGobbler = new StreamGobbler("error stream consumer for cmd: " + cmdLine, proc.getErrorStream(), (OutputStream)System.err);
        errorGobbler.start();
        StreamGobbler outputGobbler = new StreamGobbler("output stream consumer for cmd: " + cmdLine, proc.getInputStream(), (OutputStream)System.out);
        outputGobbler.start();
        do {
            try {
                retVal = proc.waitFor();
                break;
            }
            catch (InterruptedException e) {
                log.trace(e.getMessage(), null, (Throwable)e);
                continue;
            }
            break;
        } while (true);
        errorGobbler.collectThread();
        outputGobbler.collectThread();
        return retVal;
    }

    public Map getAllValidUsersAccounts() throws ConfigException {
        HashMap<String, String> result = null;
        Map<String, String> userAccountsMap = this.getUserAccountsMap();
        if (this.credentialsValidated) {
            return userAccountsMap;
        }
        if (userAccountsMap != null) {
            result = new HashMap<String, String>();
            Set<String> userKeySet = userAccountsMap.keySet();
            if (userKeySet != null) {
                for (String userName : userKeySet) {
                    String password;
                    if (!this.validateUserCredentials(userName, null, password = userAccountsMap.get(userName))) continue;
                    result.put(userName, password);
                }
            }
        }
        return result;
    }

    public Map validateAllUsersCredentials() throws ConfigException {
        HashMap<String, Boolean> result = null;
        Map<String, String> userAccountsMap = this.getUserAccountsMap();
        boolean allUsersValid = true;
        if (userAccountsMap != null) {
            result = new HashMap<String, Boolean>();
            Set<String> userKeySet = userAccountsMap.keySet();
            if (userKeySet != null) {
                for (String userName : userKeySet) {
                    String password;
                    boolean isValid = this.validateUserCredentials(userName, null, password = userAccountsMap.get(userName));
                    if (!isValid) {
                        allUsersValid = false;
                    }
                    result.put(userName, isValid);
                }
            }
        }
        this.credentialsValidated = allUsersValid;
        return result;
    }

    public List<List<String>> getCSFAndEmbeddedProfiles(String noneLocalized) throws ConfigException {
        try {
            if (listOfCSFAndEmbeddedProfiles != null) {
                return listOfCSFAndEmbeddedProfiles;
            }
            CSFInfo[] info = (CSFInfo[])this.getTransactionTemplate().execute(new TransactionCallback<CSFInfo[]>(){

                @Override
                public CSFInfo[] doInTransaction() {
                    try {
                        return PDFGConfigServiceImpl.this.getColorProfileService().getCSFAndEmbeddedProfiles();
                    }
                    catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            listOfCSFAndEmbeddedProfiles = new ArrayList<List<String>>();
            ArrayList<String> listOfSettingNames = new ArrayList<String>();
            ArrayList<String> listOfProfileNames = new ArrayList<String>();
            listOfSettingNames.add(noneLocalized);
            for (CSFInfo csinfo : info) {
                if ("null".equalsIgnoreCase(csinfo.fileName)) continue;
                listOfSettingNames.add(csinfo.fileName);
                listOfProfileNames.add(csinfo.embeddedGRAYProfileName);
                listOfProfileNames.add(csinfo.embeddedRGBProfileName);
                listOfProfileNames.add(csinfo.embeddedCMYKProfileName);
            }
            listOfCSFAndEmbeddedProfiles.add(listOfSettingNames);
            listOfCSFAndEmbeddedProfiles.add(listOfProfileNames);
            return listOfCSFAndEmbeddedProfiles;
        }
        catch (Exception e) {
            throw new ConfigException((Throwable)e);
        }
    }

    public List<List<String>> getColorProfiles() throws ConfigException {
        try {
            if (listOfColorProfiles != null) {
                return listOfColorProfiles;
            }
            final String profilesDir = this.getPs2PdfService().getColorProfilesDirectory();
            File file = new File(profilesDir);
            final String[] allNames = file.list();
            ProfilesInfo[] info = (ProfilesInfo[])this.getTransactionTemplate().execute(new TransactionCallback<ProfilesInfo[]>(){

                @Override
                public ProfilesInfo[] doInTransaction() {
                    try {
                        return PDFGConfigServiceImpl.this.getColorProfileService().getColorProfiles(allNames, profilesDir);
                    }
                    catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            listOfColorProfiles = new ArrayList<List<String>>();
            ArrayList<String> grayList = new ArrayList<String>();
            ArrayList<String> rgbList = new ArrayList<String>();
            ArrayList<String> cmykList = new ArrayList<String>();
            int counter = -1;
            for (ProfilesInfo profileInfo : info) {
                ++counter;
                if ("1".equalsIgnoreCase(profileInfo.type)) {
                    grayList.add(profileInfo.name);
                    continue;
                }
                if ("2".equalsIgnoreCase(profileInfo.type)) {
                    rgbList.add(profileInfo.name);
                    continue;
                }
                if (!"3".equalsIgnoreCase(profileInfo.type)) continue;
                cmykList.add(profileInfo.name);
            }
            listOfColorProfiles.add(grayList);
            listOfColorProfiles.add(rgbList);
            listOfColorProfiles.add(cmykList);
            return listOfColorProfiles;
        }
        catch (Exception e) {
            throw new ConfigException((Throwable)e);
        }
    }

    public List getFontsInFolder(String folderPath) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getFontsInFolder()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        try {
            PsToPdfFontPaths fontPaths = this.retrievePsToPdfFontPaths();
            FontsInFolder[] fontsInFolder = this.getPs2PdfService().getFontsInFolder(fontPaths, folderPath);
            List<String> baseFonts = Arrays.asList(fontsInFolder[0].fontNames);
            List<String> folderFonts = Arrays.asList(fontsInFolder[1].fontNames);
            TreeSet<String> fontSet = new TreeSet<String>();
            fontSet.addAll(folderFonts);
            fontSet.removeAll(baseFonts);
            ArrayList<String> fontsList = new ArrayList<String>();
            for (String fontName : fontSet) {
                int startIndex = fontName.indexOf(40);
                int endIndex = fontName.lastIndexOf(41);
                fontsList.add(fontName.substring(startIndex + 1, endIndex));
            }
            return fontsList;
        }
        catch (Exception e) {
            throw new ConfigException((Throwable)e);
        }
    }

    public void setPrologue(Map pmap) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.setPrologue()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        ch.setPrologue(pmap);
    }

    public void updateJobOptions(Map jobOptionsMap, boolean createNew) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateJobOptions()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.updateJobOptionSettings(jobOptionsMap, createNew);
        this.storeConfig(ch);
    }

    public void setJobOptionsByName(String jobName, String jobOptionData) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.setJobOptionsByName()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.setJobOptionsByName(jobName, jobOptionData);
        this.storeConfig(ch);
    }

    public void updateSecuritySetting(String settingName, String openPassword, String permPassword) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateSecuritySettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.updateSecuritySetting(settingName, openPassword, permPassword);
        this.storeConfig(ch);
    }

    public void updateSecuritySettings(Map ssMap, boolean createNew) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateSecuritySettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.updateSecuritySettings(ssMap, createNew);
        this.storeConfig(ch);
    }

    public void updateUserAccountsSettings(Map userInfoMap, boolean createNew) throws ConfigException {
        String newPsswd;
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateSecuritySettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        String newUsrName = (String)userInfoMap.get("username");
        boolean isValidCred = this.validateUserCredentials(newUsrName, null, newPsswd = (String)userInfoMap.get("password"));
        if (!isValidCred) {
            String machineDetail = "";
            try {
                InetAddress localhost = InetAddress.getLocalHost();
                machineDetail = localhost.getHostName() + " (" + localhost.getHostAddress() + ")";
            }
            catch (UnknownHostException e) {
                log.trace(e.getMessage(), null, (Throwable)e);
            }
            throw new ConfigException(ErrorCode.INVALID_USER_CRED, (java.lang.Object)newUsrName, (java.lang.Object)machineDetail);
        }
        ch.updateUserAccount(newUsrName, newPsswd, createNew);
        if (!this.acrobatFilesCleanUpTask.addUser(newUsrName)) {
            log.debug("Could not add user " + newUsrName + " to the users set maintained by CleanUpAcrFilesTask");
        }
    }

    public Map<String, String> getUserAccountsMap() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateSecuritySettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        return ch.getUserAccounts();
    }

    public Map<String, String[]> getGeneralConfigMap() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.getGeneralConfigMap()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        return ch.getGeneralConfigMap();
    }

    public void updateGeneralConfig(Map<String, String[]> generalConfig) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedUser()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateGeneralConfig()");
            }
            ch.updateGeneralConfig(generalConfig);
            this.initConfig(false);
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
    }

    public void removeUserAccounts(List users) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.removeUserAccounts()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        ListIterator liter = users.listIterator();
        while (liter.hasNext()) {
            String userName = (String)liter.next();
            ch.removeUserAccount(userName);
            if (this.acrobatFilesCleanUpTask.removeUser(userName)) continue;
            log.debug("Could not remove user " + userName + " from the users set maintained by CleanUpAcrFilesTask");
        }
    }

    public Map getIPPSettings(Map ippMap, boolean createNew) throws ConfigException {
        return null;
    }

    public void updateIPPSettings(Map ippMap, boolean createNew) throws Exception {
    }

    private static void checkIPPProcessConfig(String serviceName, String OperationName, String inParamName) throws Exception {
    }

    public void updateFiletypeSettings(Map fsMap, boolean createNew) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.updateFiletypeSettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.updateFiletypeSettings(fsMap, createNew);
        this.storeConfig(ch);
    }

    public void removeSecuritySettings(List secSettNames) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.removeSecuritySettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ListIterator liter = secSettNames.listIterator();
        while (liter.hasNext()) {
            ch.removeSecuritySettings((String)liter.next());
        }
        this.storeConfig(ch);
    }

    public void removeFiletypeSettings(List fnames) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.removeFiletypeSettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ListIterator liter = fnames.listIterator();
        while (liter.hasNext()) {
            ch.removeFiletypeSettings((String)liter.next());
        }
        this.storeConfig(ch);
    }

    public void removeJobOptionSettings(List jobOptNames) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.removeJobOptionSettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ListIterator liter = jobOptNames.listIterator();
        while (liter.hasNext()) {
            ch.removeJobOptionSettings((String)liter.next());
        }
        this.storeConfig(ch);
    }

    public void setDefaultSettings(String sname, String jname, String aname) throws ConfigException, ConversionException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.setDefaultSettings()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        this.loadConfig(ch);
        ch.setDefaultSettings(sname, jname, aname);
        this.storeConfig(ch);
    }

    public void importConfigurationXML(String configXML) throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.importConfigurationXML()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        ch.importConfigurationXML(configXML, (PDFGConfigService)this);
        this.storeConfig(ch);
    }

    public void resetConfigurationToDefault() throws ConfigException {
        try {
            if (!Utils.isCallerAuthorizedAdmin()) {
                throw new ConfigException(80015, (java.lang.Object)"PDFGConfigService.resetConfigurationToDefault()");
            }
        }
        catch (ConfigException e) {
            throw e;
        }
        catch (PDFGBaseException e) {
            log.trace(e.getMessage(), null, (Throwable)e);
            throw new ConfigException(e.getErrorCode());
        }
        catch (Exception e) {
            throw new ConfigException(1000, (Throwable)e);
        }
        ch.resetConfiguration();
        this.storeConfig(ch);
    }

    private PsToPdfService getPs2PdfService() throws Exception {
        ConnectionFactory psToPdfFactory = this.psToPdfSvc;
        psToPdfFactory.setServiceTimeout((long)AESProperties.getGlobalTimeout());
        Object psToPdfObject = (Object)psToPdfFactory.getConnection();
        PsToPdfService psToPdfService = PsToPdfServiceHelper.narrow((Object)psToPdfObject);
        return psToPdfService;
    }

    private ColorProfileService getColorProfileService() throws Exception {
        ConnectionFactory colorProfileFactory = this.colorProfileSvc;
        colorProfileFactory.setServiceTimeout((long)AESProperties.getGlobalTimeout());
        Object colorProfileObject = (Object)colorProfileFactory.getConnection();
        ColorProfileService colorProfileService = ColorProfileServiceHelper.narrow((Object)colorProfileObject);
        return colorProfileService;
    }

    public void loadConfig(PDFGConfigUtility ch) throws ConfigException {
        log.info("Loading the configuration");
        ch.loadConfig();
    }

    public void storeConfig(PDFGConfigUtility ch) throws ConfigException {
        log.info("Storing the configuration");
        ch.storeConfig();
    }

    private PsToPdfFontPaths retrievePsToPdfFontPaths() {
        PsToPdfFontPaths fontPaths = new PsToPdfFontPaths();
        fontPaths.customerFontPath = this.getNormalizerFontPath(this.fontManager.getCustomerFontDirectory());
        fontPaths.systemFontPath = this.getNormalizerFontPath(this.fontManager.getSystemFontDirectory());
        fontPaths.adobeFontPath = this.getNormalizerFontPath(this.fontManager.getAdobeServerFontDirectory());
        return fontPaths;
    }

    private String getNormalizerFontPath(String path) {
        String fileSeparator = System.getProperty("file.separator");
        String modifiedPath = "";
        if (path != null && !"".equals(path)) {
            modifiedPath = !path.endsWith(fileSeparator) ? path + fileSeparator : path;
        }
        return modifiedPath;
    }

    public Map getConfigurationSettingsMap() {
        return this.configSettingsMap;
    }

    public String getConfigurationSetting(String key) {
        return (String)this.configSettingsMap.get(key);
    }

    public void setCleanupScanSeconds(String cleanupScanSeconds) {
        this.putProperty("server.pdfg.cleanup.scan.seconds", cleanupScanSeconds);
    }

    public void setConversionTimeout(String conversionTimeout) {
        this.putProperty("server.conversion.timeout", conversionTimeout);
    }

    public void setGlobalTimeout(String globalTimeout) {
        this.putProperty("server.global.timeout", globalTimeout);
    }

    public void setJobExpirationSeconds(String jobExpirationSeconds) {
        this.putProperty("server.pdfg.job.expiration.seconds", jobExpirationSeconds);
    }

    public void setJobOptionsPrefix(String jobOptionsPrefix) {
        this.putProperty("server.acrobat.job.options.prefix", jobOptionsPrefix);
    }

    public void setNonunicodeApps(String nonunicodeApps) {
        this.putProperty("server.pdfg.nonunicode.apps", nonunicodeApps);
    }

    public void setPsStartupDir(String psStartupDir) {
        String appData = System.getenv("APPDATA");
        String newValue = psStartupDir;
        if (psStartupDir != null && appData != null) {
            newValue = psStartupDir.replace("[app.data]", appData);
        }
        this.putProperty("server.acrobat.ps.startup.dir", newValue);
    }

    public void setPsStartupFile(String psStartupFile) {
        this.putProperty("server.acrobat.ps.startup.file", psStartupFile);
    }

    public void setDefaultLocale(String locale) {
        if (locale == null || "".equals(locale.trim())) {
            Locale defaultLocale = Locale.getDefault();
            String localeSet = defaultLocale.getLanguage();
            locale = localeSet.equalsIgnoreCase("en") || localeSet.equalsIgnoreCase("fr") || localeSet.equalsIgnoreCase("de") || localeSet.equalsIgnoreCase("ja") ? localeSet : "en";
        }
        this.putProperty("server.locale", locale.toLowerCase());
    }

    public void setUserJobOptionsDir(String userJobOptionsDir) {
        String appData = System.getenv("APPDATA");
        String newValue = userJobOptionsDir;
        if (userJobOptionsDir != null && appData != null) {
            newValue = userJobOptionsDir.replace("[app.data]", appData);
        }
        this.putProperty("server.acrobat.user.job.options.dir", newValue);
    }

    private void putProperty(String key, String value) {
        this.configSettingsMap.put(key, value);
    }

    public Map<String, Map> getAllSettingsMapWithDefault() throws ConfigException {
        Map allFiletypeSettings = this.getFiletypeSettingsMap();
        Map allPdfSettings = this.getJobOptionsMap();
        Map allSecuritySettings = this.getSecuritySettingsMap();
        HashMap<String, Map> allSettingsMap = new HashMap<String, Map>();
        allSettingsMap.put("fileTypeSettingsMap", allFiletypeSettings);
        allSettingsMap.put("pdfSettingsMap", allPdfSettings);
        allSettingsMap.put("securitySettingsMap", allSecuritySettings);
        return allSettingsMap;
    }

    public Map<String, List<String>> getOSAndUsers() throws ConfigException {
        Map<String, String> userMap = this.getUserAccountsMap();
        Set<String> userSet = userMap.keySet();
        ArrayList<String> returnList = new ArrayList<String>();
        returnList.addAll(userSet);
        String osName = System.getProperty("os.name");
        HashMap<String, List<String>> returnMap = new HashMap<String, List<String>>();
        returnMap.put(osName, returnList);
        return returnMap;
    }

    private void createTempDirectory() throws IOException {
        File tempDir = new File(this.coreConfigService.getServerTempDir());
        String userId = System.getProperty("user.name");
        userId = userId.replaceAll("[\\$,\\\\,\\/,\\?,\\@,\\*,\\+,\\\",\\|,\\:,\\;\\,\\=,>,<,\\[,\\]]", "_");
        File pdfgTempDir = new File(tempDir, "pdfg-" + userId);
        FileUtils.forceMkdir((File)pdfgTempDir);
        this.pdfgTempDirPath = pdfgTempDir.getAbsolutePath();
        FileUtilities.setGuidRootDir((File)pdfgTempDir);
    }

    private File getPDFGRootDir() {
        return new File(this.pdfgTempDirPath);
    }

    private List<String> getMSWordTempDirectory() {
        ArrayList<String> retVal = new ArrayList<String>();
        try {
            Set<String> userKeySet;
            Map<String, String> userAccountsMap = this.getUserAccountsMap();
            if (userAccountsMap != null && (userKeySet = userAccountsMap.keySet()) != null) {
                for (final String UserName : userKeySet) {
                    final String Password = userAccountsMap.get(UserName);
                    String defaultUserDir = (String)this.getTransactionTemplate().execute(new TransactionCallback<String>(){

                        @Override
                        public String doInTransaction() {
                            try {
                                return PDFGConfigServiceImpl.this.getColorProfileService().getRegistryKeyValue(CacheRegKey, UserName, "", Password);
                            }
                            catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }
                    });
                    log.debug("The Temporary user directory is " + defaultUserDir);
                    String MSOPath = new File(defaultUserDir, ContentMSODir).getPath();
                    String WordPath = new File(defaultUserDir, ContentWordDir).getPath();
                    retVal.add(MSOPath);
                    retVal.add(WordPath);
                }
            }
        }
        catch (Exception e) {
            log.trace(e.getMessage(), null, (Throwable)e);
        }
        return retVal;
    }

    public List<File> getPDFGTempFolders() throws ConfigException {
        ArrayList<File> listOfFolders = new ArrayList<File>();
        listOfFolders.add(this.getPDFGRootDir());
        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
            List<String> tempDirPathList = this.getMSWordTempDirectory();
            for (String tempDirPath : tempDirPathList) {
                File dir2;
                if (tempDirPath == null || !(dir2 = new File(tempDirPath)).exists() || !dir2.isDirectory()) continue;
                listOfFolders.add(dir2);
            }
        }
        return listOfFolders;
    }

    private TransactionTemplate getTransactionTemplate() {
        return new TransactionTemplate(this.transactionManager);
    }

    protected void bindFontManager(FontManagerService fontManagerService) {
        this.fontManager = fontManagerService;
    }

    protected void unbindFontManager(FontManagerService fontManagerService) {
        if (this.fontManager == fontManagerService) {
            this.fontManager = null;
        }
    }

    protected void bindPsToPdfSvc(ConnectionFactory connectionFactory) {
        this.psToPdfSvc = connectionFactory;
    }

    protected void unbindPsToPdfSvc(ConnectionFactory connectionFactory) {
        if (this.psToPdfSvc == connectionFactory) {
            this.psToPdfSvc = null;
        }
    }

    protected void bindColorProfileSvc(ConnectionFactory connectionFactory) {
        this.colorProfileSvc = connectionFactory;
    }

    protected void unbindColorProfileSvc(ConnectionFactory connectionFactory) {
        if (this.colorProfileSvc == connectionFactory) {
            this.colorProfileSvc = null;
        }
    }

    protected void bindCryptoSupport(CryptoSupport cryptoSupport) {
        this.cryptoSupport = cryptoSupport;
    }

    protected void unbindCryptoSupport(CryptoSupport cryptoSupport) {
        if (this.cryptoSupport == cryptoSupport) {
            this.cryptoSupport = null;
        }
    }

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

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

    protected void bindCoreConfigService(CoreConfigService coreConfigService) {
        this.coreConfigService = coreConfigService;
    }

    protected void unbindCoreConfigService(CoreConfigService coreConfigService) {
        if (this.coreConfigService == coreConfigService) {
            this.coreConfigService = null;
        }
    }

    protected void bindTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    protected void unbindTransactionManager(TransactionManager transactionManager) {
        if (this.transactionManager == transactionManager) {
            this.transactionManager = null;
        }
    }

}