BalpGenerator.java

package com.proalpha.pds.generator;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.regex.Pattern;
 
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.pds.paconnector.parameter.StartparameterReader;
import com.proalpha.pds.paconnector.userexit.UserExitDelegate;
import com.proalpha.pds.templates.data.IGeneratorDataContainer;
import com.proalpha.pds.templates.helper.FileSystemUtils;
import com.proalpha.pds.templates.jaxb.JaxUnmarshallerGeneric;
import com.proalpha.pds.templates.jaxb.TtBAlpLine;
import com.proalpha.pds.templates.jaxb.TtBAlpLine.TtBAlpLineRow;
 
class BalpGenerator {
 
    private static final Logger logger = LoggerFactory.getLogger(BalpGenerator.class);
 
    private static final String CUSTOM_LEVEL_CUSTOMER = "Y";
    private static final String CUSTOM_LEVEL_PARTNER = "X";
    private static final String CUSTOM_LEVEL_COUNTRY = "C";
    private static final String CUSTOM_LEVEL_INDUSTRY = "U";
    private static final String CUSTOM_LEVEL_COMPONENT = "Q";
 
    private static final String B_ALP95_CDF = "b__alp95.cdf";
    private static final String B_ALP94_CDF = "b__alp94.cdf";
    private static final String B_ALP93_CDF = "b__alp93.cdf";
    private static final String B_ALP92_CDF = "b__alp92.cdf";
    private static final String B_ALP91_CDF = "b__alp91.cdf";
 
    private final IGeneratorDataContainer dataContainer;
    private final UserExitDelegate userExitDelegate;
    private final StartparameterReader startparameterReader;
 
    public BalpGenerator(IGeneratorDataContainer datacontainer, UserExitDelegate userExitDelegate,
            StartparameterReader startparameterReader) throws Exception {
 
        this.dataContainer = datacontainer;
        this.userExitDelegate = userExitDelegate;
        this.startparameterReader = startparameterReader;
 
        initializeGenerator();
 
    }
 
    private void readXmlBalpFile(File xmlFile) throws Exception {
 
        if (!xmlFile.exists()) {
            throw new Exception("File " + xmlFile.getAbsolutePath() + " not exits.");
        }
 
        JaxUnmarshallerGeneric<TtBAlpLine> jaxb = new JaxUnmarshallerGeneric<>(TtBAlpLine.class);
 
        TtBAlpLine lines = jaxb.readXMLFile(xmlFile);
 
        List<TtBAlpLine.TtBAlpLineRow> elementList = lines.getTtBAlpLineRow();
 
        List<String> userExitList = new ArrayList<>();
 
        List<String> balpFileHeader = new ArrayList<>();
 
        ListIterator<TtBAlpLineRow> iterator = elementList.listIterator();
 
        String line;
        Boolean isHeaderFound = Boolean.FALSE;
 
        // Fill balpTemplatesList with header rows
        while (iterator.hasNext()) {
 
            line = (iterator.next()).getContent();
 
            balpFileHeader.add(line);
 
            if (line.contains("_MAIN-BLOCK")) {
                isHeaderFound = Boolean.TRUE;
                break;
            }
        }
 
        if (!isHeaderFound) {
            MessageDialog.openInformation(Display.getCurrent().getActiveShell(),
                    xmlFile.getAbsolutePath() + " has the wrong format", xmlFile.getAbsolutePath()
                            + " file has the wrong format. The file has been regenerated. Please check the file.");
            iterator = elementList.listIterator();
            balpFileHeader.clear();
            balpFileHeader.add("&ANALYZE-SUSPEND _UIB-CODE-BLOCK _CUSTOM _MAIN-BLOCK Include");
        }
 
        // Fill userExitList with user exit definitions
        while (iterator.hasNext()) {
 
            line = (iterator.next()).getContent();
            if (isLineUserExitDefinition(line)) {
                userExitList.add(line);
            }
        }
 
        dataContainer.setUserExitFiles(userExitList);
        dataContainer.setBALPTemplateList(balpFileHeader);
 
        xmlFile.deleteOnExit();
    }
 
    private boolean isLineUserExitDefinition(String line) {
 
        Pattern patternUserExit = Pattern.compile("^&GLOB.+");
        Pattern patternInheritsClass = Pattern.compile("^&GLOB.+_INHERITS.+");
 
        return (patternUserExit.matcher(line).find() || patternInheritsClass.matcher(line).find());
 
    }
 
    private void loadBalpValues() throws Exception {
 
        String balpFile = getBAlpFile(dataContainer.getCustomLevel());
 
        File xmlFile = userExitDelegate.extractBalpFileToXMLFile(balpFile);
 
        readXmlBalpFile(xmlFile);
 
    }
 
    private String getBAlpFile(String customLevel) {
 
        switch (customLevel) {
        case CUSTOM_LEVEL_COUNTRY:
            return B_ALP91_CDF;
        case CUSTOM_LEVEL_PARTNER:
            return B_ALP92_CDF;
        case CUSTOM_LEVEL_CUSTOMER:
            return B_ALP93_CDF;
        case CUSTOM_LEVEL_INDUSTRY:
            return B_ALP94_CDF;
        case CUSTOM_LEVEL_COMPONENT:
            return B_ALP95_CDF;
        default:
            return B_ALP92_CDF;
        }
 
    }
 
    private IFile getGeneratorOutputFile() {
 
        IFile outputFile = null;
        String bAlpFile = getBAlpFile(dataContainer.getCustomLevel());
 
        try {
 
            outputFile = FileSystemUtils.createFileInWorkingDirectory(startparameterReader.getWorkingDirectory(),
                    "basis/incl", bAlpFile);
            /*
             * If the version control is inactive, the b_alp file is copied form src
             * directory and is read only.
             */
            if (outputFile.exists()) {
                ResourceAttributes resourceAttributes = new ResourceAttributes();
                resourceAttributes.setReadOnly(false);
                outputFile.setResourceAttributes(resourceAttributes);
            }
 
        } catch (Exception e) {
            MessageDialog.openInformation(PlatformUI.getWorkbench().getDisplay().getActiveShell(),
                    "Error create output file",
                    "Could not create generator output file: " + bAlpFile + "\n" + e.getMessage());
            logger.error(e.getMessage(), e);
        }
 
        return outputFile;
    }
 
    private void initializeGenerator() throws Exception {
 
        loadBalpValues();
 
        dataContainer.setOutputFile(getGeneratorOutputFile());
 
    }
 
    public void generate() throws Exception {
 
        ContentGenerator generator = new ContentGenerator("b__alp Generator", dataContainer, "pABalpxxcdf");
        generator.disableOpenFileInEditor();
        generator.schedule();
 
    }
}