org.eclipse.osbp.xtext.reportdsl/src/org/eclipse/osbp/xtext/reportdsl/common/BaseReport.java

/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License 2.0        
 * which accompanies this distribution, and is available at                  
 * https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 * SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
package org.eclipse.osbp.xtext.reportdsl.common;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;

import org.eclipse.birt.report.model.api.DesignElementHandle;
import org.eclipse.birt.report.model.api.OdaDataSetHandle;
import org.eclipse.birt.report.model.api.OdaDataSourceHandle;
import org.eclipse.birt.report.model.api.ReportDesignHandle;
import org.eclipse.birt.report.model.api.SessionHandle;
import org.eclipse.birt.report.model.api.activity.SemanticException;
import org.eclipse.birt.report.model.api.command.ContentException;
import org.eclipse.birt.report.model.api.command.NameException;
import org.eclipse.birt.report.model.api.css.CssStyleSheetHandle;
import org.eclipse.birt.report.model.css.CssStyleSheet;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.ui.di.Focus;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
import org.eclipse.osbp.dsl.semantic.entity.LEntity;
import org.eclipse.osbp.osgi.hybrid.api.AbstractHybridVaaclipseView;
import org.eclipse.osbp.preferences.ProductConfiguration;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent.EventDispatcherCommand;
import org.eclipse.osbp.runtime.common.event.EventDispatcherEvent.EventDispatcherDataTag;
import org.eclipse.osbp.runtime.common.event.IEventDispatcher;
import org.eclipse.osbp.ui.api.customfields.IBlobService;
import org.eclipse.osbp.ui.api.datamart.DatamartFilter;
import org.eclipse.osbp.ui.api.datamart.IDataMart;
import org.eclipse.osbp.ui.api.datamart.IDatamartFilterGenerator;
import org.eclipse.osbp.ui.api.layout.IViewLayoutManager;
import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService;
import org.eclipse.osbp.ui.api.perspective.IPerspectiveProvider;
import org.eclipse.osbp.ui.api.report.IReportProvider.Rendering;
import org.eclipse.osbp.ui.api.themes.IThemeResourceService;
import org.eclipse.osbp.ui.api.user.IUser;
import org.eclipse.osbp.utils.common.EntityUtils;
import org.eclipse.osbp.utils.constants.ExtendedDate;
import org.eclipse.osbp.utils.vaadin.ViewLayoutManager;
import org.eclipse.osbp.xtext.action.ReportActionEnum;
import org.eclipse.osbp.xtext.action.common.IToolbarAction;
import org.eclipse.osbp.xtext.datamart.common.DatamartFilterGenerator;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartEntity;
import org.eclipse.osbp.xtext.datamartdsl.DatamartNavigation;
import org.eclipse.osbp.xtext.reportdsl.common.item.BodyItem;
import org.eclipse.osbp.xtext.reportdsl.jvmmodel.ReportGeneratorWorkSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.ibm.icu.util.ULocale;
import com.vaadin.data.Container.Filter;
import com.vaadin.server.DownloadStream;
import com.vaadin.server.FileDownloader;
import com.vaadin.server.StreamResource;
import com.vaadin.ui.BrowserFrame;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.Panel;
import com.vaadin.ui.VerticalLayout;

/**
 * 
 * @author mokross, riegel
 * 
 */
public abstract class BaseReport extends AbstractHybridVaaclipseView
		implements StreamResource.StreamSource, IUser.UserLocaleListener, IDatamartFilterGenerator.FilterChangeListener,
		IEventDispatcher.Receiver {
	private static final String BODY_HTML = "</body></html>";
	private static final String HTML_BODY = "<html><body>";
	private static final String RPTDESIGN = ".rptdesign";
	private static final long serialVersionUID = -2774341697829389431L;
	private static final Logger LOGGER = LoggerFactory.getLogger(BaseReport.class);

	public static final String CAPTION_I18NKEY_SAVE_PDF = "save PDF";
	public static final String CAPTION_I18NKEY_PRINT_PDF = "print PDF";

	protected transient IViewLayoutManager layoutManager;
	protected transient BrowserFrame frame;
	protected transient Map<String, IDatamartFilterGenerator> filterGeneratorMap = new HashMap<>();
	protected transient BodyItem body;
	protected transient ReportGeneratorWorkSet workset;
	protected Locale locale;
	protected StreamResource reportResource;
	protected transient Map<String, IDataMart> datamartInstanceMap = new HashMap<>();

	/** needs to be equivalent to the dataMart ODA bundle symbolic name */
	public static final String DATASOURCE_EXTENSION_ID = "org.eclipse.osbp.xtext.reportdsl.oda.datamart";
	/**
	 * in order to have data in header and footer areas we must provide them as
	 * translations. to get not mixed up with attribute name translations, this
	 * prefix must be used
	 */
	public static final String ATTRIBUTE_TRANSLATION_PREFIX = "$$$";

	@Inject
	private IEclipseContext eclipseContext;

	@Inject
	protected IThemeResourceService themeResourceService;

	@Inject
	private IUser user;

	@Inject
	private IDSLMetadataService dslMetadataService;

	@Inject
	private IBlobService blobService;

	@Inject
	private IEventDispatcher eventDispatcher;

	private Object selectedId = null;
	
	private List<Parameter> parameterList;
	
	@Inject
	public BaseReport() {
		super();
		layoutManager = new ViewLayoutManager();
	}

	@Inject
	public BaseReport(VerticalLayout parent, IEclipseContext context, MApplication app) {
		super(parent, context, app);
		layoutManager = new ViewLayoutManager();
		layoutManager.init(parent);
		workset = new ReportGeneratorWorkSet();
	}

	@PostConstruct
	public void activate() {
		super.initView();
		user.addUserLocaleListener(this);
		this.locale = user.getLocale();
		for (IDatamartFilterGenerator filterGenerator : filterGeneratorMap.values()) {
			filterGenerator.addFilterChangeListener(this);
		}
		eventDispatcher.addEventReceiver(this);
	}

	@PreDestroy
	public void deactivate() {
		user.removeUserLocaleListener(this);
		for (IDatamartFilterGenerator filterGenerator : filterGeneratorMap.values()) {
			filterGenerator.removeFilterChangeListener(this);
		}
		eventDispatcher.removeEventReceiver(this);
		super.destroyView();
	}

	public StreamResource getReportStreamResource() {
		return getReportStreamResource(locale);
	}

	public StreamResource getReportStreamResource(Locale locale) {
		setLocale(locale);
		return reportResource;
	}

	@Override
	protected void createView(VerticalLayout parent) {
		initReport();
	}

	protected boolean getSelectById() {
		return false;
	}

	protected Object getSelectedId() {
		return selectedId;
	}

	public List<Parameter> getParameterList() {
		if (parameterList == null){
			parameterList = new ArrayList<>();
		}
		return parameterList;
	}

	public void setParameterList(List<Parameter> parameterList){
		this.parameterList = parameterList;
	}
	
	protected abstract List<String> getStaticData();

	public void addCss(ReportDesignHandle designHandle) {
		if (getExternalCssURI() != null) {
			CssStyleSheet css = new CssStyleSheet();
			css.setFileName(getExternalCssURI());
			css.setExternalCssURI(getExternalCssURI());
			CssStyleSheetHandle cssh = new CssStyleSheetHandle(designHandle.getModuleHandle(), css);
			try {
				designHandle.addCss(cssh);
			} catch (SemanticException e) {
				LOGGER.error(e.getLocalizedMessage());
				if (e.getCause() != null)
					LOGGER.error(" " + e.getCause());
			}
		}
	}

	protected final void initReport() {
		try {
			LOGGER.debug("BaseReport " + getClass().getSimpleName() + " initReport");
			SessionHandle session = BirtEngine.getDesignEngine().newSessionHandle(ULocale.forLocale(user.getLocale()));
			SessionHandle.setBirtResourcePath("i18n/I18N");
			if (getUsedReportDesignFilename() == null) {
				// Create a new report design.
				workset.setDesign(session.createDesign());
				// The element factory creates instances of the various BIRT
				// elements.
				workset.setFactory(workset.getDesign().getElementFactory());
				// Create a simple master page that describes how the report
				// will appear when printed.
				//
				// Note: The report will fail to load in the BIRT designer
				// unless you create a master page.
				DesignElementHandle element = workset.getFactory().newSimpleMasterPage("Page Master"); //$NON-NLS-1$
				workset.getDesign().getMasterPages().add(element);
				// add external CSS
				addCss(workset.getDesign());
				body = new BodyItem(workset);
			}
		} catch (Exception e) {
			LOGGER.error(e.getLocalizedMessage());
			if (e.getCause() != null)
				LOGGER.error(" " + e.getCause());
		}
	}

	protected final void createFilter() {
		datamartInstanceMap = getDatamartInstanceMap(user);
		for (Entry<String, IDataMart> datamartInstanceEntry : datamartInstanceMap.entrySet()) {
			if (filterGeneratorMap.get(datamartInstanceEntry.getKey()) == null) {
				DatamartFilterGenerator filterGenerator = new DatamartFilterGenerator(datamartInstanceEntry.getValue(),
						getContext(), isShowCaption(), Integer.max(10, getNumMultiRows()));
				filterGenerator.createUIFilters(layoutManager);
				filterGeneratorMap.put(datamartInstanceEntry.getKey(), filterGenerator);
			}
		}
	}

	public Map<String, IDataMart> getDatamartInstanceMap() {
		return datamartInstanceMap;
	}

	protected abstract Map<String, IDataMart> getDatamartInstanceMap(IUser user);
	
	protected abstract int getNumMultiRows();
	
	protected abstract boolean isShowCaption();

	protected abstract String getPersistenceUnitName();
	
	protected abstract boolean isParametrized();
	
	/**
	 * @return the explicit given file name of the report design file
	 */
	protected String getReportDesignFilename() {
		return null;
	}

	/**
	 * @return either the explicit given file name, any automatic generated
	 *         report design file or null
	 */
	protected final String getUsedReportDesignFilename() {
		// --- either the explicit given file name ---
		String retcode = getReportDesignFilename();
		if (retcode == null) {
			String pathName = getClass().getCanonicalName().replace(".", "/");
			if (pathName.endsWith("Report")) {
				pathName = pathName.substring(0, pathName.length() - "Report".length());
			}
			// --- or a copy of the automatic generated report file ---
			retcode = "rptdesign/" + pathName + RPTDESIGN;
			try {
				getClass().getClassLoader().getResource(retcode).openStream();
			} catch (Exception e1) {
				// --- or the automatic generated report file ---
				retcode = "rptdesign-gen/" + pathName + RPTDESIGN;
				try {
					getClass().getClassLoader().getResource(retcode).openStream();
				} catch (Exception e2) {
					retcode = null;
				}
			}
		}
		return retcode;
	}

	protected String getExternalCssURI() {
		return null;
	}

	protected String getExternalCssURIBundle() {
		return null;
	}

	protected Rendering getRenderingAs() {
		return Rendering.PDF_STREAM;
	}

	protected String getReportFilename() {
		return getClass().getSimpleName() + getTimestampPostfix() + "-" + user.getLocale().toString();
	}

	protected final String getFileExtension() {
		return getFileExtension(getRenderingAs());
	}

	final String getFileExtension(Rendering renderer) {
		switch (renderer) {
		case HTML_FILE:
		case HTML_STREAM:
			return ".html";
		case PDF_FILE:
		case PDF_STREAM:
		case PDF_PRINT_STREAM:
			return ".pdf";
		default:
			return ".unknown";
		}
	}

	protected final String getTimestampPostfix() {
		return "-" + ExtendedDate.timeStampToString();
	}

	@Override
	protected final void createComponents() {
		if (renderAllowed()){

			// remove any previous component
			if (frame != null) {
				layoutManager.getDataArea().removeComponent(frame);
				frame = null;
			}
			frame = new BrowserFrame(null, null);
			frame.setAlternateText("unable to display report");
			frame.setSizeFull();
			layoutManager.getDataArea().addComponent(frame);
			layoutManager.getDataArea().setExpandRatio(frame, 1);
	
			String filename = getReportFilename() + getFileExtension();
			reportResource = new StreamResource(this, filename);
			reportResource.setCacheTime(0);
			frame.setSource(reportResource);
		}
	}
	
	private boolean renderAllowed(){
		if (getSelectById() && getSelectedId()==null) {
			for (IDataMart datamartInstance : getDatamartInstanceMap().values()) {
				for (DatamartFilter filter : datamartInstance.getFilters()) {
					if(!filter.isOptional()) {
						return true;
					}
				} 
			} 
			return false;
		}
		return true;
	}


	@SuppressWarnings("serial")
	public void addPDFDownload(IToolbarAction target) {
		MToolBar toolbar = target.getToolBar();
		for (MToolBarElement element : toolbar.getChildren()) {
			Object widget = element.getWidget();
			if (widget instanceof Button) {
				List<String> tags = element.getTags();
				if (tags.contains(ReportActionEnum.REPORT_ACTION_DOWNLOAD_PDF.getLiteral())) {
					FileDownloader fileDownloader = new FileDownloader(
							new StreamResource(this, getReportFilename() + ".pdf") {
								@Override
								public DownloadStream getStream() {
									final DownloadStream ds = new DownloadStream(getPDF(), getMIMEType(),
											getFilename());
									ds.setBufferSize(getBufferSize());
									ds.setCacheTime(getCacheTime());
									return ds;
								}
							});
					fileDownloader.extend((Button) widget);
				}
				if (tags.contains(ReportActionEnum.REPORT_ACTION_PRINT_ON_SERVER_PDF.getLiteral())) {
					((Button) widget).addClickListener(new Button.ClickListener() {
						private static final long serialVersionUID = 3396112960709977314L;

						@Override
						public void buttonClick(ClickEvent event) {
							String reportPrinterPref = ProductConfiguration.prefs().getReportPrinter(getReportName());
							String printer = (reportPrinterPref.length()!=0)?reportPrinterPref:user.getPrintService();
							
							PdfPrintService.printReportAsPdf(BaseReport.this, printer);
						}
					});
				}
			}
		}
	}

	public void setLocale(Locale locale) {
		this.locale = locale;
	}

	public Locale getLocale() {
		return locale;
	}

	public void buildReportDesign(String fullQualifiedFileName) throws IOException {
		try {
			URL baseUrl = getClass().getClassLoader().getResource("/rptdesign-gen/.");
			if (LOGGER.isDebugEnabled())
				LOGGER.debug(baseUrl.toString());
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw));
			String exceptionDetails = sw.toString();
			LOGGER.error("{}", exceptionDetails);
		}
		workset.getDesign().saveAs(fullQualifiedFileName);
	}

	protected final Object getRunnableOrFilename() {
		if (getUsedReportDesignFilename() != null) {
			return getUsedReportDesignFilename();
		} else {
			return workset.getDesign();
		}
	}

	protected void add(DesignElementHandle handle) {
		if (handle instanceof OdaDataSourceHandle) {
			workset.getDesign().getModule().addElementID(handle.getElement());
			// design.
		} else if (handle instanceof OdaDataSetHandle) {
			workset.getDesign().getModule().addElementID(handle.getElement());
		} else {
			try {
				workset.getDesign().getBody().add(handle);
			} catch (ContentException | NameException e) {
				StringWriter sw = new StringWriter();
				e.printStackTrace(new PrintWriter(sw));
				String exceptionDetails = sw.toString();
				LOGGER.error("exception occured:{}", exceptionDetails);
			}
		}
	}

	public final ByteArrayInputStream getPDF(String path) {
		try {
			return BirtEngine.get(this, Rendering.PDF_FILE, path);
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw));
			String exceptionDetails = sw.toString();
			LOGGER.error("exception PDF occured:{}", exceptionDetails);
			return null;
		}
	}

	public final ByteArrayInputStream getHTML(String path) {
		try {
			return BirtEngine.get(this, Rendering.HTML_FILE, path);
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw));
			String exceptionDetails = sw.toString();
			LOGGER.error("exception HTML occured:{}", exceptionDetails);
			return new ByteArrayInputStream(
					(HTML_BODY + getClass().getSimpleName() + ": " + e.getLocalizedMessage() + BODY_HTML).getBytes());
		}
	}

	public ByteArrayInputStream getPDF() {
		try {
			return BirtEngine.get(this, Rendering.PDF_STREAM);
		} catch (Exception e) {
			LOGGER.debug(getClass().getSimpleName() + " PDF_STREAM: " + e.getLocalizedMessage() + BODY_HTML);
			return new ByteArrayInputStream(
					(HTML_BODY + getClass().getSimpleName() + ": " + e.getLocalizedMessage() + BODY_HTML).getBytes());
		}
	}

	public ByteArrayInputStream getPDFPrint() {
		try {
			return BirtEngine.get(this, Rendering.PDF_PRINT_STREAM);
		} catch (Exception e) {
			LOGGER.debug(getClass().getSimpleName() + " PDF_PRINT_STREAM: " + e.getLocalizedMessage() + BODY_HTML);
			return new ByteArrayInputStream(
					(HTML_BODY + getClass().getSimpleName() + ": " + e.getLocalizedMessage() + BODY_HTML).getBytes());
		}
	}

	public ByteArrayInputStream getHTML() {
		try {
			return BirtEngine.get(this, Rendering.HTML_STREAM);
		} catch (Exception e) {
			LOGGER.debug(getClass().getSimpleName() + " HTML_STREAM: " + e.getLocalizedMessage() + BODY_HTML);
			return new ByteArrayInputStream(
					(HTML_BODY + getClass().getSimpleName() + ": " + e.getLocalizedMessage() + BODY_HTML).getBytes());
		}
	}

	public ByteArrayInputStream getStream() {
		return getStream(getRenderingAs());
	}

	protected ByteArrayInputStream getStream(Rendering renderer) {
		try {
			switch (renderer) {
			case HTML_STREAM:
				return getHTML();
			case PDF_STREAM:
				return getPDF();
			case PDF_PRINT_STREAM:
				return getPDFPrint();
			default:
				return null;
			}
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw));
			String exceptionDetails = sw.toString();
			LOGGER.error("{}", exceptionDetails);
		}
		return null;
	}

	public IEclipseContext getEclipseContext() {
		return eclipseContext;
	}
	
	public IDSLMetadataService getDslMetadataService() {
		return dslMetadataService;
	}

	public IUser getUser() {
		return user;
	}

	@Focus
	public void setFocus() {
		Component parent = getParent();
		while (!(parent instanceof Panel) && parent != null) {
			parent = parent.getParent();
		}
		if (parent != null) {
			((Panel) parent).focus();
		}
	}

	public void localeChanged(Locale locale) {
		setLocale(locale);
		if (layoutManager != null) {
			layoutManager.setLabelValue(dslMetadataService.translate(locale.toLanguageTag(), getReportName()));
		}
		renderData();
	}

	@Override
	public void filterChanged(DatamartFilter changedFilter) {
		if (changedFilter != null) {
			MPerspective perspective = getContext().get(MPerspective.class);
			EventDispatcherEvent evnt = new EventDispatcherEvent(perspective, EventDispatcherCommand.SELECT, changedFilter.getName(), getClass().getCanonicalName());
			evnt.addData(changedFilter.getSelectedData());
			eventDispatcher.sendEvent(evnt);
		}
		renderData();
	}

	
	@SuppressWarnings("unchecked")
	@Override
	public void receiveEvent(final EventDispatcherEvent event) {
		switch (event.getCommand()) {
		case SELECT:
			MPerspective perspective = getContext().get(MPerspective.class);
			ArrayList<String> allowedSenderParts = (ArrayList<String>) eclipseContext.getActive(MPart.class).getTransientData().get(IPerspectiveProvider.EventDispatcherConstants.ACCEPTED_SENDERS);
    		if((event.getPerspective() == null || (perspective != null && event.getPerspective().equals(perspective))) && ((allowedSenderParts != null && allowedSenderParts.contains(event.getSender())) || allowedSenderParts == null)){ 				
				if (!event.getSender().equals(getClass().getCanonicalName())) {
					for (IDatamartFilterGenerator filterGenerator : filterGeneratorMap.values()) {
						if(filterGenerator.isPrimaryFilterId(event) && filterGenerator.selectItem(event, getSelectById())) {
							selectedId = event.getData().get(EventDispatcherDataTag.ID);
							renderData();
						}
					}
				}
			}
			break;
		case REFRESH:
			if (!event.getSender().equals(getClass().getCanonicalName()) && matchTopic(event)) {
				for(Entry<String, IDataMart> entrySet:datamartInstanceMap.entrySet()) {
					entrySet.getValue().clearCache();
				}
				renderData();
				/* must be activated if sure that the filter is to be refreshed
				for (IDatamartFilterGenerator filterGenerator : filterGeneratorMap.values()) {
					if (filterGenerator != null) {
						filterGenerator.updateFilter();
					}
				}*/
			}
			break;
		case SAVE:
		case DELETE:
			if (!event.getSender().equals(getClass().getCanonicalName())) {
				for (LEntity entity : getEntities()) {
					String entityName = EntityUtils.getFQNForLEntity(entity);
					detectDeletion(event, entity, entityName);
				}
			}
			break;
		case ACTION:
			if (!event.getSender().equals(getClass().getCanonicalName())) {
				if (event.getTopic()!=null && event.getTopic().equals(getClass().getCanonicalName())){
					Object data = event.getData().get(EventDispatcherDataTag.OBJECT);
					if (data instanceof List<?>){
						for (Object element : (List<?>)data){
							if (element instanceof Parameter){
								setParameterList((List<Parameter>)data);
							}
						}
					}
					renderData();
				}
			}
			break;
		default:
			break;
		}
	}

	private boolean matchTopic (final EventDispatcherEvent event) {
		for (LEntity entity : getEntities()) {
			String entityFQName = EntityUtils.getFQNForLEntity(entity);
			if ((event.getTopic() != null) && (event.getTopic().equals(entityFQName))){
				return true;
			}
		}
		return false;
	}
	
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void detectDeletion(final EventDispatcherEvent event, LEntity entity, String entityName) {
		if (entityName.equals(event.getTopic())) {
			for (IDataMart datamartInstance : datamartInstanceMap.values()){
				if(datamartInstance.contains(event.getData().get(EventDispatcherDataTag.ID))) {
					renderData();
					for (IDatamartFilterGenerator filterGenerator : filterGeneratorMap.values()) {
						if (filterGenerator != null) {
							filterGenerator.updateFilter();
						}
					}
				}
			}
		}
	}

	private Set<LEntity> getEntities() {
		HashSet<LEntity> entities = new HashSet<>();
		for (IDataMart datamartInstance : datamartInstanceMap.values()){
			DatamartDefinition datamart = (DatamartDefinition) dslMetadataService.getMetadata(
					datamartInstance.getClass().getCanonicalName().replace("Datamart", ""),
					DatamartDSLPackage.Literals.DATAMART_DEFINITION);
			if (datamart == null) {
				LOGGER.error("datamart with id " + datamartInstance.getClass().getCanonicalName() + " not found");
				return entities;
			}
			if (datamart.getSource() instanceof DatamartEntity) {
				entities.add(((DatamartEntity) datamart.getSource()).getEntityRef());
				for (DatamartNavigation navigation : ((DatamartEntity) datamart.getSource()).getNavigations()) {
					entities.add(navigation.getDatamartEntity().getEntityRef());
				}
			}
		}
		return entities;
	}

	public final void resetBean() {
		filterGeneratorMap.clear();
	}

	public IBlobService getBlobService() {
		return blobService;
	}

	protected abstract String getReportName();

	public abstract void applyBeanFilter(Filter filter);

	public abstract void applyBeanDto(Object dto);
	
	public static class Parameter {
		private String name;
		private Object value;
		private String displayText;
		public Parameter(String name, Object value, String displayText) {
			super();
			this.name = name;
			this.value = value;
			this.displayText = displayText;
		}
		public String getName() {
			return name;
		}
		public Object getValue() {
			return value;
		}
		public String getDisplayText() {
			return displayText;
		}
	}
}