UserExitFileGenerator.java

package com.proalpha.pds.generator;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import javax.xml.bind.JAXBException;
 
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.LineIterator;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Display;
 
import com.proalpha.pds.paconnector.userexit.UserExitDelegate;
import com.proalpha.pds.paconnector.userexit.UserExitInclude;
import com.proalpha.pds.templates.data.IGeneratorDataContainer;
import com.proalpha.pds.templates.helper.IDEUtils;
import com.proalpha.pds.templates.jaxb.JaxUnmarshallerGeneric;
import com.proalpha.pds.templates.jaxb.TtUserExits;
import com.proalpha.pds.templates.jaxb.TtUserExits.TtUserExitsRow;
import com.proalpha.pds.templates.jet.IpaTemplateGenerator;
import com.proalpha.pds.templates.jet.JetTemplateFactory;
 
public class UserExitFileGenerator {
 
    private static final String TEMPLATE_GENERATOR = "pAUserExitIncludeFile";
 
    private List<TtUserExitsRow> definedUserExits;
 
    private final IGeneratorDataContainer dataContrainer;
 
    private final UserExitDelegate userExitDelegate;
 
    public UserExitFileGenerator(IGeneratorDataContainer dataContainer, UserExitDelegate userExitDelegate)
            throws Exception {
 
        this.dataContrainer = dataContainer;
        this.userExitDelegate = userExitDelegate;
 
        initializeGenerator();
 
    }
 
    private void initializeGenerator() throws Exception {
 
        String fileName = dataContrainer.getFileName();
        String customLevel = dataContrainer.getCustomLevel();
        String parentObject = dataContrainer.getParentObject();
        String xBaseName = calculateXBaseName(fileName, customLevel);
 
        dataContrainer.setFileName(xBaseName);
 
        String description = String.format("UserExits in %s %s %s", parentObject,
                System.getProperties().getProperty("line.separator"), dataContrainer.getObjectInfo());
 
        dataContrainer.setDescription(description);
 
        String userExitSortCase = dataContrainer.getSortCase();
        UserExitInclude userExitInclude = userExitDelegate.getEmptyUserExitInclude();
 
        userExitInclude.setName(xBaseName);
        userExitInclude.setIncludeType(customLevel + "X");
        userExitInclude.setSourceFileName(parentObject);
        userExitInclude.setSortCase(userExitSortCase);
        File userExitXMLFile = userExitDelegate.extractUserExitToXMLFile(userExitInclude);
        // check the return value of pA User Exit Generator. If empty no UE is generated
        if (!userExitXMLFile.toString().equals("")) {
            definedUserExits = readUserExitFormStandardFile(userExitXMLFile);
            dataContrainer.setUserExits(definedUserExits);
 
        } else {
            throw new JAXBException("No User Exits generated for : " + userExitInclude.getSourceFileName());
        }
 
        definedUserExits = readUserExitFormStandardFile(userExitXMLFile);
        dataContrainer.setUserExits(definedUserExits);
 
    }
 
    private String calculateXBaseName(String fileName, String customLevel) throws Exception {
 
        if (fileName.contains(".")) {
 
            return fileName.substring(0, fileName.lastIndexOf('.')) + getFileExtension(fileName, customLevel);
 
        } else {
            throw new Exception("Could not calculate XBaseName, invalid filename " + fileName);
        }
 
    }
 
    private String getFileExtension(String fileName, String customLevel) throws Exception {
        String fileExtension = "";
 
        if (fileName.endsWith(".p")) {
            fileExtension = "." + customLevel.toLowerCase() + "xp";
        } else if (fileName.endsWith(".w")) {
            fileExtension = "." + customLevel.toLowerCase() + "xw";
        } else if (fileName.endsWith(".lib")) {
            fileExtension = "." + customLevel.toLowerCase() + "xl";
        } else if (fileName.endsWith(".if") || fileName.endsWith(".i")) {
            fileExtension = "." + customLevel.toLowerCase() + "xi";
        } else if (fileName.endsWith(".tdf")) {
            fileExtension = "." + customLevel.toLowerCase() + "xt";
        } else if (fileName.endsWith(".pds")) {
            fileExtension = "." + customLevel.toLowerCase() + "xp";
        } else if (fileName.endsWith(".fld")) {
            fileExtension = "." + customLevel.toLowerCase() + "xf";
        } else if (fileName.endsWith(".cdf")) {
            fileExtension = "." + customLevel.toLowerCase() + "xc";
        }
 
        if (fileExtension.isEmpty()) {
            throw new Exception("Could not calculate file extension for file " + fileName);
        }
 
        return fileExtension;
    }
 
    private List<TtUserExitsRow> readUserExitFormStandardFile(File userExitXMLFile) throws JAXBException {
 
        if (!userExitXMLFile.exists()) {
            throw new JAXBException("No UserExits Info file from proALPHA generated");
        }
        JaxUnmarshallerGeneric<TtUserExits> jaxb = new JaxUnmarshallerGeneric<>(TtUserExits.class);
 
        TtUserExits userExits = jaxb.readXMLFile(userExitXMLFile);
 
        if (userExits == null) {
            throw new JAXBException("Error Reading XML File " + userExitXMLFile.getAbsolutePath());
        }
 
        return userExits.getTtUserExitsRow();
 
    }
 
    public void generate() throws Exception {
 
        String workdir = dataContrainer.getStarparameterReader().getWorkingDirectory().getRawLocation().toString();
 
        Path fullFilePath = Paths.get(workdir, dataContrainer.getRelativePath(), dataContrainer.getFileName());
 
        if (isUserExitIncludeNew(fullFilePath.toAbsolutePath().toString())) {
            createNewUserExitInclude();
        } else {
            refreshUserExitInclude();
 
        }
 
    }
 
    private boolean isUserExitIncludeNew(String fileName) {
        File f = new File(fileName);
        return (!f.exists() && !f.isDirectory());
    }
 
    public void generateUserExitClassAndBalpEntry() throws Exception {
 
        generate();
        GeneratorFactory generatorFactory = new GeneratorFactory();
        generatorFactory.createBalpGenerator(dataContrainer).generate();
 
    }
 
    private void refreshUserExitInclude() throws Exception {
 
        if (confirmRefresh()) {
 
            File userExitIncludeFile = dataContrainer.getOutputFile().getLocation().toFile();
            // read in old user exit
            Set<String> availableUserExits = readUserExitsFormIncludeFile(userExitIncludeFile);
 
            Set<String> oldUserExits = new TreeSet<>();
            Set<String> specialUserExits = new TreeSet<>();
 
            for (TtUserExitsRow row : definedUserExits) {
                oldUserExits.add(row.getUserExitName().toUpperCase());
                if (row.isIsSpecialUserExit()) {
                    specialUserExits.add(row.getUserExitName().toUpperCase());
                }
            }
 
            // newUserExits = definedUserExit - availableUserExits
            Set<String> newUserExits = new TreeSet<>(oldUserExits);
            newUserExits.removeAll(availableUserExits);
            newUserExits.removeAll(specialUserExits);
 
            // removedUserExits = availabelUserExits - definedUserExits
            Set<String> removedUserExits = new TreeSet<>(availableUserExits);
            removedUserExits.removeAll(oldUserExits);
 
            writeUserExitsInclude(dataContrainer.getOutputFile(), newUserExits);
 
            if (!newUserExits.isEmpty()) {
                displayMessageBox("Exits " + newUserExits.toString() + " added.");
            }
 
            if (!removedUserExits.isEmpty()) {
                displayMessageBox("Exits " + removedUserExits.toString() + " removed.");
            }
            if (newUserExits.isEmpty() && removedUserExits.isEmpty()) {
                displayMessageBox("File " + userExitIncludeFile.getName() + " \nis already up to Date.");
            }
        }
 
    }
 
    private void displayMessageBox(String message) {
        MessageDialog.openInformation(Display.getCurrent().getActiveShell(), "Refresh UserExit Include", message);
 
    }
 
    private void writeUserExitsInclude(IFile outputFile, Set<String> newUserExits) throws Exception {
 
        File includeFile = dataContrainer.getOutputFile().getLocation().toFile();
        String line = null;
        StringBuilder outputBuilder = new StringBuilder();
        Integer insertOffset = -1;
        String lineSeparator = System.getProperty("line.separator");
 
        try (BufferedReader reader = new BufferedReader(new FileReader(includeFile))) {
            while ((line = reader.readLine()) != null) {
                if (!isUserExitDefinition(line))
                    outputBuilder.append(line + lineSeparator);
                else if (insertOffset < 0)
                    insertOffset = outputBuilder.length();
            }
        }
 
        if (insertOffset > 0) {
            IpaTemplateGenerator paUserExitDefinitins = JetTemplateFactory
                    .getFactoryInstance(dataContrainer.getVersion()).getTemplate("paUserExitDefinitions");
 
            String generatetUserExits = paUserExitDefinitins.generate(dataContrainer.getDataAsMap());
 
            outputBuilder.insert(insertOffset, generatetUserExits + lineSeparator);
        }
 
        insertOffset = outputBuilder.lastIndexOf("/* _UIB-CODE-BLOCK-END */");
 
        String outputString = "";
 
        for (String newUserExit : newUserExits) {
 
            String beginDef = String.format("&IF DEFINED(%s) = 2 &THEN", newUserExit.toUpperCase()) + lineSeparator;
            String endDef = String.format("&ENDIF /* %s */", newUserExit.toUpperCase()) + lineSeparator;
 
            outputString = outputString + beginDef + lineSeparator + endDef + lineSeparator;
        }
 
        outputBuilder.insert(insertOffset, outputString);
 
        new ContentWriter(includeFile, outputBuilder.toString()).writeContentToHarddisk();
 
        IDEUtils.openFileInEditor(new NullProgressMonitor(), outputFile);
 
    }
 
    private boolean isUserExitDefinition(String line) {
 
        Pattern pattern = Pattern.compile("(?i)\\s*&GLOB \\{&PA-X.*BASISNAME\\}_.*");
 
        Matcher m = pattern.matcher(line);
 
        return (m.matches());
 
    }
 
    private Set<String> readUserExitsFormIncludeFile(File includeFile) throws IOException {
        Set<String> resultSet = new TreeSet<>();
 
        LineIterator iterator = FileUtils.lineIterator(includeFile);
        try {
 
            while (iterator.hasNext()) {
                String line = iterator.nextLine();
 
                if (isUserExitDefinition(line)) {
 
                    String tempStr = line.replaceAll("\\s*&GLOB \\{&PA-X.*BASISNAME\\}_", "");
                    String userExitName = tempStr.substring(0, tempStr.indexOf(' ')).toUpperCase();
 
                    resultSet.add(userExitName);
                }
            }
        } finally {
            LineIterator.closeQuietly(iterator);
        }
 
        return resultSet;
    }
 
    private boolean confirmRefresh() {
 
        return dataContrainer.isGenerationConfirmed();
 
    }
 
    private void createNewUserExitInclude() throws Exception {
 
        new ContentGenerator("UserExit Generator", dataContrainer, TEMPLATE_GENERATOR).schedule();
 
        IJobManager jobManager = Job.getJobManager();
        jobManager.join(ContentGenerator.JOB_FAMILY, new NullProgressMonitor());
 
    }
 
}