| /* |
| * |
| * Copyright (c) 2011 - 2017 - 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 |
| * |
| * Initial contribution: |
| * Loetz GmbH & Co. KG |
| * |
| */ |
| package org.eclipse.osbp.vaaclipse.addons.softwarefactory.perspective; |
| |
| import java.net.MalformedURLException; |
| import java.net.URI; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.annotation.PostConstruct; |
| import javax.annotation.PreDestroy; |
| import javax.inject.Inject; |
| import javax.inject.Named; |
| |
| import org.eclipse.bpmn2.Bpmn2Package; |
| import org.eclipse.bpmn2.Process; |
| import org.eclipse.bpmn2.Task; |
| import org.eclipse.e4.core.contexts.IEclipseContext; |
| import org.eclipse.e4.core.di.annotations.Optional; |
| import org.eclipse.e4.core.services.events.IEventBroker; |
| import org.eclipse.e4.ui.model.application.MApplication; |
| import org.eclipse.e4.ui.model.application.ui.MElementContainer; |
| import org.eclipse.e4.ui.model.application.ui.MUIElement; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MAdvancedFactory; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MPerspectiveStack; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder; |
| import org.eclipse.e4.ui.model.application.ui.advanced.impl.AdvancedFactoryImpl; |
| import org.eclipse.e4.ui.model.application.ui.advanced.impl.AdvancedPackageImpl; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPart; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainer; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainerElement; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartStack; |
| import org.eclipse.e4.ui.model.application.ui.basic.MStackElement; |
| import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow; |
| import org.eclipse.e4.ui.model.application.ui.basic.MWindowElement; |
| import org.eclipse.e4.ui.model.application.ui.basic.impl.BasicFactoryImpl; |
| import org.eclipse.e4.ui.model.application.ui.impl.UIElementImpl; |
| import org.eclipse.e4.ui.model.application.ui.impl.UiPackageImpl; |
| import org.eclipse.e4.ui.workbench.modeling.EModelService; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.impl.AdapterImpl; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.osbp.bpm.api.BPMOperation; |
| import org.eclipse.osbp.bpm.api.BPMTaskClientPerspectiveListener; |
| import org.eclipse.osbp.bpm.api.BPMTaskEventType; |
| import org.eclipse.osbp.bpm.api.BPMTaskSummary; |
| import org.eclipse.osbp.bpm.api.BPMTaskUserEvent; |
| import org.eclipse.osbp.bpm.api.IBPMTaskClient; |
| import org.eclipse.osbp.bpm.api.IBPMTaskEventNotification; |
| import org.eclipse.osbp.bpm.api.IBlipBPMConstants; |
| import org.eclipse.osbp.bpm.api.IBlipBPMFunctionProvider; |
| import org.eclipse.osbp.bpm.api.IBlipBPMStartInfo; |
| import org.eclipse.osbp.bpm.api.IBlipBPMWorkloadModifiableItem; |
| import org.eclipse.osbp.dsl.common.datatypes.IDto; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelPackage; |
| import org.eclipse.osbp.eventbroker.EventBrokerMsg; |
| 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.metadata.IDSLMetadataService; |
| import org.eclipse.osbp.ui.api.organization.IOrganizationViewPartProvider; |
| import org.eclipse.osbp.ui.api.perspective.IPerspectiveProvider; |
| import org.eclipse.osbp.ui.api.themes.IThemeResourceService; |
| import org.eclipse.osbp.ui.api.themes.IThemeResourceService.ThemeResourceType; |
| import org.eclipse.osbp.ui.api.user.IUser; |
| import org.eclipse.osbp.ui.api.useraccess.IUserAccessService; |
| import org.eclipse.osbp.utils.vaadin.bpmn.BpmnView; |
| import org.eclipse.osbp.utils.vaadin.saiku.SaikuView; |
| import org.eclipse.osbp.vaaclipse.addons.softwarefactory.maintoolbar.IMainToolbarProvider; |
| import org.eclipse.osbp.vaaclipse.addons.softwarefactory.welcome.WelcomeView; |
| import org.eclipse.osbp.vaaclipse.publicapi.authentication.AuthenticationConstants; |
| import org.eclipse.osbp.vaadin.emf.api.IModelingContext; |
| import org.eclipse.osbp.xtext.action.ActionDSLPackage; |
| import org.eclipse.osbp.xtext.action.ActionToolbar; |
| import org.eclipse.osbp.xtext.action.TaskActionEnum; |
| import org.eclipse.osbp.xtext.blip.BlipItem; |
| import org.eclipse.osbp.xtext.blip.BlipUserTask; |
| import org.eclipse.osbp.xtext.chart.Chart; |
| import org.eclipse.osbp.xtext.chart.ChartDSLPackage; |
| import org.eclipse.osbp.xtext.chart.ChartPackage; |
| import org.eclipse.osbp.xtext.datainterchange.DataDSLPackage; |
| import org.eclipse.osbp.xtext.datainterchange.DataInterchangeGroup; |
| import org.eclipse.osbp.xtext.datainterchange.DataInterchangePackage; |
| import org.eclipse.osbp.xtext.dialogdsl.Dialog; |
| import org.eclipse.osbp.xtext.dialogdsl.DialogDSLPackage; |
| import org.eclipse.osbp.xtext.dialogdsl.DialogPackage; |
| import org.eclipse.osbp.xtext.organizationdsl.Organization; |
| import org.eclipse.osbp.xtext.organizationdsl.OrganizationDSLPackage; |
| import org.eclipse.osbp.xtext.organizationdsl.OrganizationPackage; |
| import org.eclipse.osbp.xtext.perspective.Perspective; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveBPMN; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveBrowser; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveChart; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDataInterchange; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDialog; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDslPackage; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveElement; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveEvent; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveGrid; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveKanban; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveOrganization; |
| import org.eclipse.osbp.xtext.perspective.PerspectivePackage; |
| import org.eclipse.osbp.xtext.perspective.PerspectivePart; |
| import org.eclipse.osbp.xtext.perspective.PerspectivePartStack; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveReport; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSaiku; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSashContainer; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSearch; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSelection; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveTable; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveTopology; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveView; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveWelcome; |
| import org.eclipse.osbp.xtext.reportdsl.Report; |
| import org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage; |
| import org.eclipse.osbp.xtext.reportdsl.ReportPackage; |
| import org.eclipse.osbp.xtext.table.Table; |
| import org.eclipse.osbp.xtext.table.TableDSLPackage; |
| import org.eclipse.osbp.xtext.table.TablePackage; |
| import org.eclipse.osbp.xtext.topologydsl.Topology; |
| import org.eclipse.osbp.xtext.topologydsl.TopologyDSLPackage; |
| import org.eclipse.osbp.xtext.topologydsl.TopologyPackage; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.FrameworkUtil; |
| import org.osgi.service.event.Event; |
| import org.osgi.service.event.EventHandler; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| import com.vaadin.server.Page; |
| |
| /** |
| * The Class PerspectiveProvider. Available as injectable service to create and |
| * maintain perspectives coming from the perspective DSL model. |
| */ |
| @SuppressWarnings("restriction") |
| public class PerspectiveProvider implements IPerspectiveProvider, IBPMTaskEventNotification, IEventDispatcher.Receiver, |
| BPMTaskClientPerspectiveListener { |
| |
| /** The log. */ |
| private static Logger log = LoggerFactory.getLogger(PerspectiveProvider.class); |
| |
| /** The event broker. */ |
| @Inject |
| private IEventBroker eventBroker; |
| |
| /** The app model. */ |
| @Inject |
| private MApplication appModel; |
| |
| /** The eclipse context. */ |
| @Inject |
| private IEclipseContext eclipseContext; |
| |
| @Inject |
| private IModelingContext modelingContext; |
| |
| /** The theme resource service. */ |
| @Inject |
| private IThemeResourceService themeResourceService; |
| |
| /** The current user. */ |
| @Inject |
| private IUser user; |
| |
| /** The task client. */ |
| @Inject |
| @Optional |
| private IBPMTaskClient taskClient; |
| |
| /** The task provider */ |
| @Inject |
| @Optional |
| private IBlipBPMFunctionProvider taskProvider; |
| |
| /** The dsl metadata service. */ |
| @Inject |
| private IDSLMetadataService dslMetadataService; |
| |
| /** The toolbar provider. */ |
| @Inject |
| @Named("MainToolbar") |
| private IMainToolbarProvider toolbarProvider; |
| |
| /** The optional org URI provider. */ |
| @Inject |
| @Optional |
| private IOrganizationViewPartProvider optionalOrgURIProvider; |
| |
| /** The event dispatcher. */ |
| @Inject |
| private IEventDispatcher eventDispatcher; |
| |
| /** The do logout. */ |
| private EventHandler doLogout; |
| |
| /** The trimmed window. */ |
| private MTrimmedWindow trimmedWindow = null; |
| |
| /** The model service. */ |
| private EModelService modelService; |
| |
| /** The perspectives. */ |
| private Map<String, MPerspective> perspectives = new HashMap<>(); |
| |
| /** The perspective tasks. */ |
| private Map<BPMTaskSummary, String> perspectiveTasks = new HashMap<>(); |
| |
| @Inject |
| private IUserAccessService userAccessService; |
| |
| /** |
| * Inits the PerspectiveSupport. |
| */ |
| @PostConstruct |
| protected void init() { |
| perspectives.clear(); |
| perspectiveTasks.clear(); |
| modelService = eclipseContext.get(EModelService.class); |
| eventDispatcher.addEventReceiver(this); |
| subscribe(); |
| } |
| |
| /** |
| * Inits the perspective stack. |
| * |
| * @return the current perspective stack or null |
| */ |
| private MPerspectiveStack initPerspectiveStack() { |
| log.trace("{}","analyze app model"); |
| trimmedWindow = (MTrimmedWindow) appModel.getChildren().get(0); |
| for (MWindowElement element : trimmedWindow.getChildren()) { |
| if (element instanceof MPerspectiveStack) { |
| return addToolbarAdapter((MPerspectiveStack) element); |
| } |
| } |
| return null; |
| } |
| |
| private MPerspectiveStack addToolbarAdapter(MPerspectiveStack stack) { |
| // handle toolbar |
| ((EObject) stack).eAdapters().add(new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification notification) { |
| if (notification.getEventType() == Notification.SET && notification.getFeatureID( |
| MElementContainer.class) == AdvancedPackageImpl.PERSPECTIVE_STACK__SELECTED_ELEMENT) { |
| log.trace("{}","perspective stack changed selection"); |
| if (notification.getNewValue() == null && notification.getOldValue() != null && PerspectiveProvider |
| .isPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId())) { |
| closePerspective(PerspectiveProvider |
| .fromPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId())); |
| } |
| // perspective changed |
| if (notification.getNewValue() == null && notification.getOldValue() != null) { |
| // deactivate old perspective - hide its toolBar |
| String perspectiveId = PerspectiveProvider |
| .fromPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId()); |
| toolbarProvider.setActive(perspectiveId, false); |
| } |
| if (notification.getNewValue() != null && notification.getOldValue() == null) { |
| // activate new perspective - show its toolbar |
| String perspectiveId = PerspectiveProvider |
| .fromPerspectiveElementId(((MPerspective) notification.getNewValue()).getElementId()); |
| toolbarProvider.setActive(perspectiveId, true); |
| } |
| } |
| } |
| }); |
| return stack; |
| } |
| |
| /** |
| * Checks if is our perspective element id. |
| * |
| * @param elementId |
| * the element id |
| * @return true, if is perspective element id |
| */ |
| protected static boolean isPerspectiveElementId(String perspectiveId) { |
| return perspectiveId.startsWith(IPerspectiveProvider.E4Constants.PERSPECTIVE_PREFIX); |
| } |
| |
| /** |
| * converts a name to a perspective element id. |
| * |
| * @param perspectiveId |
| * the perspective id |
| * @return the string |
| */ |
| protected static String toPerspectiveElementId(String perspectiveId) { |
| return IPerspectiveProvider.E4Constants.PERSPECTIVE_PREFIX + perspectiveId; |
| } |
| |
| /** |
| * converts from perspective element id to a name. |
| * |
| * @param elementId |
| * the element id |
| * @return the string |
| */ |
| protected static String fromPerspectiveElementId(String elementId) { |
| return elementId.substring(IPerspectiveProvider.E4Constants.PERSPECTIVE_PREFIX.length()); |
| } |
| |
| /** |
| * Add the perspective identified by perspectiveId to PerspectiveStack. |
| * |
| * @param perspectiveModel |
| * - the model everything is based on |
| * @param perspectiveId |
| * - unique identifier for a perspective in the model |
| * @return the m perspective |
| */ |
| private MPerspective createPerspective(MPerspectiveStack stack, Perspective perspectiveModel, |
| String perspectiveId) { |
| MPerspective perspective = AdvancedFactoryImpl.eINSTANCE.createPerspective(); |
| |
| perspective.getTags().add(IPerspectiveProvider.E4Constants.TAG_REMOVE_ON_CLOSE); |
| perspective.getTags().add(IPerspectiveProvider.E4Constants.TAG_NOT_IN_OPEN_PERSPECTIVE_DIALOG); |
| |
| String newPerspectiveId = toPerspectiveElementId(perspectiveId); |
| int offset = 0; |
| while(isPerspectiveIdAlreadyInUse(stack, newPerspectiveId)){ |
| newPerspectiveId = toPerspectiveElementId(perspectiveId + offset++); |
| } |
| |
| perspective.setElementId(newPerspectiveId); |
| perspective.setLabel(perspectiveModel.getName()); |
| perspective.setVisible(true); |
| perspective.setToBeRendered(true); |
| perspective.setIconURI(themeResourceService.getThemeURI(perspectiveModel.getIconURI(), ThemeResourceType.ICON)); |
| perspective.setAccessibilityPhrase(perspectiveModel.getAccessibilityPhrase()); |
| if (perspectiveModel.isDescription()) { |
| perspective.setTooltip(perspectiveModel.getDescriptionValue().replace("\"", "")); |
| } |
| |
| // iterate over all elements |
| traverseModel(perspective, perspectiveModel); |
| if (!perspective.getChildren().isEmpty()) { |
| MPartSashContainerElement firstElement = perspective.getChildren().get(0); |
| if (firstElement instanceof MPartSashContainer) { |
| // create placeholder for designer |
| // |
| MPlaceholder designerPH = MAdvancedFactory.INSTANCE.createPlaceholder(); |
| MUIElement area = modelService.find("org.eclipse.osbp.model.area.designer", stack); |
| designerPH.setRef(area); |
| designerPH.setContainerData("40"); |
| designerPH.setVisible(modelingContext.isDesignMode()); |
| designerPH.setToBeRendered(modelingContext.isDesignMode()); |
| designerPH.getTags().add("designer:autoVisible"); |
| |
| ((MPartSashContainer) firstElement).getChildren().add(designerPH); |
| } |
| } |
| return perspective; |
| } |
| |
| private boolean isPerspectiveIdAlreadyInUse(MPerspectiveStack stack, String perspectiveId){ |
| if(stack != null && stack.getChildren() != null && !stack.getChildren().isEmpty() |
| && perspectiveId != null && !perspectiveId.isEmpty()){ |
| for(MPerspective perspective : stack.getChildren()){ |
| if(perspective.getElementId().equals(perspectiveId)){ |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Register context. |
| * |
| * @param map |
| * the map |
| * @param task |
| * the task |
| */ |
| private void registerContext(Map<String, Object> map, PerspectiveFound perspectiveFound) { |
| String workloadDtoFqn = null; |
| IDto workloadDto = null; |
| IBlipBPMStartInfo startInfo = null; |
| IBlipBPMWorkloadModifiableItem task = null; |
| Class<?> operativeDtoClass = null; |
| String operativeDtoFqn = null; |
| List<IDto> operativeDtos = null; |
| |
| if (taskClient != null && perspectiveFound.blipTask != null) { |
| startInfo = taskProvider.getStartInfo(perspectiveFound.taskSummary); |
| if (startInfo != null) { |
| task = startInfo.getWorkloadMofifiableBpmItemForBlipId(perspectiveFound.blipTask.getName()); |
| if (task != null) { |
| workloadDtoFqn = taskClient.getWorkloadDtoFqn(perspectiveFound.taskSummary); |
| workloadDto = taskClient.getWorkloadDto(perspectiveFound.taskSummary); |
| if(workloadDtoFqn == null || workloadDto == null) { |
| workloadDtoFqn = startInfo.getWorkloadDtoFqn(); |
| workloadDto = startInfo.createWorkloadDto(); |
| taskClient.setWorkloadDtoFqn(perspectiveFound.taskSummary, workloadDtoFqn); |
| taskClient.setWorkloadDto(perspectiveFound.taskSummary, workloadDto); |
| } |
| operativeDtos = task.getOperativeDtos(workloadDto); |
| operativeDtoClass = task.getOperativeDtoClass(); |
| if (operativeDtoClass != null) { |
| operativeDtoFqn = operativeDtoClass.getCanonicalName(); |
| } else { |
| operativeDtoClass = null; |
| } |
| } |
| } |
| } |
| map.put(IBlipBPMConstants.VARIABLE_PROCESS_START_INFO, startInfo); |
| map.put(IBlipBPMConstants.VARIABLE_PROCESS_WORKLOAD_DTO_FQN, workloadDtoFqn); |
| map.put(IBlipBPMConstants.VARIABLE_PROCESS_WORKLOAD_DTO, workloadDto); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_JBPM_SUMMARY, perspectiveFound.taskSummary); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_BLIP_ITEM, perspectiveFound.blipTask); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_BPM2_ITEM, perspectiveFound.bpmTask); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_START_INFO, task); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTO_CLASS, operativeDtoClass); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTO_FQN, operativeDtoFqn); |
| map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTOS, operativeDtos); |
| } |
| |
| /** |
| * for every model element that can hold children, traverse recursively the |
| * model. |
| * |
| * @param parent |
| * - the parent e4 node to which the next child is added |
| * @param modelElement |
| * - the current element which is traversed |
| */ |
| private void traverseModel(MElementContainer<?> parent, EObject modelElement) { |
| if (modelElement instanceof Perspective) { |
| log.trace("{}","traverse model perspective"); |
| Perspective perspectiveModel = (Perspective) modelElement; |
| for (PerspectiveElement element : perspectiveModel.getElements()) { |
| addElement(parent, element); |
| } |
| } else if (modelElement instanceof PerspectiveSashContainer) { |
| log.trace("{}","traverse model sashcontainer"); |
| PerspectiveSashContainer sashModel = (PerspectiveSashContainer) modelElement; |
| for (PerspectiveElement element : sashModel.getElements()) { |
| addElement(parent, element); |
| } |
| } else if (modelElement instanceof PerspectivePartStack) { |
| log.trace("{}","traverse model perspectivestack"); |
| PerspectivePartStack stackModel = (PerspectivePartStack) modelElement; |
| for (PerspectiveElement element : stackModel.getElements()) { |
| addElement(parent, element); |
| } |
| } |
| log.trace("{}","traverse finished"); |
| } |
| |
| /** |
| * for PerspectiveSashContainer create an e4 element by it's factory. |
| * |
| * @param parent |
| * - the parent e4 node to which the next child is added |
| * @param element |
| * - the current element which is traversed |
| */ |
| @SuppressWarnings("unchecked") |
| private void addElementPerspectiveSashContainer(MElementContainer<?> parent, EObject element) { |
| PerspectiveSashContainer sashModel = (PerspectiveSashContainer) element; |
| MPartSashContainer sashContainer = BasicFactoryImpl.eINSTANCE.createPartSashContainer(); |
| sashContainer.setAccessibilityPhrase(sashModel.getAccessibilityPhrase()); |
| addAdapter(sashContainer); |
| sashContainer.setElementId(sashModel.getElementId()); |
| |
| sashContainer.setHorizontal("HORIZONTAL".equals(sashModel.getOrientation().getName())); |
| sashContainer.setVisible(true); |
| sashContainer.setParent((MElementContainer<MUIElement>) parent); |
| if (parent instanceof MPerspective) { |
| ((MPerspective) parent).getChildren().add(sashContainer); |
| } else if (parent instanceof MPartSashContainer) { |
| ((MPartSashContainer) parent).getChildren().add(sashContainer); |
| } |
| |
| // go deeper |
| traverseModel(sashContainer, element); |
| // set selected references |
| for (MPartSashContainerElement child : sashContainer.getChildren()) { |
| if (sashModel.getSelectedElement() != null |
| && child.getElementId().equals(sashModel.getSelectedElement().getElementId())) { |
| sashContainer.setSelectedElement(child); |
| break; |
| } |
| } |
| |
| // DON´T MOVE THE FOLLOWING CODE LINES !!!! |
| // The reading of the container data from the user properties in |
| // 'getElementContainerData' below |
| // requires the element id and the parent information set to the part |
| // above. |
| String elementContainerData = getElementContainerData(sashContainer); |
| if (elementContainerData != null) { |
| sashContainer.setContainerData(elementContainerData); |
| } else { |
| sashContainer.setContainerData( |
| sashModel.getContainerData() != null ? sashModel.getContainerData().replace("\"", "") : "50"); |
| } |
| |
| } |
| |
| /** |
| * for addElementPerspectivePartStack create an e4 element by it's factory. |
| * |
| * @param parent |
| * - the parent e4 node to which the next child is added |
| * @param element |
| * - the current element which is traversed |
| */ |
| @SuppressWarnings("unchecked") |
| private void addElementPerspectivePartStack(MElementContainer<?> parent, EObject element) { |
| PerspectivePartStack stackModel = (PerspectivePartStack) element; |
| MPartStack stack = BasicFactoryImpl.eINSTANCE.createPartStack(); |
| stack.setAccessibilityPhrase(stackModel.getAccessibilityPhrase()); |
| addAdapter(stack); |
| stack.setElementId(stackModel.getElementId()); |
| stack.setVisible(true); |
| stack.setParent((MElementContainer<MUIElement>) parent); |
| if(stackModel.getSynchronize() != null) { |
| stack.getTransientData().put(IPerspectiveProvider.EventDispatcherConstants.SYNCHRONIZE_WITH, stackModel.getSynchronize().getElementId()); |
| } |
| if (parent instanceof MPerspective) { |
| ((MPerspective) parent).getChildren().add(stack); |
| } else if (parent instanceof MPartSashContainer) { |
| ((MPartSashContainer) parent).getChildren().add(stack); |
| } |
| // go deeper |
| traverseModel(stack, element); |
| // set selected references |
| for (MStackElement child : stack.getChildren()) { |
| if (stackModel.getSelectedElement() != null |
| && child.getElementId().equals(stackModel.getSelectedElement().getElementId())) { |
| stack.setSelectedElement(child); |
| break; |
| } |
| } |
| |
| // DON´T MOVE THE FOLLOWING CODE LINES !!!! |
| // The reading of the container data from the user properties in |
| // 'getElementContainerData' below |
| // requires the element id and the parent information set to the part |
| // above. |
| String elementContainerData = getElementContainerData(stack); |
| if (elementContainerData != null) { |
| stack.setContainerData(elementContainerData); |
| } else { |
| stack.setContainerData( |
| stackModel.getContainerData() != null ? stackModel.getContainerData().replace("\"", "") : "50"); |
| } |
| |
| } |
| |
| private String getElementContainerData(MUIElement element) { |
| return (String) user.getProperty(getFQNKey(element)); |
| } |
| |
| /** |
| * for addElementPerspectivePart create an e4 element by it's factory. |
| * |
| * @param parent |
| * - the parent e4 node to which the next child is added |
| * @param element |
| * - the current element which is traversed |
| */ |
| @SuppressWarnings("unchecked") |
| private void addElementPerspectivePart(MElementContainer<?> parent, EObject element) { |
| PerspectivePart partModel = (PerspectivePart) element; |
| MPart part = BasicFactoryImpl.eINSTANCE.createPart(); |
| part.setAccessibilityPhrase(partModel.getAccessibilityPhrase()); |
| addAdapter(part); |
| part.setElementId(partModel.getElementId()); |
| |
| part.setIconURI(partModel.getIconURI()); |
| part.setLabel(partModel.getElementId()); |
| part.setVisible(true); |
| part.setCloseable(partModel.isIsClosable()); |
| |
| part.getPersistedState().put(IPerspectiveProvider.E4Constants.OSBP_NS_URI, getNsURI(partModel.getView())); |
| part.getPersistedState().put(IPerspectiveProvider.E4Constants.OSBP_FQN, getFQN(partModel.getView())); |
| |
| EObject container = partModel.eContainer(); |
| while (!(container instanceof Perspective)) { |
| container = container.eContainer(); |
| } |
| Perspective perspective = (Perspective) container; |
| supplyAcceptedSenders(partModel, part, perspective); |
| |
| String flavor = getFlavor(partModel.getView()); |
| if (flavor != null) { |
| part.getPersistedState().put(IPerspectiveProvider.E4Constants.OSBP_FLAVOR, flavor); |
| } |
| |
| part.setParent((MElementContainer<MUIElement>) parent); |
| if (parent instanceof MPerspective) { |
| ((MPerspective) parent).getChildren().add(part); |
| } else if (parent instanceof MPartSashContainer) { |
| ((MPartSashContainer) parent).getChildren().add(part); |
| } else if (parent instanceof MPartStack) { |
| ((MPartStack) parent).getChildren().add(part); |
| } |
| if (partModel.getView() != null) { |
| String contributionURI = getContributionURI(part, partModel); |
| log.trace("set contribution URI for part {} to {} ", part.getElementId(), |
| contributionURI); |
| part.setContributionURI(contributionURI); |
| } |
| |
| // DON´T MOVE THE FOLLOWING CODE LINES !!!! |
| // The reading of the container data from the user properties in |
| // 'getElementContainerData' below |
| // requires the element id and the parent information set to the part |
| // above. |
| String elementContainerData = getElementContainerData(part); |
| if (elementContainerData != null) { |
| part.setContainerData(elementContainerData); |
| } else { |
| part.setContainerData( |
| partModel.getContainerData() != null ? partModel.getContainerData().replace("\"", "") : "50"); |
| } |
| |
| } |
| |
| private void supplyAcceptedSenders(PerspectivePart partModel, MPart part, Perspective perspective) { |
| if (perspective.getEventmanager() != null && perspective.getEventmanager().getEvents() != null |
| && !perspective.getEventmanager().getEvents().isEmpty()) { |
| for (PerspectiveEvent event : perspective.getEventmanager().getEvents()) { |
| if (event.getTarget().getElementId().equals(partModel.getElementId())) { |
| ArrayList<String> senders = new ArrayList<>(); |
| senders.add(getViewPartID(partModel.getView())); |
| for(PerspectivePart source : event.getAllowedsources()){ |
| senders.add(getViewPartID(source.getView())); |
| } |
| part.getTransientData().put(IPerspectiveProvider.EventDispatcherConstants.ACCEPTED_SENDERS,senders); |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the corresponding viewid or fully qualified name of a PerspectivePart, which is needed |
| * for EventDispatcherEvent's recognition within a perspective. |
| * @param viewModel the {@link PerspectiveView} view model of the PerspectivePart |
| * @return {@link String} the view id or fully qualified name |
| */ |
| private String getViewPartID(PerspectiveView viewModel) { |
| log.trace("{}","get viewpart id"); |
| if (viewModel instanceof PerspectiveDialog) { |
| return dslMetadataService.getECViewId(((PerspectiveDialog) viewModel).getRef()); |
| } |
| else if (viewModel instanceof PerspectiveTable) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveTable) viewModel).getRef()); |
| } |
| else if (viewModel instanceof PerspectiveSelection) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveSelection) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveGrid) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveGrid) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveChart) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveChart) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveReport) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveReport) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveOrganization) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveOrganization) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveTopology) { |
| return dslMetadataService.getFullyQualifiedName(((PerspectiveTopology) viewModel).getRef()); |
| } else if (viewModel instanceof PerspectiveDataInterchange) { |
| return getFQN(viewModel); |
| } else if (viewModel instanceof PerspectiveBPMN) { |
| String className = BpmnView.class.getCanonicalName(); |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.BPMN); |
| } else if (viewModel instanceof PerspectiveWelcome) { |
| String className = WelcomeView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(WelcomeView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveSearch) { |
| String className = SearchView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(SearchView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveKanban) { |
| String className = KanbanView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(KanbanView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveBrowser) { |
| String className = BrowserView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(BrowserView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveSaiku) { |
| String className = SaikuView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(SaikuView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } |
| else { |
| return null; |
| } |
| } |
| |
| /** |
| * for every model element create an e4 element by it's factory. |
| * |
| * @param parent |
| * - the parent e4 node to which the next child is added |
| * @param element |
| * - the current element which is traversed |
| */ |
| private void addElement(MElementContainer<?> parent, EObject element) { |
| if(dslMetadataService.isPerspectiveElementAuthorized(element, userAccessService)) { |
| if (element instanceof PerspectiveSashContainer) { |
| log.trace("{}","add sashcontainer"); |
| addElementPerspectiveSashContainer(parent, element); |
| } else if (element instanceof PerspectivePartStack) { |
| log.trace("{}","add partstack"); |
| addElementPerspectivePartStack(parent, element); |
| } else if (element instanceof PerspectivePart) { |
| log.trace("{}","add part"); |
| addElementPerspectivePart(parent, element); |
| } |
| } |
| } |
| |
| /** |
| * create the view connected to a part. |
| * |
| * @param viewModel |
| * - the model of the view |
| * @return null or the classURI |
| */ |
| private String getContributionURI(MPart part, PerspectivePart partModel) { // NOSONAR |
| log.trace("{}","get contributionURI"); |
| PerspectiveView viewModel = partModel.getView(); |
| if (viewModel instanceof PerspectiveTable) { |
| String className = getFQN(viewModel)+"Table"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.TABLE); |
| } else if (viewModel instanceof PerspectiveSelection) { |
| String className = getFQN(viewModel)+"Select"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.TABLE); |
| } else if (viewModel instanceof PerspectiveGrid) { |
| String className = getFQN(viewModel)+"Grid"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.TABLE); |
| } else if (viewModel instanceof PerspectiveChart) { |
| String className = getFQN(viewModel)+"Chart"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.CHART); |
| } else if (viewModel instanceof PerspectiveReport) { |
| String className = getFQN(viewModel)+"Report"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.REPORT); |
| } else if (viewModel instanceof PerspectiveOrganization) { |
| if (optionalOrgURIProvider != null) { |
| return optionalOrgURIProvider.getViewPartURI(); |
| } else { |
| return null; |
| } |
| } else if (viewModel instanceof PerspectiveTopology) { |
| String className = getFQN(viewModel)+"Topology"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.TOPOLOGY); |
| } else if (viewModel instanceof PerspectiveDialog) { |
| part.getTransientData().put(IPerspectiveProvider.TRANSIENT_DIALOG_MODEL, ((PerspectiveDialog) viewModel).getRef()); |
| return dslMetadataService.getClassURI(DialogProvider.class.getCanonicalName(), IPerspectiveProvider.PerspectiveViewType.DIALOG); |
| } else if (viewModel instanceof PerspectiveDataInterchange) { |
| String className = getFQN(viewModel)+"TriggerView"; |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.DATAINTERCHANGE); |
| } else if (viewModel instanceof PerspectiveBPMN) { |
| String className = BpmnView.class.getCanonicalName(); |
| return dslMetadataService.getClassURI(className, IPerspectiveProvider.PerspectiveViewType.BPMN); |
| } else if (viewModel instanceof PerspectiveWelcome) { |
| String className = WelcomeView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(WelcomeView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveSaiku) { |
| String className = SaikuView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(SaikuView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveSearch) { |
| part.getTransientData().put(IPerspectiveProvider.FilterConstants.FILTER_DTO_CLASS, |
| ((PerspectiveSearch) viewModel).getDtoRef()); |
| part.getTransientData().put(IPerspectiveProvider.FilterConstants.FILTER_DEPTH, |
| ((PerspectiveSearch) viewModel).getDepth()); |
| part.getTransientData().put(IPerspectiveProvider.FilterConstants.FILTER_COLUMNS, |
| Math.max(1, ((PerspectiveSearch) viewModel).getFilterCols())); |
| String className = SearchView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(SearchView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveKanban) { |
| part.getTransientData().put(IPerspectiveProvider.KanbanConstants.DTO, |
| ((PerspectiveKanban) viewModel).getDtoRef()); |
| part.getTransientData().put(IPerspectiveProvider.KanbanConstants.DIALOG, |
| ((PerspectiveKanban) viewModel).getDialogRef()); |
| part.getTransientData().put(IPerspectiveProvider.KanbanConstants.CARD, |
| ((PerspectiveKanban) viewModel).getCardRef()); |
| String className = KanbanView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(KanbanView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } else if (viewModel instanceof PerspectiveBrowser) { |
| String url = ""; |
| if (((PerspectiveBrowser) viewModel).isCubeView()){ |
| int port = ProductConfiguration.prefs().getCubeViewPort(); |
| URI location = Page.getCurrent().getLocation(); |
| try { |
| url = new URL(location.getScheme(), location.getHost(), port, "").toString(); |
| } catch (MalformedURLException e) { |
| log.error("cube view URL is malformed!", e); |
| } |
| } else { |
| url = ((PerspectiveBrowser) viewModel).getUrl(); |
| } |
| part.getTransientData().put(IPerspectiveProvider.BrowserConstants.URL, url); |
| String className = BrowserView.class.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(BrowserView.class); |
| return E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/" + className; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the FQN for the content of the view. |
| * |
| * @param viewModel |
| * - the model of the view |
| * @return null or the FQN |
| */ |
| private String getFQN(PerspectiveView viewModel) { // NOSONAR |
| log.trace("{}","get FQN"); |
| if (viewModel instanceof PerspectiveTable) { |
| Table object = ((PerspectiveTable) viewModel).getRef(); |
| TablePackage pkg = (TablePackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveSelection) { |
| Table object = ((PerspectiveSelection) viewModel).getRef(); |
| TablePackage pkg = (TablePackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveGrid) { |
| Table object = ((PerspectiveGrid) viewModel).getRef(); |
| TablePackage pkg = (TablePackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveChart) { |
| Chart object = ((PerspectiveChart) viewModel).getRef(); |
| ChartPackage pkg = (ChartPackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveReport) { |
| Report object = ((PerspectiveReport) viewModel).getRef(); |
| ReportPackage pkg = (ReportPackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveOrganization) { |
| Organization object = ((PerspectiveOrganization) viewModel).getRef(); |
| OrganizationPackage pkg = (OrganizationPackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveTopology) { |
| Topology object = ((PerspectiveTopology) viewModel).getRef(); |
| TopologyPackage pkg = (TopologyPackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveDialog) { |
| Dialog object = ((PerspectiveDialog) viewModel).getRef(); |
| DialogPackage pkg = (DialogPackage) object.eContainer(); |
| return pkg == null ? "" : toFQN(pkg.getName(), object.getName()); |
| } else if (viewModel instanceof PerspectiveDataInterchange) { |
| DataInterchangeGroup group = ((PerspectiveDataInterchange) viewModel).getRef(); |
| DataInterchangePackage pkg = (DataInterchangePackage) group.eContainer(); |
| return toFQN(pkg.getName(), group.getName()); |
| } |
| return null; |
| } |
| |
| /** |
| * Return the NS-URI for the content of the view. Used as a content type |
| * marker. |
| * |
| * @param viewModel |
| * the view model |
| * @return the ns uri |
| */ |
| private String getNsURI(PerspectiveView viewModel) { // NOSONAR |
| log.trace("{}","get NsURI"); |
| if (viewModel instanceof PerspectiveTable) { |
| return TableDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveSelection) { |
| return TableDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveGrid) { |
| return TableDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveChart) { |
| return ChartDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveReport) { |
| return ReportDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveOrganization) { |
| return OrganizationDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveTopology) { |
| return TopologyDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveDialog) { |
| return DialogDSLPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveBPMN) { |
| return Bpmn2Package.eNS_URI; |
| } else if (viewModel instanceof PerspectiveKanban) { |
| return ExtensionModelPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveBrowser) { |
| return ExtensionModelPackage.eNS_URI; |
| } else if (viewModel instanceof PerspectiveDataInterchange) { |
| return DataDSLPackage.eNS_URI; |
| } |
| return null; |
| } |
| |
| private String getFlavor(PerspectiveView viewModel) { // NOSONAR |
| if (viewModel instanceof PerspectiveTable) { |
| return "table"; |
| } else if (viewModel instanceof PerspectiveGrid) { |
| return "grid"; |
| } |
| return null; |
| } |
| |
| /** |
| * To fqn. |
| * |
| * @param pkg |
| * the pkg |
| * @param name |
| * the name |
| * @return the string |
| */ |
| private String toFQN(String pkg, String name) { |
| return pkg + "." + name; |
| } |
| |
| /** |
| * Subscribe. |
| */ |
| protected void subscribe() { |
| if (taskClient != null) { |
| taskClient.registerPerspectiveListener(this); |
| } |
| createEventHandlers(); |
| eventBroker.subscribe(AuthenticationConstants.Events.Authentication.PRE_LOGOUT, doLogout); |
| } |
| |
| /** |
| * Unsubscribe. |
| */ |
| @PreDestroy |
| protected void unsubscribe() { |
| taskClient.unsubscribeTaskEventNotification(this); |
| if (taskClient != null) { |
| taskClient.unregisterPerspectiveListener(this); |
| } |
| } |
| |
| /** |
| * Creates the event handlers. |
| */ |
| private void createEventHandlers() { |
| doLogout = (Event event) -> { |
| log.trace("{}","logout pending"); |
| suspendAllTasks(); |
| }; |
| } |
| |
| /** |
| * Suspend all pending tasks while user pressed logout or closed browser. |
| * |
| */ |
| private void suspendAllTasks() { |
| for (BPMTaskSummary summary : perspectiveTasks.keySet()) { |
| log.debug("suspend task {}", summary.getId()); |
| taskClient.operations(summary.getId(), user, null, BPMOperation.Suspend); |
| } |
| } |
| |
| /** |
| * Tries to find the perspective model using the perspective builder |
| * service. |
| * |
| * @param perspectiveId |
| * - the id of the perspective used in the model |
| * @return the perspective |
| */ |
| protected PerspectiveFound findPerspective(String perspectiveId) { |
| log.trace("{}","find perspective model by id"); |
| return new PerspectiveFound(null, |
| (Perspective) dslMetadataService.getMetadata(perspectiveId, PerspectiveDslPackage.Literals.PERSPECTIVE), |
| null, null, perspectiveId); |
| } |
| |
| private final class PerspectiveFound { |
| public final BPMTaskSummary taskSummary; |
| public final Perspective perspective; |
| public final BlipItem blipTask; |
| public final Task bpmTask; |
| public final String fqn; |
| |
| protected PerspectiveFound(BPMTaskSummary taskSummary, Perspective perspective, BlipItem blipTask, |
| Task bpmTask, String fqn) { |
| this.taskSummary = taskSummary; |
| this.perspective = perspective; |
| this.blipTask = blipTask; |
| this.bpmTask = bpmTask; |
| this.fqn = fqn; |
| } |
| } |
| |
| /** |
| * Tries to find the perspective model using the perspective builder |
| * service. |
| * |
| * @param task |
| * the task |
| * @return the perspective |
| */ |
| protected PerspectiveFound findPerspective(BPMTaskSummary taskSummary) { |
| log.trace("{}","find perspective model by task"); |
| for (EObject eObj : dslMetadataService.getAll(PerspectiveDslPackage.Literals.PERSPECTIVE)) { |
| if ((((Perspective) eObj).getProcess() != null) && (((Perspective) eObj).getUserTask() != null)) { |
| Process process = ((Perspective) eObj).getProcess().getProcess(); |
| BlipUserTask blipTask = ((Perspective) eObj).getUserTask(); |
| if ((process != null) && (process.getId().equals(taskSummary.getProcessId()))) { |
| Task bpmTask = blipTask.getTask(); |
| if ((bpmTask != null) && bpmTask.getName().equals(taskSummary.getName())) { |
| return new PerspectiveFound(taskSummary, (Perspective) eObj, blipTask, bpmTask, ((PerspectivePackage) eObj.eContainer()).getName()+"."+((Perspective) eObj).getName()); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Tries to find the action toolbar model using the action builder service. |
| * |
| * @param toolbarId |
| * the toolbar id |
| * @return the action toolbar |
| */ |
| protected ActionToolbar findToolbar(String toolbarId) { |
| log.trace("{}","find toolbar model"); |
| return (ActionToolbar) dslMetadataService.getMetadata(toolbarId, ActionDSLPackage.Literals.ACTION_TOOLBAR); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.bpm.api.IBPMTaskEventNotification#notifyTaskEvent(org |
| * .jbpm.task.event.entity.TaskEventType, |
| * org.jbpm.task.event.entity.TaskUserEvent) |
| */ |
| @Override |
| public void notifyTaskEvent(BPMTaskEventType type, BPMTaskUserEvent event) { |
| closePerspective(event.getTaskId()); |
| } |
| |
| @Override |
| public void notifyProcessCompletedEvent() { |
| // NOP |
| } |
| |
| @Override |
| public void receiveEvent(EventDispatcherEvent event) { |
| if (event.getCommand() == EventDispatcherCommand.ACTION |
| && event.getData().containsKey(EventDispatcherDataTag.BUTTON_ID) |
| && event.getData().get(EventDispatcherDataTag.BUTTON_ID) instanceof TaskActionEnum |
| && event.getData().containsKey(EventDispatcherDataTag.TASK_ID) |
| && event.getData().get(EventDispatcherDataTag.TASK_ID) instanceof Long) { |
| Object buttonId = event.getData().get(EventDispatcherDataTag.BUTTON_ID); |
| TaskActionEnum enumId = (TaskActionEnum) buttonId; |
| Long taskId = (Long) event.getData().get(EventDispatcherDataTag.TASK_ID); |
| if (enumId == TaskActionEnum.TASK_ACTION_DELEGATE) { |
| log.debug("dispatch action received in PerspectiveSupport for {}", TaskActionEnum.TASK_ACTION_DELEGATE.getLiteral()); |
| } else { |
| taskClient.operations(taskId, user, null, BPMOperation.valueOf(enumId.getLiteral())); |
| } |
| } |
| if (event.getCommand() == EventDispatcherCommand.REFRESH && |
| event.getTopic().equals("reloadModel.perspective")) { |
| Map<BPMTaskSummary,String> taskToReload = new HashMap<>(perspectiveTasks); |
| for(BPMTaskSummary summary:taskToReload.keySet()) { |
| closePerspective(summary); |
| } |
| Map<String,MPerspective> toReload = new HashMap<>(perspectives); |
| for(String p:toReload.keySet()) { |
| closePerspective(p); |
| } |
| for(BPMTaskSummary summary:taskToReload.keySet()) { |
| openPerspective(summary); |
| } |
| for(String perspectiveId:toReload.keySet()) { |
| openPerspective(perspectiveId); |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.perspective.IPerspectiveProvider#openPerspective( |
| * java.lang.String, java.lang.String, java.lang.Class) |
| */ |
| @Override |
| public void openPerspective(String elementId, String labelName, Class<?> clazz) { |
| MPerspectiveStack stack = initPerspectiveStack(); |
| if (stack != null) { |
| // bring to top if already contained in model |
| for (MPerspective perspective : stack.getChildren()) { |
| if ((toPerspectiveElementId(elementId)).equals(perspective.getElementId())) { |
| modelService.bringToTop(perspective); |
| return; |
| } |
| } |
| MPerspective perspective = AdvancedFactoryImpl.eINSTANCE.createPerspective(); |
| |
| perspective.getTags().add(IPerspectiveProvider.E4Constants.TAG_REMOVE_ON_CLOSE); |
| perspective.getTags().add(IPerspectiveProvider.E4Constants.TAG_NOT_IN_OPEN_PERSPECTIVE_DIALOG); |
| |
| perspective.setElementId(toPerspectiveElementId(elementId)); |
| perspective.setLabel(labelName); |
| perspective.setVisible(true); |
| perspective.setToBeRendered(true); |
| perspective.setIconURI(themeResourceService.getThemeURI("osbee", ThemeResourceType.ICON)); |
| MPart part = BasicFactoryImpl.eINSTANCE.createPart(); |
| part.setVisible(true); |
| part.setCloseable(false); |
| perspective.getChildren().add(part); |
| String className = clazz.getCanonicalName(); |
| Bundle bundle = FrameworkUtil.getBundle(clazz); |
| String contributionURI = E4Constants.BUNDLE_PROTOCOL_SCHEME + "://" + bundle.getSymbolicName() + "/"+ className; |
| part.setContributionURI(contributionURI); |
| stack.getChildren().add(perspective); |
| stack.setSelectedElement(perspective); |
| modelService.bringToTop(perspective); |
| } |
| } |
| |
| @Override |
| public void openPerspective(BPMTaskSummary taskSummary) { |
| // register tasksummary in context for action's TaskHelper |
| eclipseContext.set(BPMTaskSummary.class, taskSummary); |
| PerspectiveFound perspectiveFound = null; |
| log.debug("open perspective with taskId {}", taskSummary.getId()); |
| perspectiveFound = findPerspective(taskSummary); |
| if (perspectiveFound != null) { |
| // notify orgachart with current user's position |
| eventBroker.post(EventBrokerMsg.ORGCHART_SELECT, user.getPosition()); |
| openPerspective(perspectiveFound, taskSummary); |
| } else { |
| log.error("perspective for taskid {} not found", taskSummary.getId()); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.osbp.ui.api.perspective.IPerspectiveProvider# |
| * openPerspectiveEvent(java.lang.String) |
| */ |
| @Override |
| public void openPerspective(String perspectiveId) { |
| PerspectiveFound perspectiveFound = findPerspective(perspectiveId); |
| if (perspectiveFound != null) { |
| log.debug("{}", "openPerspective starts"); |
| openPerspective(perspectiveFound, null); |
| log.debug("{}", "openPerspective finished"); |
| } else { |
| log.error("perspective id {} not found", perspectiveId); |
| } |
| } |
| |
| /** |
| * Creates a new perspective suitable for the given task it was called from. |
| * |
| * @param perspectiveModel |
| * the perspective model |
| * @param humanTask |
| * @param taskSummary |
| */ |
| private void openPerspective(PerspectiveFound perspectiveFound, BPMTaskSummary summary) { |
| MPerspectiveStack stack = initPerspectiveStack(); |
| if (stack != null && perspectiveFound.perspective != null) { |
| // bring to top if already contained in model |
| // lo wants multiple manually opened perspectives of same type by |
| // 02/28/2018 |
| if (summary != null) { |
| for (MPerspective perspective : stack.getChildren()) { |
| if ((toPerspectiveElementId(perspectiveFound.fqn)) |
| .equals(perspective.getElementId())) { |
| modelService.bringToTop(perspective); |
| return; |
| } |
| } |
| } |
| |
| log.debug("open perspective {}", perspectiveFound.fqn); |
| log.trace("{}","add perspective"); |
| MPerspective perspective = createPerspective(stack, perspectiveFound.perspective, |
| perspectiveFound.fqn); |
| if (summary != null) { |
| registerContext(perspective.getTransientData(), perspectiveFound); |
| // create the toolbar |
| if (perspectiveFound.perspective.getToolbar() != null) { |
| String toolBarId = dslMetadataService.getFullyQualifiedName(perspectiveFound.perspective.getToolbar()); |
| toolbarProvider.addToolbar(perspectiveFound.fqn, findToolbar(toolBarId)); |
| } |
| } |
| stack.getChildren().add(perspective); |
| stack.setSelectedElement(perspective); |
| modelService.bringToTop(perspective); |
| |
| perspectives.put(perspectiveFound.fqn, perspective); |
| if(summary != null) { |
| perspectiveTasks.put(summary, perspectiveFound.fqn); |
| } |
| // get notified from bpm |
| if (taskClient != null) { |
| taskClient.subscribeProcessCompletedEventNotification(this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Release, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Complete, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Delegated, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Fail, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Skipped, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Release, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Stop, this); |
| taskClient.subscribeTaskEventNotification(BPMTaskEventType.Suspended, this); |
| } |
| } |
| } |
| |
| /** |
| * Close perspective. |
| * |
| * @param perspectiveId |
| * of the perspective to close |
| * @param suspendTask |
| * is true if task should be set to susupended |
| */ |
| private void closePerspective(String perspectiveId) { |
| if (perspectiveTasks.containsValue(perspectiveId)) { |
| for (Map.Entry<BPMTaskSummary, String> perspective : perspectiveTasks.entrySet()) { |
| if (perspective.getValue().equals(perspectiveId)) { |
| closePerspective(perspective.getKey()); |
| break; |
| } |
| } |
| } else { |
| if(perspectives.containsKey(perspectiveId)) { |
| modelService.resetPerspectiveModel(perspectives.get(perspectiveId), trimmedWindow); |
| modelService.removePerspectiveModel(perspectives.get(perspectiveId), trimmedWindow); |
| perspectives.remove(perspectiveId); |
| } |
| } |
| } |
| |
| /** |
| * Close perspective an remove from PerspectiveStack. |
| * |
| * @param taskId |
| * of the perspective to close |
| */ |
| private void closePerspective(long taskId) { |
| for(BPMTaskSummary summary:perspectiveTasks.keySet()) { |
| if(summary.getId() == taskId) { |
| closePerspective(summary); |
| break; |
| } |
| } |
| } |
| |
| @Override |
| public void closePerspective(BPMTaskSummary summary) { |
| if (perspectiveTasks.containsKey(summary)) { |
| modelService.resetPerspectiveModel(perspectives.get(perspectiveTasks.get(summary)), trimmedWindow); |
| modelService.removePerspectiveModel(perspectives.get(perspectiveTasks.get(summary)), trimmedWindow); |
| toolbarProvider.removeToolbar(perspectiveTasks.get(summary)); |
| perspectives.remove(perspectiveTasks.get(summary)); |
| perspectiveTasks.remove(summary); |
| } |
| } |
| |
| private void addAdapter(MUIElement element) { |
| ((EObject) element).eAdapters().add(new AdapterImpl() { |
| @Override |
| public void notifyChanged(Notification notification) { |
| if (notification.getEventType() == Notification.SET) { |
| switch(notification.getFeatureID(UIElementImpl.class)) { |
| case UiPackageImpl.UI_ELEMENT__CONTAINER_DATA: |
| if(element.getElementId() != null) { |
| user.addToProperties(getFQNKey(element), element.getContainerData()); |
| } |
| break; |
| case UiPackageImpl.ELEMENT_CONTAINER__SELECTED_ELEMENT: |
| if(element.getTransientData().containsKey(IPerspectiveProvider.EventDispatcherConstants.SYNCHRONIZE_WITH)) { |
| String elementId = (String) element.getTransientData().get(IPerspectiveProvider.EventDispatcherConstants.SYNCHRONIZE_WITH); |
| MPartStack partStack = (MPartStack) modelService.find(elementId, element.getParent()); |
| int index = ((MPartStack)element).getChildren().indexOf(((MPartStack)element).getSelectedElement()); |
| if(index <= partStack.getChildren().size() && (partStack.getSelectedElement() == null || !partStack.getSelectedElement().equals(partStack.getChildren().get(index)))) { |
| partStack.setSelectedElement(partStack.getChildren().get(index)); |
| } |
| } |
| break; |
| } |
| } |
| } |
| }); |
| } |
| |
| private String getFQNKey(MUIElement element) { |
| MUIElement muiElement = element; |
| List<String> elementIds = new LinkedList<>(); |
| StringBuilder key = new StringBuilder(); |
| while (muiElement != null) { |
| if (muiElement.getElementId() != null) { |
| elementIds.add(muiElement.getElementId()); |
| if (muiElement.getElementId().startsWith(E4Constants.PERSPECTIVE_PREFIX)) { |
| break; |
| } |
| muiElement = muiElement.getParent(); |
| } |
| } |
| for (int i = elementIds.size(); i > 0; i--) { |
| if (key.length() != 0) { |
| key.append("."); |
| } |
| key.append(elementIds.get(i - 1)); |
| } |
| return key.toString(); |
| } |
| } |
