| /** |
| * Copyright (c)2020 CEA LIST, Committer Name, and others. |
| * |
| * 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: |
| * CEA LIST - Initial API and implementation |
| * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr |
| * |
| */ |
| package org.eclipse.papyrus.pdp4eng.designer.processstrategies.command; |
| |
| import java.util.Iterator; |
| |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.transaction.RecordingCommand; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.papyrus.pdp4eng.designer.controller.api.*; |
| import org.eclipse.papyrus.pdp4eng.designer.controller.internal.processcreation.ProcessBuilder; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.swt.widgets.Display; |
| |
| import org.eclipse.uml2.uml.Action; |
| import org.eclipse.uml2.uml.Activity; |
| import org.eclipse.uml2.uml.ActivityEdge; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.ActivityParameterNode; |
| import org.eclipse.uml2.uml.CallBehaviorAction; |
| import org.eclipse.uml2.uml.Classifier; |
| import org.eclipse.uml2.uml.Element; |
| import org.eclipse.uml2.uml.InputPin; |
| import org.eclipse.uml2.uml.NamedElement; |
| import org.eclipse.uml2.uml.ObjectFlow; |
| import org.eclipse.uml2.uml.OutputPin; |
| import org.eclipse.uml2.uml.Package; |
| import org.eclipse.uml2.uml.PackageableElement; |
| import org.eclipse.uml2.uml.Pin; |
| import org.eclipse.uml2.uml.Profile; |
| import org.eclipse.uml2.uml.ProfileApplication; |
| import org.eclipse.uml2.uml.Stereotype; |
| import org.eclipse.uml2.uml.Type; |
| import org.eclipse.uml2.uml.UMLFactory; |
| import org.eclipse.uml2.uml.UMLPackage; |
| import org.eclipse.uml2.uml.util.UMLUtil; |
| import org.eclipse.ui.dialogs.ElementListSelectionDialog; |
| |
| import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess; |
| import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Entity; |
| import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.ExternalEntity; |
| import org.eclipse.papyrus.pdp4eng.designer.utils.ModelPackageNames; |
| import org.eclipse.papyrus.pdp4eng.designer.utils.ModelProfileNames; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose; |
| import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process; |
| |
| public class InstantiateGDPRConsentPatternCommand extends RecordingCommand { |
| |
| protected Activity activityDFD; |
| |
| public InstantiateGDPRConsentPatternCommand(TransactionalEditingDomain domain, Activity activityDFD) { |
| super(domain, "Instantiate a Consent Pattern based upon the information provided by the engineer"); |
| this.activityDFD = activityDFD; |
| } |
| |
| @Override |
| protected void doExecute() { |
| |
| String title = "1. Consent Pattern - Select the Controller"; |
| String message = "1. Select the Controller responsible for processing Personal Data"; |
| ExternalEntity selectedController = selectExternalEntityFromActivityDFD(title,message); |
| Entity controllerEntity = createEntity(selectedController.getBase_ActivityParameterNode().getName()); |
| Entity processorEntity = createEntity(selectedController.getBase_ActivityParameterNode().getName()+"_Processor"); |
| applyStereotypeToNamedElement(controllerEntity.getBase_NamedElement(), ModelProfileNames.commonGDPRProfileName, ModelProfileNames.commonGDPR_Controller); |
| applyStereotypeToNamedElement(processorEntity.getBase_NamedElement(), ModelProfileNames.commonGDPRProfileName, ModelProfileNames.commonGDPR_Processor); |
| selectedController.setEntity(controllerEntity); |
| |
| title = "2. Consent Pattern - Select the Data Subject"; |
| message = "2. Select the Data Subject to ask for Consent"; |
| ExternalEntity selectedDataSubject = selectExternalEntityFromActivityDFD(title, message); |
| Entity dataSubjectEntity = createEntity(selectedDataSubject.getBase_ActivityParameterNode().getName()); |
| applyStereotypeToNamedElement(dataSubjectEntity.getBase_NamedElement(), ModelProfileNames.commonGDPRProfileName, ModelProfileNames.commonGDPR_DataSubject); |
| selectedDataSubject.setEntity(dataSubjectEntity); |
| |
| title = "3. Consent Pattern - Select the Process"; |
| message = "3. Select the Process concerned by the Consent"; |
| CallProcess selectedCallProcess = selectCallProcessFromActivityDFD(title, message); |
| applyStereotypeToAction(selectedCallProcess.getBase_CallBehaviorAction(), ModelProfileNames.commonGDPRProfileName, ModelProfileNames.commonGDPR_Process); |
| |
| title = "4. Consent Pattern - Declare the Purpose"; |
| message = "4. Declare the Purpose for which Data is processed"; |
| InputDialog dialog = new InputDialog(Display.getCurrent().getActiveShell(), |
| title, message, "", null); |
| dialog.open(); |
| String purposeTxt = dialog.getValue(); |
| Purpose purpose = createPurpose(purposeTxt); |
| |
| title = "5. Consent Pattern - Select the Personal Data"; |
| message = "5. Select the Personal Data involved in "+ selectedCallProcess.getBase_CallBehaviorAction().getName(); |
| PersonalData selectedPersonalData = selectPersonalDataFromActivityDFD(title, message); |
| |
| /** Start to instantiate the Consent Pattern by completing and filling the model **/ |
| |
| /** 1st. Controller (and Processor) **/ |
| Controller controller = getController(controllerEntity.getBase_NamedElement()); |
| Processor processor = getProcessor(processorEntity.getBase_NamedElement()); |
| |
| if ((controller!=null) && (processor!=null) && (selectedPersonalData!=null)) { |
| controller.getPersonalData().add(selectedPersonalData); |
| controller.getProcessor().add(processor); |
| } |
| |
| /** 2nd. Data Subject and Consent **/ |
| |
| Consent consent = createConsent("Consent("+selectedPersonalData.getBase_NamedElement().getName()+"_"+purpose.getBase_NamedElement().getName()+")"); |
| DataSubject dataSubject = getDataSubject(dataSubjectEntity.getBase_NamedElement()); |
| |
| if (dataSubject!=null && selectedPersonalData!=null && consent!=null) { |
| dataSubject.getPersonalData().add(selectedPersonalData); |
| dataSubject.getGivenConsent().add(consent); |
| } |
| |
| |
| /** 3rd. Process **/ |
| Process process = getProcess(selectedCallProcess.getBase_CallBehaviorAction()); |
| if (process!=null) { |
| processor.getProcess().add(process); |
| process.getPersonaldata().add(selectedPersonalData); |
| } |
| |
| /** 4th. Purpose **/ |
| if (process!=null && consent!=null) { |
| purpose.getProcesses().add(process); |
| purpose.setConsent(consent); |
| } |
| |
| /** INSTANTIATE THE CONSENT PATTERN **/ |
| |
| /** Create a CallProcess **/ |
| Activity newProcess= UMLFactory.eINSTANCE.createActivity(); |
| String consentName = "GDPRConsent_"+process.getBase_NamedElement().getName(); |
| newProcess.setName(consentName); |
| Package DFDL1_Pkg = this.activityDFD.getModel().getNestedPackage(ModelPackageNames.DFD_L1_PackageName); |
| if (DFDL1_Pkg!=null && newProcess!=null) { |
| //System.err.printf(DFDL1_Pkg.toString()+"\n\n\n"); |
| //System.err.printf(newProcess.toString()+"\n\n\n"); |
| DFDL1_Pkg.getPackagedElements().add(newProcess); |
| CallBehaviorAction consentCallBehaviorAction=UMLFactory.eINSTANCE.createCallBehaviorAction(); |
| activityDFD.getOwnedNodes().add(consentCallBehaviorAction); |
| consentCallBehaviorAction.setName("GDPRConsent_"+process.getBase_NamedElement().getName()); |
| consentCallBehaviorAction.setBehavior(newProcess); |
| applyStereotypeToAction(consentCallBehaviorAction, ModelProfileNames.PDPbDProfileName, ModelProfileNames.PDPbD_CallProcess); |
| |
| /** Add DataInput and DataOutput pins **/ |
| InputPin inPin = UMLFactory.eINSTANCE.createInputPin(); |
| OutputPin outPin = UMLFactory.eINSTANCE.createOutputPin(); |
| if (inPin != null && outPin!=null) { |
| inPin.setType((Type) consent.getBase_NamedElement()); |
| outPin.setType((Type) consent.getBase_NamedElement()); |
| inPin.setName("InputPin1"); |
| outPin.setName("OutputPin2"); |
| consentCallBehaviorAction.getArguments().add(inPin); |
| consentCallBehaviorAction.getResults().add(outPin); |
| applyStereotypeToPin(inPin, ModelProfileNames.PDPbDProfileName, ModelProfileNames.PDPbD_DataInput); |
| applyStereotypeToPin(outPin, ModelProfileNames.PDPbDProfileName, ModelProfileNames.PDPbD_DataOutput); |
| |
| /** Connect DataSubject entity to the DataInput pin **/ |
| ObjectFlow dataFlowEdge1 = UMLFactory.eINSTANCE.createObjectFlow(); |
| if (dataFlowEdge1 !=null) { |
| dataFlowEdge1.setName("Consent_"+selectedDataSubject.getBase_ActivityParameterNode().getName()); |
| dataFlowEdge1.setSource(selectedDataSubject.getBase_ActivityParameterNode()); |
| dataFlowEdge1.setTarget(inPin); |
| activityDFD.getEdges().add(dataFlowEdge1); |
| |
| /** Connect DataOutput pin to Controller entity **/ |
| ObjectFlow dataFlowEdge2 = UMLFactory.eINSTANCE.createObjectFlow(); |
| if (dataFlowEdge2!=null) { |
| dataFlowEdge2.setName("Consent_"+selectedController.getBase_ActivityParameterNode().getName()); |
| dataFlowEdge2.setSource(outPin); |
| dataFlowEdge2.setTarget(selectedController.getBase_ActivityParameterNode()); |
| activityDFD.getEdges().add(dataFlowEdge2); |
| |
| /** Completing Behavior Process **/ |
| ActivityParameterNode parameterIn=UMLFactory.eINSTANCE.createActivityParameterNode(); |
| if (parameterIn!=null) { |
| parameterIn.setName(inPin.getName()); |
| parameterIn.setType(inPin.getType()); |
| newProcess.getOwnedNodes().add(parameterIn); |
| } |
| |
| ActivityParameterNode parameterOut=UMLFactory.eINSTANCE.createActivityParameterNode(); |
| if (parameterOut!=null) { |
| parameterOut.setName(outPin.getName()); |
| parameterOut.setType(outPin.getType()); |
| newProcess.getOwnedNodes().add(parameterOut); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Verify whether the needed profiles have been already loaded in the model |
| * @param profileList |
| * @return |
| */ |
| public boolean verifyProfilesApplied(EList<Profile> profileList) { |
| boolean found = false; |
| int noProfiles = 0; |
| for (Iterator<Profile> profileListIt = profileList.iterator(); profileListIt.hasNext() && noProfiles!=2;) { |
| Profile profile = profileListIt.next(); |
| if (profile!=null) { |
| String profileName = profile.getName(); |
| switch (profileName) { |
| case "pdp4engDesign": |
| noProfiles++; |
| break; |
| |
| case "pdp4engCommonGDPR": |
| noProfiles++; |
| break; |
| |
| } |
| } |
| } |
| if (noProfiles==2) { |
| found=true; |
| } |
| return found; |
| } |
| |
| /** |
| * Return the profile with the given name or null elsewhere |
| * @param profileName |
| * @return |
| */ |
| public Profile getProfile(String profileName) { |
| Profile profile = null; |
| for (ProfileApplication profileApplication : this.activityDFD.getModel().getProfileApplications()) { |
| profile = profileApplication.getAppliedProfile(); |
| if (profile.getName().equals(profileName)){ |
| return profile; |
| } |
| } |
| return profile; |
| } |
| |
| /** |
| * Create a Package with the given name. |
| * @param packageName |
| */ |
| public void createIfMissingPackage(String packageName){ |
| PackageableElement targetPackage = this.activityDFD.getModel().getPackagedElement(packageName); |
| if (targetPackage==null || !targetPackage.getName().equals(packageName)){ |
| this.activityDFD.getModel().createPackagedElement(packageName, UMLPackage.eINSTANCE.getPackage()); |
| } |
| } |
| |
| |
| /** |
| * Shows all the Call Process associated to an Activity DFD. Returns the CallProcess selected by the user. |
| * @return |
| */ |
| CallProcess selectCallProcessFromActivityDFD(String title, String message) { |
| CallProcess selectedCallProcess = null; |
| EList<Action> selectedCallProcList = new BasicEList<Action>(); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile PDPbDprofile = getProfile(ModelProfileNames.PDPbDProfileName); |
| EList<Element> elementList = this.activityDFD.getNearestPackage().allOwnedElements(); |
| if (elementList!=null && PDPbDprofile!=null) { |
| for (Iterator<Element> elementListIt = elementList.iterator(); elementListIt.hasNext();) { |
| Element element = elementListIt.next(); |
| EList<Stereotype> elementStypesList = element.getAppliedStereotypes(); |
| for (Iterator<Stereotype> elementStypeListIt = elementStypesList.iterator(); elementStypeListIt.hasNext();) { |
| Stereotype stype = elementStypeListIt.next(); |
| if (stype!=null && stype.getName().equals(ModelProfileNames.PDPbD_CallProcess)) { |
| if (element instanceof org.eclipse.uml2.uml.Action) { |
| Action actionElmt = (Action) element; |
| System.out.printf("CallProcess Name: "+actionElmt.getName()+"\n"); |
| if (!selectedCallProcList.contains(actionElmt)) { |
| selectedCallProcList.add(actionElmt); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| Object[] objList = new Object[selectedCallProcList.size()]; |
| Iterator<Action> selectedElementListIt = selectedCallProcList.iterator(); |
| for (int i=0; selectedElementListIt.hasNext()&& i<objList.length; i++) { |
| Action callProc = selectedElementListIt.next(); |
| objList[i] = callProc.getName(); |
| } |
| |
| ElementListSelectionDialog dialog = new ElementListSelectionDialog(Display.getCurrent().getActiveShell(), new LabelProvider()); |
| dialog.setElements(objList); |
| dialog.setTitle(title); |
| dialog.setMessage(message); |
| dialog.setHelpAvailable(true); |
| |
| if (dialog.open() != Window.OK) { |
| System.out.printf(">> A problem opening the CallProcess Window"); |
| } |
| |
| Object[] resultList = dialog.getResult(); |
| if (resultList!=null && resultList.length>0) { |
| Object result = resultList[0]; |
| for (Iterator<Action> selectedElementListIt1 = selectedCallProcList.iterator(); selectedElementListIt1.hasNext();) { |
| Action callProc = selectedElementListIt1.next(); |
| if (callProc.getName().equals(result)){ |
| selectedCallProcess = UMLUtil.getStereotypeApplication(callProc,CallProcess.class) ; |
| } |
| } |
| } |
| return selectedCallProcess; |
| } |
| |
| /** |
| * Shows all the External Entities associated to an Activity DFD. Returns the ExternalEntity selected by the user. |
| * @return |
| */ |
| ExternalEntity selectExternalEntityFromActivityDFD(String title, String message) { |
| ExternalEntity selectedEEntity = null; |
| EList<ActivityParameterNode> selectedEEntityList = new BasicEList<ActivityParameterNode>(); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile PDPbDprofile = getProfile(ModelProfileNames.PDPbDProfileName); |
| EList<Element> elementList = this.activityDFD.getNearestPackage().allOwnedElements(); |
| if (elementList!=null && PDPbDprofile!=null) { |
| for (Iterator<Element> elementListIt = elementList.iterator(); elementListIt.hasNext();) { |
| Element element = elementListIt.next(); |
| EList<Stereotype> elementStypesList = element.getAppliedStereotypes(); |
| for (Iterator<Stereotype> elementStypeListIt = elementStypesList.iterator(); elementStypeListIt.hasNext();) { |
| Stereotype stype = elementStypeListIt.next(); |
| if (stype!=null && stype.getName().equals(ModelProfileNames.PDPbD_ExternalEntity)) { |
| if (element instanceof org.eclipse.uml2.uml.ActivityParameterNode) { |
| ActivityParameterNode activityParameterNodeElmt = (ActivityParameterNode) element; |
| System.out.printf("ExternalEntity Name: "+activityParameterNodeElmt.getName()+"\n"); |
| if (!selectedEEntityList.contains(activityParameterNodeElmt)) { |
| selectedEEntityList.add(activityParameterNodeElmt); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| Object[] objList = new Object[selectedEEntityList.size()]; |
| Iterator<ActivityParameterNode> selectedEEntityListIt = selectedEEntityList.iterator(); |
| for (int i=0; selectedEEntityListIt.hasNext()&& i<objList.length; i++) { |
| ActivityParameterNode extEntity = selectedEEntityListIt.next(); |
| objList[i] = extEntity.getName(); |
| } |
| |
| ElementListSelectionDialog dialog = new ElementListSelectionDialog(Display.getCurrent().getActiveShell(), new LabelProvider()); |
| dialog.setElements(objList); |
| dialog.setTitle(title); |
| dialog.setMessage(message); |
| dialog.setHelpAvailable(true); |
| |
| if (dialog.open() != Window.OK) { |
| System.out.printf(">> A problem opening the ExternalEntity Window"); |
| } |
| |
| Object[] resultList = dialog.getResult(); |
| if (resultList!=null && resultList.length>0) { |
| Object result = resultList[0]; |
| for (Iterator<ActivityParameterNode> selectedEEntityListIt1 = selectedEEntityList.iterator(); selectedEEntityListIt1.hasNext();) { |
| ActivityParameterNode activityParamNode = selectedEEntityListIt1.next(); |
| if (activityParamNode.getName().equals(result)){ |
| selectedEEntity = UMLUtil.getStereotypeApplication(activityParamNode,ExternalEntity.class); |
| } |
| } |
| } |
| return selectedEEntity; |
| } |
| |
| /** |
| * hows all the Data associated to an Activity DFD. Stereotypes the selected Data as Personal and returns them. |
| * @param title |
| * @param message |
| * @return |
| */ |
| PersonalData selectPersonalDataFromActivityDFD(String title, String message) { |
| PersonalData selectedPersonalData = null; |
| EList<Classifier> selectedPersonalDataList = new BasicEList<Classifier>(); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile PDPbDprofile = getProfile(ModelProfileNames.PDPbDProfileName); |
| EList<Element> elementList = this.activityDFD.getModel().getNestedPackage(ModelPackageNames.Data_PackageName).allOwnedElements(); |
| if (elementList!=null && PDPbDprofile!=null) { |
| for (Iterator<Element> elementListIt = elementList.iterator(); elementListIt.hasNext();) { |
| Element element = elementListIt.next(); |
| EList<Stereotype> elementStypesList = element.getAppliedStereotypes(); |
| for (Iterator<Stereotype> elementStypeListIt = elementStypesList.iterator(); elementStypeListIt.hasNext();) { |
| Stereotype stype = elementStypeListIt.next(); |
| if (stype!=null && stype.getName().equals(ModelProfileNames.commonGDPR_PersonalData)) { |
| if (element instanceof org.eclipse.uml2.uml.Classifier) { |
| Classifier classElmt = (Classifier) element; |
| System.out.printf("PersonalData Name: "+classElmt.getName()+"\n"); |
| if (!selectedPersonalDataList.contains(classElmt)) { |
| selectedPersonalDataList.add(classElmt); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| Object[] objList = new Object[selectedPersonalDataList.size()]; |
| Iterator<Classifier> selectedPersonalDataListIt = selectedPersonalDataList.iterator(); |
| for (int i=0; selectedPersonalDataListIt.hasNext()&& i<objList.length; i++) { |
| Classifier extEntity = selectedPersonalDataListIt.next(); |
| objList[i] = extEntity.getName(); |
| } |
| |
| ElementListSelectionDialog dialog = new ElementListSelectionDialog(Display.getCurrent().getActiveShell(), new LabelProvider()); |
| dialog.setElements(objList); |
| dialog.setTitle(title); |
| dialog.setMessage(message); |
| dialog.setHelpAvailable(true); |
| |
| if (dialog.open() != Window.OK) { |
| System.out.printf(">> A problem opening the PersonalData Window"); |
| } |
| |
| Object[] resultList = dialog.getResult(); |
| if (resultList!=null && resultList.length>0) { |
| Object result = resultList[0]; |
| for (Iterator<Classifier> selectedPersonalDataListIt1 = selectedPersonalDataList.iterator(); selectedPersonalDataListIt1.hasNext();) { |
| Classifier activityParamNode = selectedPersonalDataListIt1.next(); |
| if (activityParamNode.getName().equals(result)){ |
| selectedPersonalData = UMLUtil.getStereotypeApplication(activityParamNode,PersonalData.class); |
| } |
| } |
| } |
| return selectedPersonalData; |
| } |
| |
| /** |
| * Create a Purpose with the given name within the Stakeholders package |
| * @param name |
| * @return |
| */ |
| Purpose createPurpose(String name) { |
| Purpose purpose = null; |
| createIfMissingPackage(ModelPackageNames.Stakeholder_PackageName); |
| Classifier purposeCls = this.activityDFD.getModel().getNestedPackage(ModelPackageNames.Stakeholder_PackageName). |
| createOwnedClass(name, false); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype purposeStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_Purpose); |
| if (purposeStype!=null){ |
| UMLUtil.safeApplyStereotype(purposeCls, purposeStype); |
| purpose = UMLUtil.getStereotypeApplication(purposeCls, Purpose.class); |
| } |
| } |
| } |
| return purpose; |
| } |
| |
| /** |
| * Create an Entity with the given name within the Stakeholders package |
| * @param name |
| * @return |
| */ |
| Entity createEntity(String name) { |
| Entity entity = null; |
| createIfMissingPackage(ModelPackageNames.Stakeholder_PackageName); |
| Classifier entityCls = this.activityDFD.getModel().getNestedPackage(ModelPackageNames.Stakeholder_PackageName). |
| createOwnedClass(name, false); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.PDPbDProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.PDPbD_Entity); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(entityCls, entityStype); |
| entity = UMLUtil.getStereotypeApplication(entityCls, Entity.class); |
| } |
| } |
| } |
| return entity; |
| } |
| |
| /** |
| * Create a Consent with the given name within the Data package |
| * @param name |
| * @return |
| */ |
| Consent createConsent(String name) { |
| Consent consent = null; |
| createIfMissingPackage(ModelPackageNames.Data_PackageName); |
| Classifier entityCls = this.activityDFD.getModel().getNestedPackage(ModelPackageNames.Data_PackageName). |
| createOwnedClass(name, false); |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_Consent); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(entityCls, entityStype); |
| consent = UMLUtil.getStereotypeApplication(entityCls, Consent.class); |
| } |
| } |
| } |
| return consent; |
| } |
| |
| /** |
| * Get the controller of an Entity |
| * @param entityCls |
| * @return |
| */ |
| Controller getController(NamedElement entityCls) { |
| Controller controller = null; |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_Controller); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(entityCls, entityStype); |
| controller = UMLUtil.getStereotypeApplication(entityCls, Controller.class); |
| } |
| } |
| } |
| return controller; |
| } |
| |
| /** |
| * Get the processor of an Entity |
| * @param entityCls |
| * @return |
| */ |
| Processor getProcessor(NamedElement entityCls) { |
| Processor processor = null; |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_Processor); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(entityCls, entityStype); |
| processor = UMLUtil.getStereotypeApplication(entityCls, Processor.class); |
| } |
| } |
| } |
| return processor; |
| } |
| |
| /** |
| * Get the Data Subject of an Entity |
| * @param entityCls |
| * @return |
| */ |
| DataSubject getDataSubject(NamedElement entityCls) { |
| DataSubject dataSubject = null; |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_DataSubject); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(entityCls, entityStype); |
| dataSubject = UMLUtil.getStereotypeApplication(entityCls, DataSubject.class); |
| } |
| } |
| } |
| return dataSubject; |
| } |
| |
| /** |
| * Get the process of a CallBehaviorAction |
| * @param entityCls |
| * @return |
| */ |
| Process getProcess(CallBehaviorAction callBehaviorAction) { |
| Process process = null; |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| if (verifyProfilesApplied(profileList)) { |
| Profile commonProfile = getProfile(ModelProfileNames.commonGDPRProfileName); |
| if (commonProfile!=null){ |
| Stereotype entityStype = commonProfile.getOwnedStereotype(ModelProfileNames.commonGDPR_Process); |
| if (entityStype!=null){ |
| UMLUtil.safeApplyStereotype(callBehaviorAction, entityStype); |
| process = UMLUtil.getStereotypeApplication(callBehaviorAction, Process.class); |
| } |
| } |
| } |
| return process; |
| } |
| |
| /** |
| * Safely apply the a stereotype to an ActivityParameterNode |
| * @param classifier |
| * @param stereotype |
| */ |
| public void applyStereotypeToActivityParameterNode(ActivityParameterNode activityPNode, String profileName, String stereotypeName) { |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| EList<Stereotype> appliedStypes = activityPNode.getAppliedStereotypes(); |
| if (verifyProfilesApplied(profileList) && profileName!=null && stereotypeName!=null && activityPNode!=null) { |
| Profile profile = getProfile(profileName); |
| if (profile!=null){ |
| Stereotype stereotype = profile.getOwnedStereotype(stereotypeName); |
| if (stereotype!=null && !appliedStypes.contains(stereotype)){ |
| UMLUtil.safeApplyStereotype(activityPNode, stereotype); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Safely apply the a stereotype to a Classifier |
| * @param classifier |
| * @param profileName |
| * @param stereotypeName |
| */ |
| public void applyStereotypeToClassifier(Classifier classifier, String profileName, String stereotypeName) { |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| EList<Stereotype> appliedStypes = classifier.getAppliedStereotypes(); |
| if (verifyProfilesApplied(profileList) && profileName!=null && stereotypeName!=null && classifier!=null) { |
| Profile profile = getProfile(profileName); |
| if (profile!=null){ |
| Stereotype stereotype = profile.getOwnedStereotype(stereotypeName); |
| if (stereotype!=null && !appliedStypes.contains(stereotype)){ |
| UMLUtil.safeApplyStereotype(classifier, stereotype); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Safely apply the a stereotype to a NamedElement |
| * @param namedElement |
| * @param profileName |
| * @param stereotypeName |
| */ |
| public void applyStereotypeToNamedElement(NamedElement namedElement, String profileName, String stereotypeName) { |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| EList<Stereotype> appliedStypes = namedElement.getAppliedStereotypes(); |
| if (verifyProfilesApplied(profileList) && profileName!=null && stereotypeName!=null && namedElement!=null) { |
| Profile profile = getProfile(profileName); |
| if (profile!=null){ |
| Stereotype stereotype = profile.getOwnedStereotype(stereotypeName); |
| if (stereotype!=null && !appliedStypes.contains(stereotype)){ |
| UMLUtil.safeApplyStereotype(namedElement, stereotype); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Safely apply the a stereotype to an Action node |
| * @param action |
| * @param profileName |
| * @param stereotypeName |
| */ |
| public void applyStereotypeToAction(Action action, String profileName, String stereotypeName) { |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| EList<Stereotype> appliedStypes = action.getAppliedStereotypes(); |
| if (verifyProfilesApplied(profileList) && profileName!=null && stereotypeName!=null && action!=null) { |
| Profile profile = getProfile(profileName); |
| if (profile!=null){ |
| Stereotype stereotype = profile.getOwnedStereotype(stereotypeName); |
| if (stereotype!=null && !appliedStypes.contains(stereotype)){ |
| UMLUtil.safeApplyStereotype(action, stereotype); |
| } |
| } |
| } |
| } |
| |
| public void applyStereotypeToPin(Pin pin, String profileName, String stereotypeName) { |
| EList<Profile> profileList = this.activityDFD.getModel().getAppliedProfiles(); |
| EList<Stereotype> appliedStypes = pin.getAppliedStereotypes(); |
| if (verifyProfilesApplied(profileList) && profileName!=null && stereotypeName!=null && pin!=null) { |
| Profile profile = getProfile(profileName); |
| if (profile!=null){ |
| Stereotype stereotype = profile.getOwnedStereotype(stereotypeName); |
| if (stereotype!=null && !appliedStypes.contains(stereotype)){ |
| UMLUtil.safeApplyStereotype(pin, stereotype); |
| } |
| } |
| } |
| } |
| } |
