WizardMainPage.java

package com.proalpha.pds.ui.wizards.wizardpages;
 
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
 
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.IDialogPage;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.dialogs.ContainerSelectionDialog;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.pds.paconnector.PaProject;
import com.proalpha.pds.paconnector.parameter.StartparameterReader;
import com.proalpha.pds.paconnector.repository.Instance;
import com.proalpha.pds.paconnector.repository.RepositoryDelegate;
import com.proalpha.pds.paconnector.repository.RepositoryInformations;
import com.proalpha.pds.templates.data.GeneratorSettingsConstans;
import com.proalpha.pds.ui.Activator;
 
public class WizardMainPage extends WizardPage implements IpaWizardPage {
 
    private static final Logger logger = LoggerFactory.getLogger(WizardMainPage.class);
 
    private PaProject paProject;
    private RepositoryDelegate repositoryDelegate;
    private RepositoryInformations repositoryInformations;
    private StartparameterReader startparameterReader;
    private CCombo programVariant;
    private Text containerText;
    private Text fileText;
    private Text relativePathText;
    private String currConfig;
    private Map<String, WizardMainPageConfiguration> configList;
    private boolean checkRepository;
    private boolean supportRepositoryCreateButton;
    private boolean checkFileNameLength;
    private boolean checkLowerCase;
    private Combo parentClassCombo;
    private String rootClass;
    private Text shortDescriptionText;
    private Text descriptionText;
    private Button buttonCreateObject;
    private Text productText;
    private Text versionText;
    private Text authorText;
    private List<String> extensionList;
    private Text productDescriptionText;
    private Text moduleDescriptionText;
    private Text moduleText;
    private String thirdDigit;
    private HashMap<String, String> classGroupCode;
    private Boolean isFileExisting = false;
 
    private static final String OO_ABL = "OOABL";
 
    public WizardMainPage(PaProject paProject, Map<String, WizardMainPageConfiguration> configs, RepositoryDelegate repositoryDelegate,
            RepositoryInformations repositoryInformations, StartparameterReader startparameterReader) {
        super("WizardMainPage");
 
        URL url = FileLocator.find(Platform.getBundle(Activator.PLUGIN_ID), new Path("icons/pA-logox72.png"),
                Collections.emptyMap());
 
        setImageDescriptor(ImageDescriptor.createFromURL(url));
 
        this.paProject = paProject;
        this.configList = configs;
        currConfig = configs.entrySet().iterator().next().getKey();
        this.repositoryDelegate = repositoryDelegate;
        this.repositoryInformations = repositoryInformations;
        this.startparameterReader = startparameterReader;
 
        repositoryDelegate.refreshChache();
 
    }
 
    private class CreateInRepositorySelectionAdapter extends SelectionAdapter {
        @Override
        public void widgetSelected(SelectionEvent event) {
            String fileName = getFileName();
            String description = getFileDescription();
            String shortDescription = getShortDescription();
            String parentClass = parentClassCombo.getText();
 
            Instance instance = repositoryDelegate.getEmptyInstance();
            instance.setName(fileName);
            instance.setDescription(description);
            instance.setShortDescription(shortDescription);
            instance.setParentClass(parentClass);
            repositoryDelegate.createRepositoryEntryforInstance(instance);
 
            checkFileExisting(getFileName());
 
            validateInput();
 
        }
 
        private String getFileDescription() {
            return descriptionText.getText();
        }
 
    }
 
    private class BrowseButtonSelectionAdapter extends SelectionAdapter {
 
        @Override
        public void widgetSelected(SelectionEvent event) {
            ContainerSelectionDialog dialog = new ContainerSelectionDialog(getShell(),
                    ResourcesPlugin.getWorkspace().getRoot(), false, "Select new file container");
 
            if (dialog.open() == ContainerSelectionDialog.OK) {
                Object[] result = dialog.getResult();
                if (result.length == 1) {
                    containerText.setText(((Path) result[0]).toString());
                }
            }
        }
    }
 
    private class FileNameFocusAdapter extends FocusAdapter {
        @Override
        public void focusLost(FocusEvent event) {
            validateFileName();
 
        }
 
    }
 
    private class ValidateModifyListener implements ModifyListener {
        public void modifyText(ModifyEvent e) {
            if (programVariant.isVisible())
                validateInput();
        }
    }
 
    public void createControl(Composite parent) {
 
        Composite container;
        container = new Composite(parent, SWT.NULL);
 
        GridLayout glContainer = new GridLayout(3, false);
        container.setLayout(glContainer);
 
        ValidateModifyListener modifyListener = new ValidateModifyListener();
 
        createLabel(container, "Program &Variant:", SWT.NULL);
        programVariant = new CCombo(container, SWT.SINGLE | SWT.BORDER);
        programVariant.setEditable(false);
        GridData gdProgramVariant = new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
        gdProgramVariant.widthHint = convertWidthInCharsToPixels(10);
        programVariant.setLayoutData(gdProgramVariant);
        programVariant.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                if (!currConfig.equals(programVariant.getText())) {
                    currConfig = programVariant.getText();
                    initialize();
                }
            }
        });
        createEmptyLabel(container, SWT.NONE);
 
        createLabel(container, "&File name:", SWT.NULL);
        fileText = createTextField(container, "Physical File Name");
        fileText.addModifyListener(modifyListener);
        fileText.addFocusListener(new FileNameFocusAdapter());
        createEmptyLabel(container, SWT.NONE);
 
        createLabel(container, "&Parent Class:", SWT.NONE);
        parentClassCombo = new Combo(container, SWT.NONE);
        GridData gdParentClass = new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
        gdParentClass.widthHint = convertWidthInCharsToPixels(10);
        parentClassCombo.setLayoutData(gdParentClass);
        parentClassCombo.addModifyListener(modifyListener);
 
        buttonCreateObject = createButton(container, "Create in Repository");
        buttonCreateObject.addSelectionListener(new CreateInRepositorySelectionAdapter());
 
        createLabel(container, "&Container:", SWT.NONE);
        containerText = createTextField(container, "Parent Directory");
        containerText.addModifyListener(modifyListener);
 
        Button buttonBrowseForContainer = createButton(container, "Browse...");
        buttonBrowseForContainer.setToolTipText("Browse Directories in current Project");
        buttonBrowseForContainer.addSelectionListener(new BrowseButtonSelectionAdapter());
 
        createLabel(container, "Author:", SWT.NONE);
        authorText = createTextField(container, "Author");
        createEmptyLabel(container, SWT.NONE);
 
        createLabel(container, "Version:", SWT.NONE);
        versionText = createTextField(container, "Current proALPHA Version");
        createEmptyLabel(container, SWT.NONE);
 
        createLabel(container, "Product:", SWT.NONE);
        productText = createReadOnlyTextField(container, "proALPHA Product Key");
        productDescriptionText = createReadOnlyTextField(container, "proALPHA Product Description");
 
        createLabel(container, "Module:", SWT.NONE);
        moduleText = createReadOnlyTextField(container, "proALPHA Sub Module Key");
        moduleDescriptionText = createReadOnlyTextField(container, "proALPHA Sub Module Description");
 
        createLabel(container, "Relative Path:", SWT.NONE);
        relativePathText = createReadOnlyTextField(container, "Relative Path of File");
        // Override default layout data
        GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).span(2, 1)
                .applyTo(relativePathText);
 
        createLabel(container, "Short Description:", SWT.NONE);
        shortDescriptionText = createTextField(container, "Short Description");
        GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).span(2, 1)
                .applyTo(shortDescriptionText);
        shortDescriptionText.addModifyListener(modifyListener);
        shortDescriptionText.setTextLimit(80);
 
        Label descriptionLabel = createLabel(container, "Description:", SWT.NONE);
        GridDataFactory.fillDefaults().align(SWT.FILL, SWT.TOP).applyTo(descriptionLabel);
        descriptionText = createTextField(container, "Description", SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
        GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).span(2, 1).applyTo(descriptionText);
        descriptionText.addModifyListener(modifyListener);
        descriptionText.setTextLimit(800);
 
        setControl(container);
        new Label(container, SWT.NONE);
        new Label(container, SWT.NONE);
 
    }
 
    @Override
    public void setVisible(boolean visible) {
        programVariant.setItems(getConfigKeys((LinkedHashMap<String, WizardMainPageConfiguration>) this.configList));
        programVariant.setText(currConfig);
        initialize();
        super.setVisible(visible);
    }
 
    private Button createButton(Composite composite, String text) {
        Button newButton = new Button(composite, SWT.PUSH);
        newButton.setText(text);
        return newButton;
    }
 
    private Text createReadOnlyTextField(Composite composite, String tooltip) {
        return createTextField(composite, tooltip, SWT.BORDER | SWT.SINGLE | SWT.READ_ONLY);
    }
 
    private Text createTextField(Composite composite, String tooltip) {
        return createTextField(composite, tooltip, SWT.BORDER | SWT.SINGLE);
    }
 
    private Text createTextField(Composite composite, String tooltip, int style) {
        Text newText = new Text(composite, style);
        newText.setToolTipText(tooltip);
 
        GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(newText);
 
        return newText;
    }
 
    private Label createEmptyLabel(Composite composite, int style) {
        return createLabel(composite, "", style);
    }
 
    private Label createLabel(Composite composite, String text, int style) {
        Label newLabel = new Label(composite, style);
        newLabel.setText(text);
 
        return newLabel;
    }
 
    private void initialize() {
 
        authorText.setText(System.getProperty("user.name"));
        versionText.setText(this.paProject.getVersion());
 
        WizardMainPageConfiguration configuration = configList.get(currConfig);
 
        setTitle(configuration.getWizardTitle());
        setDescription(configuration.getWizardDescription());
        this.checkRepository = configuration.isCheckRepository();
        this.extensionList = configuration.getExtensionList();
        this.thirdDigit = configuration.getThirdDigit();
        this.rootClass = configuration.getRootClass();
        this.extensionList = configuration.getExtensionList();
        this.checkFileNameLength = configuration.isCheckFileNameLength();
        this.checkLowerCase = configuration.isCheckLowerCase();
        this.supportRepositoryCreateButton = configuration.isSupportRepositoryCreateButton();
 
        IFolder workingDirectory = startparameterReader.getWorkingDirectory();
 
        containerText.setText(workingDirectory.getFullPath().toString());
 
        buttonCreateObject.setEnabled(false);
 
        // Initialize Parent Class Combo
        // Items are the given parent class plus all subclasses
        // Initialize the screen value with parent class
        if (!checkRepository) {
            parentClassCombo.setEnabled(false);
        } else {
 
            String subClasses = repositoryInformations.getListOFSubClasses(this.rootClass);
 
            if (subClasses != null && !subClasses.isEmpty()) {
                String[] subClassesArray = subClasses.split(",");
 
                parentClassCombo.setItems(subClassesArray);
                parentClassCombo.setText(rootClass);
 
                // Fill the HashMap with each className and the correspondent
                // objectClassCode
                classGroupCode = new HashMap<>();
 
                if (rootClass.equals(OO_ABL)) {
                    for (String className : subClassesArray) {
                        String objectClassCode = repositoryInformations.getClassGroupOf(className);
                        classGroupCode.put(className, objectClassCode);
                    }
                }
            }
        }
 
        setPageComplete(false);
    }
 
    private void validateInput() {
 
        try {
 
            if (!this.paProject.isAvailable()) {
                return;
            }
 
            String fileName = getFileName();
 
            buttonCreateObject.setEnabled((checkRepository) && (supportRepositoryCreateButton)
                    && (!shortDescriptionText.getText().equals("")) && (!isFileExisting)
                    // never in customlevel Standard but in all other Levels for UserExits
                    && (!this.paProject.getCustomLevel().equals("")));
 
            parentClassCombo
                    .setEnabled((checkRepository) && (parentClassCombo.getItemCount() != 1) && (!isFileExisting));
 
            shortDescriptionText.setEnabled(!((checkRepository) && (isFileExisting)));
 
            IResource container = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(getContainerName()));
 
            int dotLoc = fileName.lastIndexOf('.');
            if (dotLoc == -1) {
                updateStatus("File extension must be specified");
                buttonCreateObject.setEnabled(Boolean.FALSE);
                return;
            } else {
                String ext = fileName.substring(dotLoc + 1);
                if (!(this.extensionList.contains(ext))) {
                    updateStatus("Invalid File Extension \"" + ext + "\"");
                    buttonCreateObject.setEnabled(Boolean.FALSE);
                    return;
                }
            }
 
            if (getContainerName().length() == 0) {
                updateStatus("File container must be specified");
                return;
            }
            if (container == null || (container.getType() & (IResource.PROJECT | IResource.FOLDER)) == 0) {
                updateStatus("File container must exist");
                return;
            }
            if (!container.isAccessible()) {
                updateStatus("Project must be writable");
                return;
            }
            if (fileName.length() == 0) {
                updateStatus("File name must be specified");
                return;
            }
            if (fileName.replace('\\', '/').indexOf('/', 1) > 0) {
                updateStatus("File name must be valid");
                return;
            }
            if ((this.checkLowerCase) && !fileName.toLowerCase().equals(fileName)) {
                updateStatus("File name must be lower case");
                return;
            }
 
            String fileBody = fileName.substring(0, dotLoc);
            if ((this.checkFileNameLength) && (fileBody.length() != 8)) {
                updateStatus("File name must have a length of 8 digits");
                return;
 
            }
            if (this.thirdDigit.length() > 0 && !fileName.substring(2, 3).equals(this.thirdDigit)) {
                updateStatus("Thirdt Digit of File name must be \"" + this.thirdDigit + "\"");
                return;
 
            }
 
            // Exclusion: _* (Update program)
            if (!fileName.startsWith("_") && moduleText.getText().equals("")) {
                updateStatus("The file must be assigned to a module.");
                return;
            }
 
            if (shortDescriptionText.getText().length() == 0) {
                updateStatus("Short description must be specified");
                return;
            }
 
            /*
             * Check if the fileName is valid before we create the object within the
             * repository
             */
 
            if (fileName.endsWith(".cls")) {
                String parentClass = parentClassCombo.getText();
                String objectClassCode = this.classGroupCode.get(parentClass);
 
                for (int i = 0; i < 2; i++) {
 
                    if (Character.isLowerCase(fileName.charAt(i))) {
                        updateStatus("The first three characters must be uppercase.");
                        return;
                    }
 
                }
 
                // There is no class group code defined for the parentClass
 
                if (objectClassCode == null || objectClassCode.contains("?")) {
                    objectClassCode = "";
                }
 
                if ((!fileName.contains(objectClassCode + ".cls") && (!parentClassCombo.getText().equals(OO_ABL)))) {
 
                    updateStatus("You selected the following parent Class: " + parentClass
                            + "Your Classname does not contain the dedicated Class Group Code: *" + objectClassCode
                            + ".cls");
                    buttonCreateObject.setEnabled(false);
                    return;
                }
                if ((!fileName.contains(objectClassCode + ".cls") && (parentClassCombo.getText().equals(OO_ABL)))) {
                    fileText.setText(fileName.replace(objectClassCode, ""));
                    return;
                }
            }
 
            if (this.checkRepository && parentClassCombo.getText().equals("") && (!isFileExisting)) {
                updateStatus("Object should be member of Class \"" + this.rootClass + "\"");
                return;
            }
 
            if (checkRepository && (!isFileExisting)) {
                // in standard level the hash code is auto generated. create is not supported 
                    
                if (this.paProject.getCustomLevel().equals("")) {
                    updateStatus("File unknown to Repository Manager. Please create manually in a seperate pA Session");
                }
                else {
                    updateStatus("File unknown to Repository Manager.");
                }
                
                return;
            }
            updateStatus(null);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
 
    private void updateStatus(String message) {
        setErrorMessage(message);
        setPageComplete(message == null);
    }
 
    public String getContainerName() {
        return containerText.getText();
    }
 
    public String getFileName() {
        return fileText.getText();
    }
 
    public void setFileName(String fileName) {
        this.fileText.setText(fileName);
        validateFileName();
    }
 
    public String getAuthor() {
        return authorText.getText();
    }
 
    public String getShortDescription() {
        return shortDescriptionText.getText();
    }
 
    public String getProduct() {
        return productText.getText();
    }
 
    public String getProductDescription() {
        return productDescriptionText.getText();
    }
 
    public String getRelativePath() {
        return relativePathText.getText();
    }
 
    public String getVersion() {
        return versionText.getText();
    }
 
    public String getModule() {
        return moduleText.getText();
    }
 
    public String getModuleDescription() {
        return moduleDescriptionText.getText();
    }
 
    public Map<String, Object> getSettings() {
        HashMap<String, Object> wizardSettings = new HashMap<>();
        wizardSettings.put(GeneratorSettingsConstans.AUTHOR, this.getAuthor());
        wizardSettings.put(GeneratorSettingsConstans.CONTAINER_NAME, this.getContainerName());
        wizardSettings.put(GeneratorSettingsConstans.DESCRIPTION, this.getShortDescription());
        wizardSettings.put("FileName", this.getFileName());
        wizardSettings.put("Product", this.getProduct());
        wizardSettings.put("ProductDescription", this.getProductDescription());
        wizardSettings.put("RelativePath", this.getRelativePath());
        wizardSettings.put("Module", this.getModule());
        wizardSettings.put("ModuleDescription", this.getModuleDescription());
        wizardSettings.put("Version", this.getVersion());
        wizardSettings.put("ParentObject", this.getParentClass());
        wizardSettings.put(GeneratorSettingsConstans.TEMPLATE_NAME, this.configList.get(currConfig).getTemplateName());
        return wizardSettings;
    }
 
    private Object getParentClass() {
 
        return parentClassCombo.getText();
    }
 
    public void setFileDescriptionText(String description) {
        if (shortDescriptionText != null) {
            shortDescriptionText.setText(description);
        }
    }
 
    public boolean isCheckFileNameLength() {
        return checkFileNameLength;
    }
 
    public void setCheckFileNameLength(boolean checkFileNameLength) {
        this.checkFileNameLength = checkFileNameLength;
    }
 
    public boolean isCheckLowerCase() {
        return checkLowerCase;
    }
 
    public void setCheckLowerCase(boolean checkLowerCase) {
        this.checkLowerCase = checkLowerCase;
    }
 
    private void checkFileExisting(String fileName) {
        if (checkRepository) {
            isFileExisting = repositoryInformations.exitsInstanceInRepository(fileName);
        } else {
            isFileExisting = false;
        }
    }
 
    private void validateFileName() {
        if (!this.paProject.isAvailable())
            return;
 
        String fileName = getFileName();
 
        checkFileExisting(fileName);
 
        // Derive Product Key and Description
        // Derive Module Key and Description
        // Derive relative Path
        if (fileName.length() > 0) {
 
            productText.setText(repositoryInformations.getProductName(fileName));
            productDescriptionText.setText(repositoryInformations.getProductDescription(fileName));
 
            moduleText.setText(repositoryInformations.getModule(fileName));
            moduleDescriptionText.setText(repositoryInformations.getModuleDescription(fileName));
 
            relativePathText.setText(repositoryInformations.getRelativePath(fileName));
        } else {
 
            productText.setText("");
            productDescriptionText.setText("");
            moduleText.setText("");
            moduleDescriptionText.setText("");
            relativePathText.setText("");
 
        }
 
        // Derive Short Description from Repository
 
        if (isFileExisting) {
 
            shortDescriptionText.setText(repositoryInformations.getProgramShortDesc(fileName));
 
        }
 
        if (checkRepository) {
 
            String parentClass = "";
            if (isFileExisting) {
                parentClass = repositoryInformations.getClassName(repositoryInformations.getClassOBJ(fileName));
 
            } else if (fileName.contains(".cls")) {
                parentClass = retrieveParentClass();
            }
 
            if (!parentClass.isEmpty()) {
                parentClassCombo.setText(parentClass);
            }
 
        }
 
        validateInput();
    }
 
    private String retrieveParentClass() {
 
        String fileName = getFileName();
 
        for (Map.Entry<String, String> entry : classGroupCode.entrySet()) {
 
            String classCode = entry.getValue();
 
            if ((classCode != null) && (!classCode.isEmpty()) && (classCode.length() == 3)) {
                classCode = classCode + ".cls";
                if (fileName.contains(classCode)) {
                    return entry.getKey();
                }
            }
        }
 
        return OO_ABL;
    }
 
    private String[] getConfigKeys(LinkedHashMap<String, WizardMainPageConfiguration> configList) {
        return configList.keySet().stream().toArray(String[]::new);
    }
}