GenerateMissingDbTriggerHandler.java

package com.proalpha.pds.ui.handlers;
 
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
 
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ui.PlatformUI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.pds.exception.ProALPHANotAvailableException;
import com.proalpha.pds.generator.GeneratorFactory;
import com.proalpha.pds.generator.TriggerFileGenerator;
import com.proalpha.pds.jaxb.TtDECMissingTrigger;
import com.proalpha.pds.jaxb.TtDECMissingTrigger.TtDECMissingTriggerRow;
import com.proalpha.pds.paconnector.Activator;
import com.proalpha.pds.paconnector.PaProject;
import com.proalpha.pds.paconnector.utils.ExceptionUtils;
import com.proalpha.pds.paconnector.utils.JaxbUnmarshallerGeneric;
import com.proalpha.pds.templates.data.DataContainerFactory;
import com.proalpha.pds.templates.data.IGeneratorDataContainer;
import com.proalpha.pds.ui.AbstractProAlphaHandler;
 
public class GenerateMissingDbTriggerHandler extends AbstractProAlphaHandler {
 
    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {
 
        PaProject paProject;
        try {
            paProject = getPaProjectOfEvent(event);
            runProgram(paProject);
        } catch (ProALPHANotAvailableException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        }
 
        return null;
    }
 
    private static void runProgram(PaProject paProject) {
        IRunnableWithProgress runnable = new IRunnableWithProgress() {
 
            private final Logger logger = LoggerFactory.getLogger(GenerateMissingDbTriggerHandler.class);
 
            @Override
            public void run(IProgressMonitor monitor) {
 
                try {
                    monitor.beginTask("Create missing database triggers", 2);
 
                    monitor.worked(1);
 
                    monitor.subTask("Fetch list of missing triggers");
 
                    File file = paProject.getBridge().createMissingTriggersXMLFile();
                    logger.debug("Exported missing triggers to file {}", file);
 
                    List<TtDECMissingTriggerRow> missingTriggers = retrieveMissingTriggers(file);
 
                    monitor.beginTask("Create missing database triggers", missingTriggers.size() + 1);
 
                    for (TtDECMissingTriggerRow trigger : missingTriggers) {
                        String triggerName = trigger.getTriggerFileName().getValue();
                        logger.debug("Create trigger {}", triggerName);
                        monitor.subTask("Create trigger " + triggerName);
                        DataContainerFactory dataContainerFactory = new DataContainerFactory();
                        IGeneratorDataContainer datacontainer = dataContainerFactory
                                .createDataContainer(paProject);
 
                        datacontainer.setFileName(trigger.getTriggerFileName().getValue());
                        datacontainer.setTriggerMode(trigger.getTriggerMode().getValue());
                        datacontainer.setTableName(trigger.getTriggerTableName().getValue());
                        datacontainer.setAuthor(System.getProperty("user.name"));
                        datacontainer.setVersion(paProject.getVersion());
 
                        GeneratorFactory generatorFactory = new GeneratorFactory();
                        TriggerFileGenerator gen = generatorFactory.createTriggerFileGenerator(datacontainer);
 
                        gen.generate();
 
                        monitor.worked(1);
                    }
                } catch (Exception exception) {
                    ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), exception);
                } finally {
                    monitor.done();
                }
            }
 
            private List<TtDECMissingTriggerRow> retrieveMissingTriggers(File file) {
 
                JaxbUnmarshallerGeneric<TtDECMissingTrigger> unmarshaller = new JaxbUnmarshallerGeneric<>(
                        TtDECMissingTrigger.class);
 
                TtDECMissingTrigger missingTriggers = unmarshaller.readXMLFile(file);
                return missingTriggers.getTtDECMissingTriggerRow();
            }
        };
 
        ISchedulingRule rule = ResourcesPlugin.getWorkspace().getRoot();
        IRunnableContext context = PlatformUI.getWorkbench().getProgressService();
 
        try {
            PlatformUI.getWorkbench().getProgressService().runInUI(context, runnable, rule);
        } catch (InvocationTargetException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
        } catch (InterruptedException e) {
            ExceptionUtils.showAndLogErrorMessage(Activator.getDefault(), e);
            Thread.currentThread().interrupt();
        }
    }
 
}