EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.model;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import java.util.UUID;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.operations.AbstractOperation;

import org.eclipse.core.commands.operations.IOperationHistory;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.ICoreRunnable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubMonitor;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.EPartService;

import org.eclipse.jface.action.IStatusLineManager;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;

import org.eclipse.ui.progress.IProgressConstants;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.service.IProgressMonitorService;

import eu.etaxonomy.cdm.api.service.UpdateResult;

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

import eu.etaxonomy.cdm.io.common.ExportDataWrapper;

import eu.etaxonomy.cdm.io.common.ExportResult;

import eu.etaxonomy.cdm.io.common.ExportResultType;

import eu.etaxonomy.cdm.io.common.ExportType;

import eu.etaxonomy.cdm.model.common.IEnumTerm;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.IFeedbackGenerator;

import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.operation.e4.RemotingCdmHandlerE4;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;

import eu.etaxonomy.taxeditor.ui.dialog.ReportTextDialog;

import eu.etaxonomy.taxeditor.view.e4.AbstractCdmDataViewerE4;

import eu.etaxonomy.taxeditor.view.e4.details.DetailsPartE4;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 *

 * @author n.hoffmann

 * @created 11.05.2009

 * @version 1.0

 */

public abstract class AbstractUtility {

    protected static final Logger logger = Logger.getLogger(AbstractUtility.class);

    /** Constant <code>statusLineManager</code> */

    protected static IStatusLineManager statusLineManager;

    /** Constant <code>DATE_FORMAT_NOW="yyyyMMddHHmm"</code> */

   	public static final String DATE_FORMAT_NOW = "yyyyMMddHHmm";

    public static Object getActivePart() {

        MPart activePart = EventUtility.getActivePart();

        if(activePart!=null){

            return activePart.getObject();

        }

        return null;

    }

    public static Shell getShell() {

        return EventUtility.getShell();

    }

    public static IWorkbench getWorkbench() {

        return TaxeditorStorePlugin.getDefault().getWorkbench();

    }

    public static Object getService(Class api) {

        return TaxeditorStorePlugin.getDefault().getWorkbench().getService(api);

    }

    public static Font getFont(String symbolicName) {

        return FontResources.getFont(symbolicName);

    }

    public static Color getColor(String symbolicName) {

        return ColorResources.getColor(symbolicName);

    }

    public static IStatus executeOperation(final AbstractPostOperation operation, UISynchronize sync) {

        if (getOperationHistory() == null) {

            throw new IllegalArgumentException(

                    "There is no operation history for this context");

        }

        final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                .getUIInfoAdapter(getShell());

        Job job = Job.create(operation.getLabel(), (ICoreRunnable) monitor -> {

            sync.syncExec(() -> {

                String operationlabel = operation.getLabel();

                monitor.beginTask(operationlabel, 100);

                IStatus status = Status.CANCEL_STATUS;

                try {

                    operation.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                    status = operation.execute(monitor, uiInfoAdapter);

                } catch (ExecutionException e) {

                    MessagingUtils.operationDialog(AbstractUtility.class, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

                } finally {

                    monitor.done();

                }

                String statusString = status.equals(Status.OK_STATUS) ? "completed"

                        : "cancelled";

                setStatusLine(operationlabel + " " + statusString + ".");

                IPostOperationEnabled postOperationEnabled = operation

                        .getPostOperationEnabled();

                if (postOperationEnabled != null) {

                    postOperationEnabled.onComplete();

                }

            });

        });

        try {

            job.setUser(true);

            job.schedule();

        } catch (Exception e) {

            MessagingUtils.messageDialog("Error executing operation", AbstractUtility.class, "An error occurred while executing " + operation.getLabel(), e);

        }

        return Status.OK_STATUS;

    }

    public static IStatus executeOperation(final AbstractOperation operation, final RemotingCdmHandlerE4 handler, UISynchronize sync) {

        return executeOperation_internal(operation, handler, sync);

    }

    private static IStatus executeOperation_internal(final AbstractOperation operation, final RemotingCdmHandlerE4 handler,

            UISynchronize sync) {

        if (getOperationHistory() == null) {

            throw new IllegalArgumentException(

                    "There is no operation history for this context");

        }

        final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                .getUIInfoAdapter(getShell());

        Job job = Job.create(operation.getLabel(), (ICoreRunnable) monitor -> {

            sync.syncExec(() -> {

                String operationlabel = operation.getLabel();

                monitor.beginTask(operationlabel, 100);

                IStatus status = Status.CANCEL_STATUS;

                try {

                    operation.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                    status = operation.execute(monitor,

                            uiInfoAdapter);

                    handler.postOperation(status);

                } catch (ExecutionException e) {

                    MessagingUtils.operationDialog(AbstractUtility.class, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

                } finally {

                    monitor.done();

                }

                String statusString = status.equals(Status.OK_STATUS) ? "completed"

                        : "cancelled";

                setStatusLine(operationlabel + " " + statusString + ".");

            });

        });

        try {

            job.setUser(true);

            sync.syncExec(()->job.schedule());

        } catch (Exception e) {

            MessagingUtils.messageDialog("Error executing operation", AbstractUtility.class, "An error occurred while executing " + operation.getLabel(), e);

        }

        return Status.OK_STATUS;

    }

    /**

     * Executes a remoting monitored operation

     *

     * @param label for the operation

     * @param uuid of the remoting monitor already started on the server

     * @param pollInterval in milliseconds

     * @param cancelable flag which determines whether the operation can be cancelled

     * @param postOp callback for running post operation logic

     * @return

     */

    public static IStatus executeMoniteredExport(final String label,

            final UUID uuid,

            final int pollInterval,

            final boolean cancelable,

            final IPostMoniteredOperationEnabled postOp,

            final IFeedbackGenerator feedbackGenerator,

            String urlString,

            boolean createZip) {

        try {

            // get the remoting monitor the first time to make sure that the

            // operation is valid

            final IProgressMonitorService progressMonitorService = CdmApplicationState.getCurrentAppConfig().getProgressMonitorService();

            final IRemotingProgressMonitor firstRemotingMonitor = progressMonitorService.getRemotingMonitor(uuid);

            if(firstRemotingMonitor == null) {

                throw new IllegalStateException("Remoting progress monitor is null");

            }

            if (firstRemotingMonitor.isDone()){

                createExportResult(label, urlString, createZip, firstRemotingMonitor);

            }

            Job job = new Job(label) {

                @Override

                public IStatus run(IProgressMonitor monitor) {

                    // run the monitor until the operation is finished

                    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);

                    //subMonitor.beginTask("Start", 100);

                    IRemotingProgressMonitor remotingMonitor;

                    try {

                        remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor(label,

                                uuid,

                                pollInterval,

                                postOp,

                                feedbackGenerator,

                                subMonitor);

                    } catch (Exception ex) {

                        return new Status(Status.ERROR, TaxeditorStorePlugin.PLUGIN_ID, "Operation Interrupted", ex);

                    }

                    createExportResult(label, urlString, createZip, remotingMonitor);

                    return Status.OK_STATUS;

                }

                @Override

                protected void canceling() {

                    CdmStore.getCurrentApplicationConfiguration().getProgressMonitorService().cancel(uuid);

                }

            };

            // configure the job

            job.setProperty(IProgressConstants.KEEP_PROPERTY, true);

            job.setUser(true);

            // schedule job

            job.schedule();

        } catch (Exception e) {

            MessagingUtils.errorDialog("Error executing operation",

                    AbstractUtility.class,

                    "An error occurred while executing " + label,

                    TaxeditorStorePlugin.PLUGIN_ID,

                    e,

                    true);

        }

        return Status.OK_STATUS;

    }

    public static IOperationHistory getOperationHistory() {

        return getWorkbench().getOperationSupport().getOperationHistory();

    }

    public static void setStatusLine(final String message) {

        Display.getDefault().asyncExec(new Runnable() {

            @Override

            public void run() {

                statusLineManager.setMessage(message);

            }

        });

    }

    public static IProgressMonitor getMonitor() {

        statusLineManager.setCancelEnabled(false);

        return statusLineManager.getProgressMonitor();

    }

    /**

     * Starts either the given {@link IProgressMonitor} if it's not

     * <code>null</code> or a new {@link NullProgressMonitor}.

     *

     * @param progressMonitor

     *            The {@link IProgressMonitor} or <code>null</code> if no

     *            progress should be reported.

     * @param taskName

     *            The name of the main task.

     * @param steps

     *            The number of steps this task is subdivided into.

     * @return The {@link IProgressMonitor}.

     */

    public static IProgressMonitor startMainMonitor(

            IProgressMonitor progressMonitor, String taskName, int steps) {

        IProgressMonitor newMonitor = progressMonitor;

        if (newMonitor == null) {

            newMonitor = new NullProgressMonitor();

        }

        newMonitor.beginTask(taskName == null ? "" : taskName, steps);

        newMonitor.subTask(" ");

        return newMonitor;

    }

    /**

     * Creates a {@link SubProgressMonitor} if the given

     * {@link IProgressMonitor} is not <code>null</code> and not a

     * {@link NullProgressMonitor}.

     *

     * @param progressMonitor

     *            The parent {@link IProgressMonitor} of the

     *            {@link SubProgressMonitor} to be created.

     * @param ticks

     *            The number of steps this subtask is subdivided into. Must be a

     *            positive number and must not be

     *            {@link IProgressMonitor#UNKNOWN}.

     * @return The {@link IProgressMonitor}.

     */

    public static IProgressMonitor getSubProgressMonitor(

            IProgressMonitor progressMonitor, int ticks) {

        if (progressMonitor == null) {

            return new NullProgressMonitor();

        }

        if (progressMonitor instanceof NullProgressMonitor) {

            return progressMonitor;

        }

        return new SubProgressMonitor(progressMonitor, ticks);

    }

    /**

     * Checks whether the user canceled this operation. If not canceled, the

     * given number of steps are declared as done.

     *

     * @param newMonitor

     *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.

     * @param steps

     *            a int.

     */

    public static void workedChecked(IProgressMonitor newMonitor, int steps) {

        // In case the progress monitor was canceled throw an exception.

        if (newMonitor.isCanceled()) {

            throw new OperationCanceledException();

        }

        // Otherwise declare this step as done.

        newMonitor.worked(steps);

    }

    public static String getPluginId() {

        return "eu.taxeditor";

    }

    public static Object getActiveEditor() {

        MPart activePart = EventUtility.getActivePart();

        if(activePart!=null && activePart.getObject()!=null

                && activePart.getObject() instanceof IE4SavablePart){

            return activePart.getObject();

        }

        return null;

    }

    public static DetailsPartE4 getDetailsView(EPartService partService) {

        MPart part = partService.findPart("eu.etaxonomy.taxeditor.view.e4.details.DetailsPartE4");

        if(part!=null){

            return (DetailsPartE4) part.getObject();

        }

        return null;

    }

    public static void refreshDetailsViewer(EPartService partService) {

        if (getDetailsView(partService) != null) {

            ((AbstractCdmDataViewerE4) getDetailsView(partService).getViewer()).refresh();

        }

    }

    public static void reflowDetailsViewer(EPartService partService) {

        if (getDetailsView(partService) != null) {

            ((AbstractCdmDataViewerE4) getDetailsView(partService).getViewer()).reflow();

        }

    }

    /**

     * Orders a Collection of {@link IEnumTerm}s according to the term

     * hierarchy. <br>

     * <br>

     * The returned map will be be ordered primarily by root elements,

     * secondarily by the child elements and their children resp., both ascending alphabetically. <br>

     * @param terms

     *            A {@link Collection} of {@link IEnumTerm}s for which the term

     *            hierarchy should be created

     * @return a map which holds the terms as keys and their string

     *         representation via {@link IEnumTerm#getMessage()} as values

     */

    public static <T extends IEnumTerm<T>> LinkedHashMap<T, String> orderTerms(Collection<T> terms) {

        TreeSet<TermNode<T>> parentElements = new TreeSet<TermNode<T>>();

        parentElements.addAll(getTermHierarchy(terms));

        // create list according to the type hierarchy (root elements alphabetically with recursive children also alphabetically)

        LinkedHashMap<T, String> result = new LinkedHashMap<T, String>();

        parseTermTree(parentElements, result, -1);

        return result;

    }

    private static<T extends IEnumTerm<T>> void parseTermTree(Collection<TermNode<T>> children, LinkedHashMap<T, String> result, int depth){

        depth++;

        for(TermNode<T> node:children){

            String indentString = "";

            for(int i=0;i<depth;i++){

                indentString += "  ";

            }

            if(depth>0){

                indentString += "- ";

            }

            result.put(node.term, indentString + node.term.getMessage());

            parseTermTree(node.children, result, depth);

        }

    }

    private static<T extends IEnumTerm<T>> void addToParents(List<TermNode<T>> parents, Collection<T> terms){

        List<TermNode<T>> hasChildrenList = new ArrayList<TermNode<T>>();

        for(T term:terms){

            // only terms with parents

            if(term.getKindOf()!=null){

                TermNode<T> parentNode = new TermNode<T>(term.getKindOf());

                TermNode<T> childNode = new TermNode<T>(term);

                if(parents.contains(parentNode)){

                    // parent found in parent list -> add this term to parent's child list

                    parents.get(parents.indexOf(parentNode)).addChild(childNode);

                    if(!term.getGeneralizationOf().isEmpty()){

                        // has more children -> add to list which will be the parent for the next recursion

                        hasChildrenList.add(childNode);

                    }

                }

            }

        }

        if(!hasChildrenList.isEmpty()){

            addToParents(hasChildrenList, terms);

        }

    }

    private static<T extends IEnumTerm<T>> List<TermNode<T>> getTermHierarchy(Collection<T> terms){

        List<TermNode<T>> parents = new ArrayList<TermNode<T>>();

        // get root elements

        for(T term:terms){

            T parentTerm = term.getKindOf();

            if(parentTerm==null){

                // root element

                parents.add(new TermNode<T>(term));

            }

        }

        addToParents(parents, terms);

        return parents;

    }

    @SuppressWarnings("unchecked")

    /**

     * Recursively iterates over all term parents until no more parent is found i.e. the root node

     * @param term The term for which the parent should be found

     * @return the root terms of the term hierarchy

     */

    private static<T extends IEnumTerm<T>> T getParentFor(T term){

        // PP: cast should be safe. Why is Eclipse complaining??

        T parent = term.getKindOf();

        if(parent==null){

            return term;

        }

        else{

            return getParentFor(term.getKindOf());

        }

    }

    private static class TermNode<T extends IEnumTerm<T>> implements Comparable<TermNode<T>>{

        private final T term;

        private final TreeSet<TermNode<T>> children;

        public TermNode(T term) {

            super();

            this.term = term;

            this.children = new TreeSet<TermNode<T>>();

        }

        public void addChild(TermNode<T> child){

            this.children.add(child);

        }

        public TreeSet<TermNode<T>> getChildren() {

            return children;

        }

        public T getTerm() {

            return term;

        }

        @Override

        public int hashCode() {

            final int prime = 31;

            int result = 1;

            result = prime * result + ((term == null) ? 0 : term.hashCode());

            return result;

        }

        @Override

        public boolean equals(Object obj) {

            if (this == obj) {

                return true;

            }

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            TermNode other = (TermNode) obj;

            if (term == null) {

                if (other.term != null) {

                    return false;

                }

            } else if (!term.equals(other.term)) {

                return false;

            }

            return true;

        }

        @Override

        public int compareTo(TermNode<T> that) {

            return this.term.getMessage().compareTo(that.term.getMessage());

        }

    }

    public static Object getElementsFromSelectionChangedEvent(SelectionChangedEvent event) {

        IStructuredSelection selection = (IStructuredSelection) event.getSelection();

        Object selectionToSet = selection;

        if(selection.size() == 1){

            selectionToSet = selection.getFirstElement();

        }

        else if(!selection.isEmpty()){

            selectionToSet = selection.toArray();

        }

        return selectionToSet;

    }

    /**

     * Executes a remoting monitored import

     *

     * @param label for the import

     * @param uuid of the remoting monitor already started on the server

     * @param pollInterval in milliseconds

     * @param cancelable flag which determines whether the operation can be cancelled

     * @param postOp callback for running post operation logic

     * @return

     */

    public static IStatus executeMoniteredOperation(final String label,

            final UUID uuid,

            final int pollInterval,

            final boolean cancelable,

            final IPostMoniteredOperationEnabled postOp,

            final IFeedbackGenerator feedbackGenerator,

            final boolean showResult) {

    	try{

    		// get the remoting monitor the first time to make sure that the

            // operation is valid

            final IProgressMonitorService progressMonitorService = CdmApplicationState.getCurrentAppConfig().getProgressMonitorService();

            final IRemotingProgressMonitor firstRemotingMonitor = progressMonitorService.getRemotingMonitor(uuid);

            if(firstRemotingMonitor == null) {

                throw new IllegalStateException("Remoting progress monitor is null");

            }

            if (firstRemotingMonitor.isDone()){

                createResult(label, showResult, firstRemotingMonitor);

                return Status.OK_STATUS;

            }

            Job job = new Job(label) {

                @Override

                public IStatus run(IProgressMonitor monitor) {

                    // run the monitor until the operation is finished

                    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);

                   // subMonitor.beginTask("Start", 100);

                    IRemotingProgressMonitor remotingMonitor;

                    try {

                        remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor(label,

                                uuid,

                                pollInterval,

                                postOp,

                                feedbackGenerator,

                                subMonitor);

                    } catch (Exception ex) {

                        return new Status(Status.ERROR, TaxeditorStorePlugin.PLUGIN_ID, "Operation Interrupted", ex);

                    }

                    // collect reports

//	                    for(String report : remotingMonitor.getResult()) {

                    createResult(label, showResult, remotingMonitor);

                    return Status.OK_STATUS;

                }

                @Override

                protected void canceling() {

                    CdmStore.getCurrentApplicationConfiguration().getProgressMonitorService().cancel(uuid);

                }

            };

            // configure the job

            job.setUser(true);

            // schedule job

            job.schedule();

        } catch (Exception e) {

            MessagingUtils.errorDialog("Error executing operation",

                    AbstractUtility.class,

                    "An error occurred while executing " + label,

                    TaxeditorStorePlugin.PLUGIN_ID,

                    e,

                    true);

        }

        return Status.OK_STATUS;

        }

    private static void createResult(final String label, final boolean showResult,

            IRemotingProgressMonitor remotingMonitor) {

        final StringBuilder reportSb = new StringBuilder();

        if (remotingMonitor.getResult() instanceof ExportResult) {

            reportSb.append(((ExportResult)remotingMonitor.getResult()).createReport());

        }else if (remotingMonitor.getResult() instanceof UpdateResult){

            if (((UpdateResult)remotingMonitor.getResult()).isOk()){

                reportSb.append("Update successful. \n"+"Updated Objects: " + ((UpdateResult)remotingMonitor.getResult()).getUpdatedObjects().size());

            }

            if (!((UpdateResult)remotingMonitor.getResult()).getExceptions().isEmpty()){

                reportSb.append(((UpdateResult)remotingMonitor.getResult()).getExceptions().toString());

            }

        }

//          }

        if(showResult && !StringUtils.isBlank(reportSb.toString()) && reportSb.length() != 0) {

            Display.getDefault().asyncExec(new Runnable() {

                @Override

                public void run() {

                    // display reports with possibility to save

                    ReportTextDialog dialog = new ReportTextDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());

                    dialog.setTitle(label + " Report");

                    dialog.setReportText(reportSb.toString());

                    dialog.open();

                }

            });

        }

    }

    private static void createExportResult(final String label, String urlString, boolean createZip,

            IRemotingProgressMonitor remotingMonitor) {

        final StringBuilder reportSb = new StringBuilder();

        if (remotingMonitor.getResult() instanceof ExportResult){

            ExportResult result = (ExportResult)remotingMonitor.getResult();

            reportSb.append(result.createReport());

            if(!StringUtils.isBlank(reportSb.toString())) {

                Display.getDefault().asyncExec(new Runnable() {

                    @Override

                    public void run() {

                        // display reports with possibility to save

                        ReportTextDialog dialog = new ReportTextDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());

                        dialog.setTitle(label + " Report");

                        dialog.setReportText(reportSb.toString());

                        dialog.open();

                    }

                });

            }

            if (urlString != null){

                 ExportDataWrapper data = result.getExportData();

                 try{

                     if (result.getExportData().getType().equals(ExportResultType.BYTE_ARRAY)){

                         byte[] exportData = (byte[])data.getExportData();

                         if(exportData != null){

                             File file = new File(urlString);

                             FileOutputStream stream = new FileOutputStream(file);

                             Writer out = new BufferedWriter(new OutputStreamWriter(

                                    stream, "UTF8"));

                            stream.write(exportData);

                            out.flush();

                            stream.close();

                         }

                     } else if (result.getExportData().getType().equals(ExportResultType.MAP_BYTE_ARRAY)){

                         Map<String, byte[]> resultMap = (Map<String, byte[]>)data.getExportData();

                         Set<String> keySet = resultMap.keySet();

                         SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);

                         Calendar cal = Calendar.getInstance();

                         String fileEnding = ".csv";

                         if (createZip){

                             File file = new File(urlString+File.separator +  sdf.format(cal.getTime())+ ".zip");

                             FileOutputStream stream = new FileOutputStream(file);

                             ZipOutputStream zos = new ZipOutputStream(stream);

                             for (String key: keySet){

                                byte[] fileData = resultMap.get(key);

                                ZipEntry entry = new ZipEntry( key + fileEnding);

                                zos.putNextEntry(entry);

                                zos.write(fileData);

                                zos.closeEntry();

                             }

                             zos.close();

                         }else{

                            if(result.getExportType().equals(ExportType.DWCA)){

                                File file = new File(urlString);

                                FileOutputStream stream = new FileOutputStream(file);

                                ZipOutputStream zos = new ZipOutputStream(stream);

                                for (String key: keySet){

                                    byte[] fileData = resultMap.get(key);

                                    ZipEntry entry = new ZipEntry( key);

                                        zos.putNextEntry(entry);

                                        zos.write(fileData);

                                        zos.closeEntry();

                                 }

                                 zos.close();

                              }else{

                                 for (String key: keySet){

                                     byte[] fileData = resultMap.get(key);

                                     File file = new File(urlString+File.separator + key + fileEnding);

                                     FileOutputStream stream = new FileOutputStream(file);

                                     Writer out = new BufferedWriter(new OutputStreamWriter(

                                            stream, "UTF8"));

                                     stream.write(fileData);

                                     stream.close();

                                 }

                              }

                         }

                    }else{

                         logger.error("This kind of result data is not supported yet." + result.getExportData().getType().toString());

                     }

                 } catch(Exception e){

                     logger.error(e.getStackTrace());

                 }

            }

        }

    }

}