| /** |
| * |
| * 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 |
| * |
| * |
| * This copyright notice shows up in the generated Java code |
| * |
| */ |
| |
| package org.eclipse.osbp.xtext.action.jvmmodel |
| |
| import java.util.Map |
| import javax.inject.Inject |
| import org.eclipse.e4.core.contexts.Active |
| import org.eclipse.e4.core.contexts.IEclipseContext |
| import org.eclipse.e4.core.di.annotations.CanExecute |
| import org.eclipse.e4.core.di.annotations.Execute |
| import org.eclipse.e4.core.di.annotations.Optional |
| import org.eclipse.e4.ui.model.application.MApplication |
| import org.eclipse.e4.ui.model.application.ui.MUIElement |
| import org.eclipse.e4.ui.model.application.ui.basic.MPart |
| import org.eclipse.e4.ui.model.application.ui.menu.MHandledToolItem |
| import org.eclipse.e4.ui.model.application.ui.menu.MToolBar |
| import org.eclipse.e4.ui.workbench.IPresentationEngine |
| import org.eclipse.emf.common.util.Enumerator |
| import org.eclipse.osbp.core.api.persistence.IPersistenceService |
| import org.eclipse.osbp.datainterchange.api.IDataInterchange |
| import org.eclipse.osbp.ecview.core.common.context.IViewContext |
| import org.eclipse.osbp.runtime.common.event.IEventDispatcher |
| import org.eclipse.osbp.ui.api.contextfunction.ICommandsProvider |
| import org.eclipse.osbp.ui.api.customfields.IBlobService |
| import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService |
| import org.eclipse.osbp.ui.api.themes.IThemeResourceService |
| import org.eclipse.osbp.ui.api.user.IUser |
| import org.eclipse.osbp.ui.api.useraccess.IUserAccessService |
| import org.eclipse.osbp.utils.annotation.CommonUtils |
| import org.eclipse.osbp.vaaclipse.api.VaadinExecutorService |
| import org.eclipse.osbp.xtext.action.ActionButton |
| import org.eclipse.osbp.xtext.action.ActionChart |
| import org.eclipse.osbp.xtext.action.ActionCommand |
| import org.eclipse.osbp.xtext.action.ActionDatainterchange |
| import org.eclipse.osbp.xtext.action.ActionDialog |
| import org.eclipse.osbp.xtext.action.ActionFunction |
| import org.eclipse.osbp.xtext.action.ActionPackage |
| import org.eclipse.osbp.xtext.action.ActionReport |
| import org.eclipse.osbp.xtext.action.ActionSelectWorkload |
| import org.eclipse.osbp.xtext.action.ActionSpacer |
| import org.eclipse.osbp.xtext.action.ActionState |
| import org.eclipse.osbp.xtext.action.ActionTask |
| import org.eclipse.osbp.xtext.action.ActionToolbar |
| import org.eclipse.osbp.xtext.action.ActionToolbarItem |
| import org.eclipse.osbp.xtext.action.ActionUI |
| import org.eclipse.osbp.xtext.action.ActionWorkflow |
| import org.eclipse.osbp.xtext.action.DialogActionEnum |
| import org.eclipse.osbp.xtext.action.UIActionEnum |
| import org.eclipse.osbp.xtext.action.common.IToolbarAction |
| import org.eclipse.osbp.xtext.datainterchange.DataInterchange |
| import org.eclipse.osbp.xtext.datainterchange.jvmmodel.DataDSLJvmModelInferrer |
| import org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryPackage |
| import org.eclipse.osbp.xtext.messagedsl.MessagePackage |
| import org.eclipse.xtext.common.types.JvmDeclaredType |
| import org.eclipse.xtext.common.types.JvmField |
| import org.eclipse.xtext.common.types.JvmGenericType |
| import org.eclipse.xtext.common.types.JvmTypeReference |
| import org.eclipse.xtext.common.types.JvmVisibility |
| import org.eclipse.xtext.naming.IQualifiedNameProvider |
| import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer |
| import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor |
| import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder |
| import org.osgi.service.component.annotations.Component |
| import org.slf4j.Logger |
| |
| /** |
| * <p>Infers a JVM model from the source model.</p> |
| * |
| * <p>The JVM model should contain all elements that would appear in the Java code |
| * which is generated from the source model. Other models link against the JVM model rather than the source model.</p> |
| */ |
| class ActionDSLJvmModelInferrer extends AbstractModelInferrer { |
| |
| @Inject extension JvmTypesBuilder |
| @Inject extension IQualifiedNameProvider |
| @Inject extension DataDSLJvmModelInferrer data |
| @Inject extension CommonUtils |
| |
| var String contextClassName = "" |
| var String clsName = "" |
| |
| def dispatch void infer(ActionPackage pkg, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) { |
| for (toolbar : pkg.toolbars) { |
| var toolbarClass = toolbar.toClass(toolbar.className) |
| acceptor.accept(toolbarClass, [ |
| superTypes += _typeReferenceBuilder.typeRef(IToolbarAction) |
| it.toToolbarConstructor(toolbar) |
| it.toToolbarFields(toolbar) |
| it.toToolbarOperations(toolbar) |
| it.fileHeader = pkg.documentation |
| ]) |
| |
| } |
| // the command handlers |
| for (command : pkg.commands) { |
| var handlerClass = command.toClass(command.className) |
| acceptor.accept(handlerClass, [ |
| it.toHandlerFields(command) |
| it.toHandlerOperations(command) |
| it.fileHeader = pkg.documentation |
| ]) |
| } |
| // the commands class |
| if (! pkg.withouCommandProvider) { |
| clsName = pkg.name.toString.concat(".").concat("CommandsProvider") |
| val cls = pkg.toClass(clsName) |
| cls.superTypes.add(_typeReferenceBuilder.typeRef(ICommandsProvider)) |
| acceptor.accept(cls, [ |
| var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Component)) |
| annotationRef.addAnnAttr(pkg, "service", |
| _typeReferenceBuilder.typeRef(ICommandsProvider) as JvmTypeReference) |
| annotations += annotationRef |
| it.toCommandsConstructor(pkg) |
| it.toCommandsOperations(pkg) |
| ]) |
| } |
| } |
| |
| def void toCommandsOperations(JvmGenericType type, ActionPackage pkg) { |
| // init |
| type.members += pkg.toMethod("init", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| parameters += pkg.toParameter("application", _typeReferenceBuilder.typeRef(MApplication)) |
| body = [append('''«pkg.init»''')] |
| ]) |
| } |
| |
| def init(ActionPackage pkg) { |
| var body = ''' |
| if(!application.getBindingTables().isEmpty()) { |
| MBindingTable bindingTable = application.getBindingTables().get(0); |
| MKeyBinding keyBinding; |
| MCommand command; |
| MHandler commandHandler; |
| ''' |
| for (command : pkg.commands) { |
| body = ''' |
| «body» |
| command = CommandsFactoryImpl.eINSTANCE.createCommand(); |
| command.setElementId("«pkg.fullyQualifiedName».«command.name»"); |
| command.setCommandName("«command.name»"); |
| «IF command.hasDescription»command.setDescription("«command.description»");«ENDIF» |
| application.getCommands().add(command); |
| commandHandler = CommandsFactoryImpl.eINSTANCE.createHandler(); |
| commandHandler.setElementId("«pkg.fullyQualifiedName».«command.name»Handler"); |
| commandHandler.setCommand(command); |
| commandHandler.setContributionURI("bundleclass://"+FrameworkUtil.getBundle(«command.className».class).getSymbolicName()+"/«command.className»"); |
| application.getHandlers().add(commandHandler); |
| «IF command.hasKeyBinding» |
| keyBinding = CommandsFactoryImpl.eINSTANCE.createKeyBinding(); |
| keyBinding.setElementId("«pkg.fullyQualifiedName».«command.name»Keybinding"); |
| keyBinding.setKeySequence("«command.keyBinding.replace(" ", "+")»"); |
| keyBinding.setCommand(command); |
| bindingTable.getBindings().add(keyBinding);«ENDIF» |
| ''' |
| } |
| body = ''' |
| «body» |
| } |
| ''' |
| return body |
| } |
| |
| def void toCommandsConstructor(JvmGenericType type, ActionPackage pkg) { |
| type.members += pkg.toConstructor([ |
| body = [append('''''')] |
| ]) |
| } |
| |
| /** |
| * <p>build the constructors including the uuid.</p> |
| * |
| */ |
| def void toToolbarConstructor(JvmGenericType type, ActionToolbar toolbar) { |
| type.members += toolbar.toConstructor( |
| [ |
| parameters += toolbar.toParameter("uuid", _typeReferenceBuilder.typeRef(String)) |
| body = [ |
| append( |
| ''' |
| super(); |
| this.uuid = uuid;''') |
| ] |
| ]) |
| } |
| |
| def String className(ActionToolbar toolbar) { |
| var pkg = toolbar.eContainer as ActionPackage |
| return pkg.name.toString.concat(".").concat(toolbar.name.toFirstUpper).concat("Toolbar") |
| } |
| |
| def String className(ActionCommand actionCommand) { |
| var pkg = actionCommand.eContainer as ActionPackage |
| return pkg.name.toString.concat(".").concat(actionCommand.name.toFirstUpper).concat("Action") |
| } |
| |
| def void toToolbarOperations(JvmGenericType type, ActionToolbar toolbar) { |
| // create a toolbar |
| type.members += toolbar.toMethod("createToolbar", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| parameters += toolbar.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += toolbar.toParameter("renderingEngine", _typeReferenceBuilder.typeRef(IPresentationEngine)) |
| parameters += |
| toolbar.toParameter("themeResourceService", _typeReferenceBuilder.typeRef(IThemeResourceService)) |
| visibility = JvmVisibility.PUBLIC |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| body = [append('''«toolbar.createToolbar»''')] |
| ]) |
| // get toolbar |
| type.members += toolbar.toMethod("getToolBar", _typeReferenceBuilder.typeRef(MToolBar), [ |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| body = [append('''return toolbar;''')] |
| ]) |
| // get stateLabelUUID |
| type.members += toolbar.toMethod("getStateLabelUUID", _typeReferenceBuilder.typeRef(String), [ |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| body = [append('''return stateLabelUUID;''')] |
| ]) |
| // set command |
| type.members += toolbar.toMethod("setCommand", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| parameters += toolbar.toParameter("commandName", _typeReferenceBuilder.typeRef(String)) |
| parameters += toolbar.toParameter("toolItem", _typeReferenceBuilder.typeRef(MHandledToolItem)) |
| parameters += toolbar.toParameter("application", _typeReferenceBuilder.typeRef(MApplication)) |
| visibility = JvmVisibility.PRIVATE |
| body = [ |
| append( |
| ''' |
| for(MCommand command:application.getCommands()) { |
| if(command.getCommandName().equals(commandName)) { |
| toolItem.setCommand(command); |
| break; |
| } |
| } |
| ''') |
| ] |
| ]) |
| } |
| |
| def String createToolbar(ActionToolbar toolbar) { |
| var body = "" |
| body = ''' |
| «body» |
| MenuFactoryImpl factory = MenuFactoryImpl.eINSTANCE; |
| MHandledToolItem toolItem = null; |
| MToolBarSeparator separator = null; |
| |
| MApplication application = (MApplication)eclipseContext.get(MApplication.class); |
| MPart part = (MPart)eclipseContext.get(MPart.class); |
| if(part != null) { |
| toolbar = part.getToolbar(); |
| if (toolbar == null) { |
| toolbar = factory.createToolBar(); |
| toolbar.setElementId(uuid); |
| part.getContext().set("«IToolbarAction.TOOLBAR_UUID»", toolbar.getElementId()); |
| toolbar.setToBeRendered(true); |
| part.setToolbar(toolbar); |
| |
| Panel panel = (Panel) part.getWidget(); |
| if (panel != null) { // it is already visible in terms of vaadin |
| //create toolbar area |
| VerticalLayout rootContainer = (VerticalLayout)panel.getContent(); |
| CssLayout toolbarArea = new CssLayout(); |
| toolbarArea.setStyleName(EnumCssClass.MPARTTOOLBARAREA.toString()); |
| toolbarArea.setSizeUndefined(); |
| toolbarArea.setWidth("100%"); |
| rootContainer.addComponentAsFirst(toolbarArea); |
| |
| //create toolbar |
| Component toolbarWidget = (Component) renderingEngine.createGui(toolbar); |
| ((AbstractLayout)toolbarWidget).setSizeUndefined(); |
| toolbarWidget.setStyleName(EnumCssClass.MPARTTOOLBAR.toString()); |
| toolbarArea.addComponent(toolbarWidget); |
| } |
| } |
| else { |
| toolbar.getChildren().removeIf(c -> c.isToBeRendered()); |
| } |
| ''' |
| for (action : toolbar.actions) { |
| body = '''«body»«toolbar.createToolItem(action)»''' |
| } |
| body = ''' |
| «body» |
| }''' |
| return body |
| } |
| |
| def createToolItem(ActionToolbar toolbar, ActionToolbarItem action) { |
| if (action instanceof ActionButton) { |
| return ''' |
| toolItem = factory.createHandledToolItem(); |
| toolItem.setElementId(UUID.randomUUID().toString()); |
| toolItem.setType(ItemType.PUSH); |
| toolItem.setTooltip("«IF action.command.actionType instanceof ActionDatainterchange && (action.command.actionType as ActionDatainterchange).dataRef.description»«(action.command.actionType as ActionDatainterchange).dataRef.descriptionValue»«ELSE»«action.name»«ENDIF»«IF action.command.hasKeyBinding».keybinding.«action.command.keyBinding»«ENDIF»"); |
| toolItem.setIconURI(themeResourceService.getThemeURI("«action.iconURI»", ThemeResourceType.ICON)); |
| toolItem.setEnabled(true); |
| toolItem.setToBeRendered(true); |
| toolItem.setVisible(true); |
| setCommand("«action.command.name»", toolItem, application); |
| toolbar.getChildren().add(toolItem); |
| «IF action.command.actionType instanceof ActionReport» |
| toolItem.getTags().add("«(action.command.actionType as ActionReport).action.literal»"); |
| «ENDIF» |
| ''' |
| } else if (action instanceof ActionSpacer) { |
| return ''' |
| separator = factory.createToolBarSeparator(); |
| toolbar.getChildren().add(separator); |
| ''' |
| } else if (action instanceof ActionState) { |
| return ''' |
| MToolControl state = factory.createToolControl(); |
| state.setContributionURI(E4Helper.getDialogStateHandlerURI()); |
| stateLabelUUID = UUID.randomUUID().toString(); |
| state.setElementId(stateLabelUUID); |
| state.setToBeRendered(true); |
| state.setVisible(true); |
| toolbar.getChildren().add(state); |
| ''' |
| } |
| } |
| |
| def void toToolbarFields(JvmGenericType type, ActionToolbar toolbar) { |
| var JvmField field = null |
| // create logger |
| field = toolbar.toField("log", _typeReferenceBuilder.typeRef(Logger)) [ |
| setInitializer([append('''org.slf4j.LoggerFactory.getLogger("toolbar")''')]) |
| ] |
| field.static = true |
| field.visibility = JvmVisibility::PRIVATE |
| type.members += field |
| // create UUID |
| field = toolbar.toField("uuid", _typeReferenceBuilder.typeRef(String)) |
| field.visibility = JvmVisibility::PRIVATE |
| type.members += field |
| field = toolbar.toField("toolbar", _typeReferenceBuilder.typeRef(MToolBar)) |
| type.members += field |
| field = toolbar.toField("stateLabelUUID", _typeReferenceBuilder.typeRef(String)) |
| field.visibility = JvmVisibility::PRIVATE |
| type.members += field |
| } |
| |
| // handler stuff |
| def void toHandlerFields(JvmGenericType type, ActionCommand action) { |
| var JvmField field = null |
| // create logger |
| field = action.toField("log", _typeReferenceBuilder.typeRef(Logger)) [ |
| setInitializer([append('''org.slf4j.LoggerFactory.getLogger("action")''')]) |
| ] |
| field.static = true |
| field.visibility = JvmVisibility::PRIVATE |
| type.members += field |
| |
| var JvmField field2 = null |
| // create logger |
| field2 = action.toField("isGranted", _typeReferenceBuilder.typeRef(Map,_typeReferenceBuilder.typeRef(String),_typeReferenceBuilder.typeRef(Boolean))) [ |
| setInitializer([append('''new HashMap()''')]) |
| ] |
| field2.static = true |
| field2.visibility = JvmVisibility::PRIVATE |
| type.members += field2 |
| // create a field |
| type.members += action.toField("activePart", _typeReferenceBuilder.typeRef(MUIElement)) |
| // create a getter |
| type.members += action.toMethod("getActivePart", _typeReferenceBuilder.typeRef(MUIElement), [ |
| body = [append('''return activePart;''')] |
| ]) |
| |
| } |
| |
| def activatePart() ''' |
| if (part == null) { |
| return; |
| } |
| if(activePart != null && activePart.getWidget() instanceof Panel) { |
| ((Panel)activePart.getWidget()).removeStyleName(EnumCssClass.HAS_FOCUS.styleName()); |
| } |
| if(part.getWidget() instanceof Panel) { |
| activePart = part; |
| ((Panel)activePart.getWidget()).addStyleName(EnumCssClass.HAS_FOCUS.styleName()); |
| IE4Dialog dialog = part.getContext().get(IE4Dialog.class); |
| if (dialog != null) { |
| ContextInjectionFactory.invoke(dialog, Focus.class, part.getContext()); |
| } |
| IE4Table table = part.getContext().get(IE4Table.class); |
| if (table != null) { |
| ContextInjectionFactory.invoke(table, Focus.class, part.getContext()); |
| } |
| IE4Focusable focusable = part.getContext().get(IE4Focusable.class); |
| if (focusable != null) { |
| ContextInjectionFactory.invoke(focusable, Focus.class, part.getContext()); |
| } |
| } |
| ''' |
| |
| /** |
| * <p>build the methods to be used as toolbar handlers by an e4 application.</p> |
| * |
| */ |
| def void toHandlerOperations(JvmDeclaredType type, ActionCommand action) { |
| if (action.actionType instanceof ActionUI && |
| ((action.actionType as ActionUI).action == UIActionEnum.NEXT_PART || |
| (action.actionType as ActionUI).action == UIActionEnum.PREVIOUS_PART)) { |
| // create activePart |
| type.members += action.toMethod("activePart", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| annotations += _annotationTypesBuilder.annotationRef(Inject) |
| var para = action.toParameter("part", _typeReferenceBuilder.typeRef(MPart)) |
| para.annotations += _annotationTypesBuilder.annotationRef(typeof(Active)) |
| para.annotations += _annotationTypesBuilder.annotationRef(typeof(Optional)) |
| parameters += para |
| body = [append('''«activatePart»''')] |
| ]) |
| } |
| // create canExecute |
| type.members += action.toMethod("canExecute", _typeReferenceBuilder.typeRef(boolean), [ |
| annotations += _annotationTypesBuilder.annotationRef(CanExecute) |
| switch (action.actionType) { |
| ActionTask: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| } |
| ActionSelectWorkload: { |
| } |
| ActionDialog: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("userAccessService", _typeReferenceBuilder.typeRef(IUserAccessService)) |
| parameters += action.toParameter("viewContext", _typeReferenceBuilder.typeRef(IViewContext)) |
| } |
| ActionReport: { |
| } |
| ActionChart: { |
| } |
| ActionWorkflow: { |
| } |
| ActionDatainterchange: { |
| parameters += action.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange)) |
| } |
| ActionFunction: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| } |
| ActionUI: { |
| if ((action.actionType as ActionUI).action == UIActionEnum.DATABASE_INFO) { |
| parameters += |
| action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| } |
| } |
| } |
| body = [append('''«action.canExecute»''')] |
| ]) |
| // create execute |
| type.members += action.toMethod("execute", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| annotations += _annotationTypesBuilder.annotationRef(Execute) |
| switch (action.actionType) { |
| ActionTask: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionSelectWorkload: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionDialog: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionReport: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionChart: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionWorkflow: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } |
| ActionDatainterchange: { |
| parameters += action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| parameters += |
| action.toParameter("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService)) |
| parameters += action.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange)) |
| parameters += |
| action.toParameter("executorService", _typeReferenceBuilder.typeRef(VaadinExecutorService)) |
| parameters += |
| action.toParameter("dslMetadataService", _typeReferenceBuilder.typeRef(IDSLMetadataService)) |
| parameters += action.toParameter("blobService", _typeReferenceBuilder.typeRef(IBlobService)) |
| parameters += action.toParameter("user", _typeReferenceBuilder.typeRef(IUser)) |
| } |
| ActionFunction: { |
| parameters += action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| if ((action.actionType as ActionFunction).hasExecuteLater) { |
| parameters += |
| action.toParameter("executorService", _typeReferenceBuilder.typeRef(VaadinExecutorService)) |
| } |
| if ((action.actionType as ActionFunction).hasMessage || |
| (action.actionType as ActionFunction).hasStartedMessage) { |
| parameters += |
| action.toParameter("dslMetadataService", _typeReferenceBuilder.typeRef(IDSLMetadataService)) |
| parameters += action.toParameter("user", _typeReferenceBuilder.typeRef(IUser)) |
| } |
| } |
| ActionUI: { |
| if ((action.actionType as ActionUI).action == UIActionEnum.DATABASE_INFO) { |
| parameters += |
| action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += |
| action.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher)) |
| } else if ((action.actionType as ActionUI).action == UIActionEnum.MDX_QUERY) { |
| parameters += |
| action.toParameter("eclipseContext", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| } |
| } |
| } |
| body = [append('''«action.execute»''')] |
| ]) |
| } |
| |
| def execute(ActionCommand command) { |
| switch command.actionType { |
| ActionDatainterchange: |
| ((command.actionType as ActionDatainterchange).dataRef as DataInterchange)?.doInterchange(command) |
| default: |
| command.doExecute |
| } |
| } |
| |
| def doInterchange(DataInterchange dataInterchange, ActionCommand action) ''' |
| «dataInterchange.getConfigFileURL» |
| «data.getBasicRunConfiguration(dataInterchange, true, (action.actionType as ActionDatainterchange).action.literal, null)» |
| «dataInterchange.getDefaultVariableName()».setDirection(WorkerThreadRunnable.Direction.«(action.actionType as ActionDatainterchange).action.literal.toUpperCase»); |
| «dataInterchange.getDefaultVariableName()».setEventDispatcher(eventDispatcher); |
| «dataInterchange.getDefaultVariableName()».setBlobService(blobService); |
| Notification.show(dslMetadataService.translate(user.getLocale().toLanguageTag(), "datainterchangeStarted"),Notification.Type.HUMANIZED_MESSAGE); |
| executorService.invokeLater(null, new Runnable() { |
| @Override |
| public void run() { |
| «dataInterchange.getDefaultVariableName()».run(); |
| } |
| });''' |
| |
| def String doExecute(ActionCommand command) { |
| var String actionEnumStr |
| switch command.actionType { |
| ActionTask: |
| actionEnumStr = (command.actionType as ActionTask).action.getEnumString.toString |
| ActionSelectWorkload: |
| actionEnumStr = (command.actionType as ActionSelectWorkload).action.getEnumString.toString |
| ActionDialog: |
| actionEnumStr = (command.actionType as ActionDialog).action.getEnumString.toString |
| ActionReport: |
| actionEnumStr = (command.actionType as ActionReport).action.getEnumString.toString |
| ActionChart: |
| actionEnumStr = (command.actionType as ActionChart).action.getEnumString.toString |
| ActionWorkflow: |
| actionEnumStr = (command.actionType as ActionWorkflow).action.getEnumString.toString |
| ActionFunction: |
| actionEnumStr = "Execute" |
| ActionUI: |
| actionEnumStr = (command.actionType as ActionUI).action.getEnumString.toString |
| } |
| if (command.actionType instanceof ActionFunction) { |
| var func = command.actionType as ActionFunction |
| if (func.hasExecuteImmediate) { |
| return ''' |
| «IF func.hasMessage»boolean result = «ENDIF»«(func.actionGroup.eContainer as FunctionLibraryPackage).fullyQualifiedName».«func.actionGroup.name.toString.toFirstUpper».«func.executeImmediate.name.toString»(eclipseContext); |
| «IF func.hasMessage» |
| if(!result) { |
| Notification.show(«(func.messageCategory.eContainer as MessagePackage).fullyQualifiedName».«func.messageCategory.name»Message.«func.onFailMessage.name.toFirstLower»().getShowMessage(dslMetadataService, user),Notification.Type.ERROR_MESSAGE); |
| } «IF func.hasSuccessMessage»else { |
| Notification.show(«(func.messageCategory.eContainer as MessagePackage).fullyQualifiedName».«func.messageCategory.name»Message.«func.onSuccessMessage.name.toFirstLower»().getShowMessage(dslMetadataService, user), Notification.Type.HUMANIZED_MESSAGE); |
| }«ENDIF»«ENDIF»''' |
| } |
| if (func.hasExecuteLater) { |
| return ''' |
| «IF func.hasStartedMessage» |
| Notification.show(«(func.messageCategory.eContainer as MessagePackage).fullyQualifiedName».«func.messageCategory.name»Message.«func.onStartedMessage.name.toFirstLower»().getShowMessage(dslMetadataService, user),Notification.Type.HUMANIZED_MESSAGE); |
| «ENDIF» |
| executorService.invokeLater(eclipseContext, new Runnable() { |
| @Override |
| public void run() { |
| «(func.actionGroup.eContainer as FunctionLibraryPackage).fullyQualifiedName».«func.actionGroup.name.toString.toFirstUpper».«func.executeLater.name.toString»(eclipseContext); |
| } |
| });''' |
| } |
| } else if (command.actionType instanceof ActionUI && |
| (command.actionType as ActionUI).action == UIActionEnum.NEXT_PART) { |
| return ''' |
| log.debug("execute next part"); |
| MUIElement newActivePart = E4Helper.getPart(true, getActivePart(), true); |
| if(newActivePart != null && newActivePart instanceof MPart) { |
| ((MPart)newActivePart).getContext().activate(); |
| }''' |
| } else if (command.actionType instanceof ActionUI && |
| (command.actionType as ActionUI).action == UIActionEnum.PREVIOUS_PART) { |
| return ''' |
| log.debug("execute previous part"); |
| MUIElement newActivePart = E4Helper.getPart(false, getActivePart(), true); |
| if(newActivePart != null && newActivePart instanceof MPart) { |
| ((MPart)newActivePart).getContext().activate(); |
| }''' |
| |
| } else if (command.actionType instanceof ActionUI && |
| (command.actionType as ActionUI).action == UIActionEnum.MDX_QUERY) { |
| return ''' |
| UI.getCurrent().addWindow(new MDXDialog(eclipseContext)); |
| ''' |
| } else { |
| return ''' |
| log.debug("action execute called for «command.name»"); |
| String uuid = (String)eclipseContext.get("«IToolbarAction.TOOLBAR_UUID»"); |
| MPerspective perspective = eclipseContext.get(MPerspective.class); |
| EventDispatcherEvent evnt = new EventDispatcherEvent(perspective, EventDispatcherCommand.ACTION, uuid, "«command.fullyQualifiedName»"); |
| evnt.addItem(EventDispatcherDataTag.BUTTON_ID, «actionEnumStr»); |
| «IF command.actionType instanceof ActionTask» |
| evnt.addItem(EventDispatcherDataTag.TASK_ID, TaskHelper.getTaskId(eclipseContext)); |
| «ENDIF» |
| eventDispatcher.sendEvent(evnt);''' |
| } |
| } |
| |
| def getEnumString(Enumerator actionEnum) '''«actionEnum.class.simpleName».«actionEnum.name»''' |
| |
| def canExecute(ActionCommand action) { |
| |
| switch action.actionType { |
| ActionTask: { |
| return '''return TaskHelper.«(action.actionType as ActionTask).action.literal.toFirstLower»CanExecute(eclipseContext);''' |
| } |
| ActionUI: { |
| if ((action.actionType as ActionUI).action == UIActionEnum.DATABASE_INFO) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| boolean result = !(boolean) ContextInjectionFactory.invoke(dialog, IsNew.class, eclipseContext); |
| return result;''' |
| } else { |
| return ''' |
| return true; |
| ''' |
| } |
| } |
| ActionDialog: { |
| if ((action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_SAVE) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| Object dto = viewContext.getBean(IViewContext.MAIN_BEAN_SLOT); |
| boolean result1 = (boolean) ContextInjectionFactory.invoke(dialog, IsValid.class, eclipseContext); |
| boolean result2 = (boolean) ContextInjectionFactory.invoke(dialog, IsDirty.class, eclipseContext); |
| boolean result3 = true; |
| if( result1 && result2) { |
| String clazzName = dto.getClass().getName(); |
| String grantKey = clazzName + "###UPDATABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result3=isGranted.get(grantKey); |
| } else { |
| result3 = userAccessService.isGranted(Group.DTO, Action.UPDATABLE, clazzName); |
| isGranted.put(grantKey,result3); |
| } |
| } |
| return result1 && result2 && result3;''' |
| |
| } else if ( (action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_SAVE_AND_NEW ) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| Object dto = viewContext.getBean(IViewContext.MAIN_BEAN_SLOT); |
| boolean result1 = (boolean) ContextInjectionFactory.invoke(dialog, IsValid.class, eclipseContext); |
| boolean result2 = (boolean) ContextInjectionFactory.invoke(dialog, IsDirty.class, eclipseContext); |
| boolean result3 = true; |
| boolean result4 = true; |
| if( result1 && result2) { |
| String clazzName = dto.getClass().getName(); |
| String grantKey = clazzName + "###UPDATABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result3=isGranted.get(grantKey); |
| } else { |
| result3 = userAccessService.isGranted(Group.DTO, Action.UPDATABLE, clazzName); |
| isGranted.put(grantKey,result3); |
| } |
| if( result3 ) { |
| grantKey = clazzName + "###CREATABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result4=isGranted.get(grantKey); |
| } else { |
| result4 = userAccessService.isGranted(Group.DTO, Action.CREATABLE, clazzName); |
| isGranted.put(grantKey,result4); |
| } |
| } |
| } |
| return result1 && result2 && result3 && result4;''' |
| |
| } else if ( (action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_SAVE_AS_NEW) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| Object dto = viewContext.getBean(IViewContext.MAIN_BEAN_SLOT); |
| boolean result1 = (boolean) ContextInjectionFactory.invoke(dialog, IsValid.class, eclipseContext); |
| boolean result2 = (boolean) ContextInjectionFactory.invoke(dialog, IsDirty.class, eclipseContext); |
| boolean result3 = true; |
| if( result1 && result2 ) { |
| String clazzName = dto.getClass().getName(); |
| String grantKey = clazzName + "###CREATABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result3=isGranted.get(grantKey); |
| } else { |
| result3 = userAccessService.isGranted(Group.DTO, Action.CREATABLE, clazzName); |
| isGranted.put(grantKey,result3); |
| } |
| } |
| return result1 && result2 && result3;''' |
| } else if ((action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_NEW) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| Object dto = viewContext.getBean(IViewContext.MAIN_BEAN_SLOT); |
| boolean result = !(boolean) ContextInjectionFactory.invoke(dialog, IsDirty.class, eclipseContext); |
| boolean result2 = true; |
| if( result ) { |
| String clazzName = dto.getClass().getName(); |
| String grantKey = clazzName + "###CREATABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result2=isGranted.get(grantKey); |
| } else { |
| result2=userAccessService.isGranted(Group.DTO, Action.CREATABLE, clazzName); |
| isGranted.put(grantKey,result2); |
| } |
| } |
| return result && result2;''' |
| |
| } else if ((action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_DELETE) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| Object dto = viewContext.getBean(IViewContext.MAIN_BEAN_SLOT); |
| boolean result1 = !(boolean) ContextInjectionFactory.invoke(dialog, IsNew.class, eclipseContext); |
| boolean result2 = (boolean) ContextInjectionFactory.invoke(dialog, IsPositioned.class, eclipseContext); |
| boolean result3 = true; |
| if( result1 && result2 ) { |
| String clazzName = dto.getClass().getName(); |
| String grantKey = clazzName + "###DELETEABLE"; |
| if( isGranted.containsKey(grantKey)) { |
| result3=isGranted.get(grantKey); |
| } else { |
| result3=userAccessService.isGranted(Group.DTO, Action.DELETEABLE, clazzName); |
| isGranted.put(grantKey,result3); |
| } |
| } |
| return result1 && result2 && result3;''' |
| } else if ((action.actionType as ActionDialog).action == DialogActionEnum.DIALOG_ACTION_CANCEL) { |
| return ''' |
| IE4Dialog dialog = eclipseContext.get(IE4Dialog.class); |
| if (dialog == null) { |
| return false; |
| } |
| boolean result = (boolean) ContextInjectionFactory.invoke(dialog, IsDirty.class, eclipseContext); |
| return result;''' |
| } else { |
| return '''return true;''' |
| } |
| } |
| ActionFunction: { |
| var pkg = (action.actionType as ActionFunction).actionGroup.eContainer as FunctionLibraryPackage |
| return '''return «pkg.fullyQualifiedName.toString».«(action.actionType as ActionFunction).actionGroup.name.toString.toFirstUpper».«(action.actionType as ActionFunction).canExecute.name.toString»(eclipseContext);''' |
| } |
| ActionDatainterchange: { |
| return '''return «IF action.actionType instanceof ActionDatainterchange»(dataInterchange!=null)«ELSE»true«ENDIF»;''' |
| } |
| default: |
| return '''return true;''' |
| } |
| } |
| } |
