diff --git a/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/DFD2GDPR.java b/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/DFD2GDPR.java index 9b3d97d..1670604 100644 --- a/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/DFD2GDPR.java +++ b/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/DFD2GDPR.java @@ -33,7 +33,6 @@ import mdpa.gdpr.dfdconverter.tracemodel.tracemodel.TraceModel; import mdpa.gdpr.dfdconverter.tracemodel.tracemodel.TracemodelFactory; import mdpa.gdpr.dfdconverter.tracemodel.tracemodel.TracemodelPackage; -import mdpa.gdpr.metamodel.GDPR.AbstractGDPRElement; import mdpa.gdpr.metamodel.GDPR.Collecting; import mdpa.gdpr.metamodel.GDPR.Consent; import mdpa.gdpr.metamodel.GDPR.Controller; @@ -47,6 +46,8 @@ import mdpa.gdpr.metamodel.GDPR.ThirdParty; import mdpa.gdpr.metamodel.GDPR.Transferring; import mdpa.gdpr.metamodel.GDPR.Usage; +import mdpa.laf.referencemodel.LAF.AssessmentFact; +import mdpa.laf.referencemodel.LAF.LegalContext; import mdpa.gdpr.metamodel.GDPR.LegalBasis; import mdpa.gdpr.metamodel.GDPR.NaturalPerson; import mdpa.gdpr.metamodel.GDPR.Obligation; @@ -166,10 +167,10 @@ public void transform() { // convert flows transformFlowsInOrder(); - if (laf.getInvolvedParties().stream().noneMatch(Controller.class::isInstance)) { + if (laf.getSubjects().stream().noneMatch(Controller.class::isInstance)) { var controller = gdprFactory.createController(); - laf.getInvolvedParties().add(controller); - laf.getProcessing().forEach(processing -> processing.setResponsible(controller)); + laf.getSubjects().add(controller); + laf.getActions().stream().filter(a -> a instanceof Processing).forEach(processing -> ((Processing)processing).setResponsible(controller)); } } @@ -204,58 +205,58 @@ private void convertLabel(LabelType type, Label label) { if (optLt.isPresent()) { LabelTrace lt = optLt.get(); // Put element in map - AbstractGDPRElement gdprElement = cloneGDPRElement(lt.getGdprElement()); + AssessmentFact assessmentFact = cloneAssessmentFact(lt.getAssessmentFact()); //AbstractGDPRElement gdprElement = lt.getGdprElement(); - labelToEntityMap.put(label, gdprElement); - lt.setGdprElement(gdprElement); + labelToEntityMap.put(label, assessmentFact); + lt.setAssessmentFact(assessmentFact); outTrace.getLabelTraces().add(lt); } else { switch(type.getEntityName()) { case "Controller": - createNewGPDRElement(label, type, gdprFactory.createController(), laf.getInvolvedParties()); + createNewAssessmentFact(label, type, gdprFactory.createController(), laf.getSubjects()); break; case "NaturalPerson": - createNewGPDRElement(label, type, gdprFactory.createNaturalPerson(), laf.getInvolvedParties()); + createNewAssessmentFact(label, type, gdprFactory.createNaturalPerson(), laf.getContext()); break; case "ThirdParty": - createNewGPDRElement(label, type, gdprFactory.createThirdParty(), laf.getInvolvedParties()); + createNewAssessmentFact(label, type, gdprFactory.createThirdParty(), laf.getSubjects()); break; case "Consent": - createNewGPDRElement(label, type, gdprFactory.createConsent(), laf.getLegalBases()); + createNewAssessmentFact(label, type, gdprFactory.createConsent(), laf.getContext()); break; case "Obligation": - createNewGPDRElement(label, type, gdprFactory.createObligation(), laf.getLegalBases()); + createNewAssessmentFact(label, type, gdprFactory.createObligation(), laf.getContext()); break; case "Contract": - createNewGPDRElement(label, type, gdprFactory.createPerformanceOfContract(), laf.getLegalBases()); + createNewAssessmentFact(label, type, gdprFactory.createPerformanceOfContract(), laf.getContext()); break; case "PublicAuthority": - createNewGPDRElement(label, type, gdprFactory.createExerciseOfPublicAuthority(), laf.getLegalBases()); + createNewAssessmentFact(label, type, gdprFactory.createExerciseOfPublicAuthority(), laf.getContext()); break; case "Purposes": - createNewGPDRElement(label, type, gdprFactory.createPurpose(), laf.getPurposes()); + createNewAssessmentFact(label, type, gdprFactory.createPurpose(), laf.getContext()); break; case "Data": - createNewGPDRElement(label, type, gdprFactory.createData(), laf.getData()); + createNewAssessmentFact(label, type, gdprFactory.createData(), laf.getObjects()); break; case "PersonalData": - createNewGPDRElement(label, type, gdprFactory.createPersonalData(), laf.getData()); + createNewAssessmentFact(label, type, gdprFactory.createPersonalData(), laf.getObjects()); break; } } } - private T createNewGPDRElement(Label label, LabelType type, T gdprElement, List lafElementCollection) { - gdprElement.setEntityName(label.getEntityName()); - gdprElement.setId(label.getId()); - labelToEntityMap.put(label, gdprElement); - lafElementCollection.add(gdprElement); + private T createNewAssessmentFact(Label label, LabelType type, T assessmentFact, List lafElementCollection) { + assessmentFact.setEntityName(label.getEntityName()); + assessmentFact.setId(label.getId()); + labelToEntityMap.put(label, assessmentFact); + lafElementCollection.add(assessmentFact); LabelTrace lt = TracemodelFactory.eINSTANCE.createLabelTrace(); - lt.setGdprElement(gdprElement); + lt.setAssessmentFact(assessmentFact); lt.setLabel(label); lt.setLabelType(type); outTrace.getLabelTraces().add(lt); - return gdprElement; + return assessmentFact; } private Optional labelTraceLookup(LabelType type, Label label) { @@ -282,7 +283,7 @@ private void convertNode(Node node) { gdprProcessing = createNewGDPRProcessing(node); addNodeTrace(node, gdprProcessing); } - laf.getProcessing().add(gdprProcessing); + laf.getActions().add(gdprProcessing); mapNodeToProcessing.put(node, gdprProcessing); } @@ -408,7 +409,7 @@ private void createProcessingReferences(Node node) { } private Data getDataFromPin(Pin pin) { - return laf.getData().stream().filter(it -> it.getEntityName().equals(pin.getEntityName())).findAny().orElse(null); + return (Data) laf.getObjects().stream().filter(it -> it.getEntityName().equals(pin.getEntityName())).findAny().orElse(null); } /** @@ -436,8 +437,8 @@ private void transformFlowsInOrder() { if (collectingNodes.contains(node) && processing.getOutputData().isEmpty()) { var dataCollecting = gdprFactory.createData(); var purposeCollecting = gdprFactory.createPurpose(); - laf.getData().add(dataCollecting); - laf.getPurposes().add(purposeCollecting); + laf.getObjects().add(dataCollecting); + laf.getContext().add(purposeCollecting); processing.getOutputData().add(dataCollecting); processing.getPurpose().add(purposeCollecting); @@ -514,16 +515,14 @@ private Optional> flowTraceLookup(Flow flow) { } //Cloning because of ECore Containment - private AbstractGDPRElement cloneGDPRElement(AbstractGDPRElement element) { + private AssessmentFact cloneAssessmentFact(AssessmentFact element) { if (element instanceof Data data) { return cloneData(data); - } else if (element instanceof LegalBasis legalBasis) { - return cloneLegalBasis(legalBasis); + } else if (element instanceof LegalContext context) { + return cloneContext(context); } else if (element instanceof Processing processing) { return cloneProcessing(processing); - } else if (element instanceof Purpose purpose) { - return clonePurpose(purpose); - } else if (element instanceof Role role) { + } else if (element instanceof Role role) { return cloneRole(role); } else { return null; @@ -532,19 +531,18 @@ private AbstractGDPRElement cloneGDPRElement(AbstractGDPRElement element) { private Data cloneData(Data data) { if (gdprElementClonesMap.containsKey(data)) return (Data) gdprElementClonesMap.get(data); - Data clone; if (data instanceof PersonalData personalData) { - clone = GDPRFactory.eINSTANCE.createPersonalData(); + clone = gdprFactory.createPersonalData(); personalData.getDataReferences().forEach(reference -> { - ((PersonalData)clone).getDataReferences().add((NaturalPerson)cloneRole(reference)); + ((PersonalData)clone).getDataReferences().add((NaturalPerson)cloneContext(reference)); }); - } else clone = GDPRFactory.eINSTANCE.createData(); + } else clone = gdprFactory.createData(); clone.setEntityName(data.getEntityName()); clone.setId(data.getId()); - laf.getData().add(clone); + laf.getObjects().add(clone); gdprElementClonesMap.put(data, clone); return clone; @@ -558,12 +556,10 @@ private Role cloneRole(Role role) { Role clone; if (role instanceof Controller) { - clone = GDPRFactory.eINSTANCE.createController(); + clone = gdprFactory.createController(); } else if (role instanceof ThirdParty) { - clone = GDPRFactory.eINSTANCE.createThirdParty(); - } else { - clone = GDPRFactory.eINSTANCE.createNaturalPerson(); - } + clone = gdprFactory.createThirdParty(); + } else throw new IllegalArgumentException(); if (role.getName() != null) { clone.setName(role.getName()); @@ -571,57 +567,67 @@ private Role cloneRole(Role role) { clone.setEntityName(role.getEntityName()); clone.setId(role.getId()); - laf.getInvolvedParties().add(clone); + laf.getSubjects().add(clone); gdprElementClonesMap.put(role, clone); return clone; } - private Purpose clonePurpose(Purpose purpose) { - if (gdprElementClonesMap.containsKey(purpose)) return (Purpose) gdprElementClonesMap.get(purpose); - - Purpose clone = GDPRFactory.eINSTANCE.createPurpose(); - clone.setEntityName(purpose.getEntityName()); - clone.setId(purpose.getId()); + private LegalContext cloneContext(LegalContext context) { + if (gdprElementClonesMap.containsKey(context)) return (LegalContext) gdprElementClonesMap.get(context); + + LegalContext clone; + if (context instanceof NaturalPerson naturalPerson) { + clone = cloneNaturalPerson(naturalPerson); + } else if (context instanceof LegalBasis legalBasis) { + clone = cloneLegalBasis(legalBasis); + } else if (context instanceof Purpose purpose) { + clone = gdprFactory.createPurpose(); + } else { + return null; + } - laf.getPurposes().add(clone); - gdprElementClonesMap.put(purpose, clone); + clone.setEntityName(context.getEntityName()); + clone.setId(context.getId()); + laf.getContext().add(clone); + gdprElementClonesMap.put(context, clone); return clone; } + private NaturalPerson cloneNaturalPerson(NaturalPerson naturalPerson) { + NaturalPerson clone = gdprFactory.createNaturalPerson(); + if (naturalPerson.getName() != null) { + clone.setName(naturalPerson.getName()); + } + return clone; + } + private LegalBasis cloneLegalBasis(LegalBasis legalBasis) { if(gdprElementClonesMap.containsKey(legalBasis)) return (LegalBasis) gdprElementClonesMap.get(legalBasis); LegalBasis clone; if (legalBasis instanceof Consent consent) { - clone = GDPRFactory.eINSTANCE.createConsent(); - ((Consent)clone).setConsentee((NaturalPerson)cloneRole(consent.getConsentee())); + clone = gdprFactory.createConsent(); + ((Consent)clone).setConsentee((NaturalPerson)cloneContext(consent.getConsentee())); } else if (legalBasis instanceof PerformanceOfContract contract) { - clone = GDPRFactory.eINSTANCE.createPerformanceOfContract(); + clone = gdprFactory.createPerformanceOfContract(); contract.getContractingParty().forEach(party -> { ((PerformanceOfContract)clone).getContractingParty().add(cloneRole(party)); }); } else if (legalBasis instanceof ExerciseOfPublicAuthority) { - clone = GDPRFactory.eINSTANCE.createExerciseOfPublicAuthority(); + clone = gdprFactory.createExerciseOfPublicAuthority(); } else if (legalBasis instanceof Obligation) { - clone = GDPRFactory.eINSTANCE.createObligation(); - } else clone = GDPRFactory.eINSTANCE.createLegalBasis(); + clone = gdprFactory.createObligation(); + } else clone = gdprFactory.createLegalBasis(); legalBasis.getForPurpose().forEach(purpose -> { - clone.getForPurpose().add(clonePurpose(purpose)); + clone.getForPurpose().add((Purpose)cloneContext(purpose)); }); if (legalBasis.getPersonalData() != null) clone.setPersonalData((PersonalData)cloneData(legalBasis.getPersonalData())); - clone.setEntityName(legalBasis.getEntityName()); - clone.setId(legalBasis.getId()); - - - laf.getLegalBases().add(clone); - gdprElementClonesMap.put(legalBasis, clone); - return clone; } @@ -634,11 +640,11 @@ private Processing cloneProcessing(Processing processing) { if (gdprElementClonesMap.containsKey(processing)) return (Processing) gdprElementClonesMap.get(processing); Processing clone; - if ( processing instanceof Collecting) clone= GDPRFactory.eINSTANCE.createCollecting(); - else if (processing instanceof Storing) clone = GDPRFactory.eINSTANCE.createStoring(); - else if (processing instanceof Transferring) clone = GDPRFactory.eINSTANCE.createTransferring(); - else if (processing instanceof Usage) clone = GDPRFactory.eINSTANCE.createUsage(); - else clone = GDPRFactory.eINSTANCE.createProcessing(); + if ( processing instanceof Collecting) clone= gdprFactory.createCollecting(); + else if (processing instanceof Storing) clone = gdprFactory.createStoring(); + else if (processing instanceof Transferring) clone = gdprFactory.createTransferring(); + else if (processing instanceof Usage) clone = gdprFactory.createUsage(); + else clone = gdprFactory.createProcessing(); if(processing.getResponsible() != null) clone.setResponsible((Role)cloneRole(processing.getResponsible())); @@ -648,9 +654,9 @@ private Processing cloneProcessing(Processing processing) { processing.getInputData().forEach(data -> clone.getInputData().add(cloneData(data))); processing.getOutputData().forEach(data -> clone.getOutputData().add(cloneData(data))); processing.getOnTheBasisOf().forEach(legalBasis -> clone.getOnTheBasisOf().add(cloneLegalBasis(legalBasis))); - processing.getPurpose().forEach(purpose -> clone.getPurpose().add(clonePurpose(purpose))); + processing.getPurpose().forEach(purpose -> clone.getPurpose().add((Purpose)cloneContext(purpose))); - laf.getProcessing().add(clone); + laf.getActions().add(clone); gdprElementClonesMap.put(processing, clone); return clone; diff --git a/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/GDPR2DFD.java b/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/GDPR2DFD.java index 2288fdc..758028a 100644 --- a/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/GDPR2DFD.java +++ b/bundles/mdpa.gdpr.dfdconverter/src/mdpa/gdpr/dfdconverter/GDPR2DFD.java @@ -13,6 +13,7 @@ import org.eclipse.emf.ecore.xmi.impl.XMLResourceFactoryImpl; import mdpa.gdpr.metamodel.GDPR.*; +import mdpa.laf.referencemodel.LAF.AssessmentFact; import tools.mdsd.modelingfoundations.identifier.Entity; import mdpa.gdpr.dfdconverter.tracemodel.tracemodel.*; @@ -239,26 +240,13 @@ public void transform() { annotateNodeLabels(); //Create Flows - laf.getProcessing().stream().forEach(p -> { - dfd.getFlows().addAll(createFlows(p)); + laf.getActions().stream().filter(a -> a instanceof Processing).forEach(p -> { + dfd.getFlows().addAll(createFlows((Processing)p)); }); - - //Sorry for that but otherwise containment causes issues - var newFlowTraces = outTrace.getFlowTraces().stream().map(ft -> { - var flowTrace = TracemodelFactory.eINSTANCE.createFlowTrace(); - flowTrace.setDataFlow(dfd.getFlows().stream().filter(flow -> flow.getId().equals(ft.getDataFlow().getId())).findAny().orElseThrow()); - flowTrace.setData(ft.getData()); - flowTrace.setDest(ft.getDest()); - flowTrace.setSource(ft.getSource()); - return flowTrace; - }).toList(); - - outTrace.getFlowTraces().clear(); - outTrace.getFlowTraces().addAll(newFlowTraces); - + // Create/Annotate Behaviors to Nodes - laf.getProcessing().stream().forEach(p -> { - annotateBehaviour(p); + laf.getActions().stream().filter(a -> a instanceof Processing).forEach(p -> { + annotateBehaviour((Processing)p); }); } @@ -303,71 +291,68 @@ private LabelType getOrCreateLabelType(String typeName) { * Creates all Labels to hold GDPR specific information */ private void createLabels() { - laf.getInvolvedParties().forEach(role -> { - if (role instanceof NaturalPerson) convertElementToLabel(role,this.personLabelType); - else if (role instanceof ThirdParty) convertElementToLabel(role, this.thirdPartyLabelType); - else if (role instanceof Controller) convertElementToLabel(role, this.controllerLabelType); - }); - - laf.getLegalBases().forEach(legalBasis -> { - if (legalBasis instanceof Consent) convertElementToLabel(legalBasis, this.consentLabelType); - else if (legalBasis instanceof Obligation) convertElementToLabel(legalBasis, this.obligationLabelType); - else if (legalBasis instanceof PerformanceOfContract) convertElementToLabel(legalBasis, this.contractLabelType); - else if (legalBasis instanceof ExerciseOfPublicAuthority) convertElementToLabel(legalBasis, this.authorityLabelType); - }); - - laf.getPurposes().forEach(purpose -> { - convertElementToLabel(purpose, this.purposeLabelType); - }); - - laf.getData().forEach(data -> { - if (data instanceof PersonalData personalData) convertElementToLabel(data, this.personalDataLabelType); - else convertElementToLabel(data, dataLabelType); + laf.getContext().forEach(context -> { + if (context instanceof Consent) convertElementToLabel(context, this.consentLabelType); + else if (context instanceof Obligation) convertElementToLabel(context, this.obligationLabelType); + else if (context instanceof PerformanceOfContract) convertElementToLabel(context, this.contractLabelType); + else if (context instanceof ExerciseOfPublicAuthority) convertElementToLabel(context, this.authorityLabelType); + else if (context instanceof NaturalPerson) convertElementToLabel(context,this.personLabelType); + else if (context instanceof Purpose) convertElementToLabel(context,this.purposeLabelType); + }); + + laf.getSubjects().forEach(subjects -> { + if (subjects instanceof ThirdParty) convertElementToLabel(subjects, this.thirdPartyLabelType); + else if (subjects instanceof Controller) convertElementToLabel(subjects, this.controllerLabelType); + }); + + laf.getObjects().forEach(object -> { + if (object instanceof PersonalData) convertElementToLabel(object, this.personalDataLabelType); + else if (object instanceof Data)convertElementToLabel(object, dataLabelType); }); createProcessingTypeLabels(); } - private void convertElementToLabel(AbstractGDPRElement gdprElement, LabelType type) { - if(!entityToLabelMap.containsKey(gdprElement)) { + private void convertElementToLabel(AssessmentFact assessmentFact, LabelType type) { + if(!entityToLabelMap.containsKey(assessmentFact)) { Label label; - var optLt = labelTraceLookup(gdprElement, type); + var optLt = labelTraceLookup(assessmentFact, type); if (optLt.isPresent()) { LabelTrace lt = optLt.get(); label = lt.getLabel(); type.getLabel().add(label); outTrace.getLabelTraces().add(lt); } else { - label = createLabel(gdprElement, type); - addLabelTrace(gdprElement, label, type); + label = createLabel(assessmentFact, type); + addLabelTrace(assessmentFact, label, type); } - entityToLabelMap.put(gdprElement, label); + entityToLabelMap.put(assessmentFact, label); } } - private Label createLabel(AbstractGDPRElement gdprElement, LabelType type) { + private Label createLabel(AssessmentFact assessmentFact, LabelType type) { Label label; label = ddFactory.createLabel(); - label.setEntityName(gdprElement.getEntityName()); - label.setId(gdprElement.getId()); + label.setEntityName(assessmentFact.getEntityName()); + label.setId(assessmentFact.getId()); type.getLabel().add(label); return label; } - private Optional labelTraceLookup(AbstractGDPRElement gdprElement, LabelType type) { + private Optional labelTraceLookup(AssessmentFact assessmentFact, LabelType type) { if (inTrace == null) { return Optional.empty(); } return inTrace.getLabelTraces().stream() .filter( // same id ensures same element, same labeltype also ensures same gdpr class lt -> lt.getLabelType().getEntityName().equals(type.getEntityName()) && - lt.getGdprElement().getId().equals(gdprElement.getId())) + lt.getAssessmentFact().getId().equals(assessmentFact.getId())) .findAny(); } - private void addLabelTrace(AbstractGDPRElement gdprElement, Label label, LabelType type) { + private void addLabelTrace(AssessmentFact assessmentFact, Label label, LabelType type) { var lt = TracemodelFactory.eINSTANCE.createLabelTrace(); - lt.setGdprElement(gdprElement); + lt.setAssessmentFact(assessmentFact); lt.setLabel(label); lt.setLabelType(type); outTrace.getLabelTraces().add(lt); @@ -386,8 +371,8 @@ private void createProcessingTypeLabels() { } private void createNodes() { - laf.getProcessing().stream().forEach(p -> { - Node node = convertProcessing(p); + laf.getActions().stream().filter(p -> p instanceof Processing).forEach(p -> { + Node node = convertProcessing((Processing) p); dfd.getNodes().add(node); }); } @@ -460,8 +445,8 @@ private void addNodeTrace(Processing processing, Node node) { } private void annotateNodeLabels() { - laf.getProcessing().stream().forEach(p -> { - addNodeLabels(p); + laf.getActions().stream().filter(p -> p instanceof Processing).forEach(p -> { + addNodeLabels((Processing) p); }); } diff --git a/releng/mdpa.gdpr.dfdconverter.targetplatform/mdpa.gdpr.dfdconverter.targetplatform.target b/releng/mdpa.gdpr.dfdconverter.targetplatform/mdpa.gdpr.dfdconverter.targetplatform.target index c515333..989e9d4 100644 --- a/releng/mdpa.gdpr.dfdconverter.targetplatform/mdpa.gdpr.dfdconverter.targetplatform.target +++ b/releng/mdpa.gdpr.dfdconverter.targetplatform/mdpa.gdpr.dfdconverter.targetplatform.target @@ -8,7 +8,7 @@ - + @@ -129,5 +129,9 @@ + + + + \ No newline at end of file diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/.project b/tests/mdpa.gdpr.dfdconverter.tests/models/.project new file mode 100644 index 0000000..f8161ad --- /dev/null +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/.project @@ -0,0 +1,11 @@ + + + models + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dd b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dd index c0aa2e2..fdd375e 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dd +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dd @@ -8,6 +8,14 @@ - + - - + + + + + + + + + + + + - - - + + + + + + + + + + + + + - - - + + + + + + + + + + + + + - - + + - + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dfd b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dfd index 9e462ee..0af9ddf 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dfd +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.dfd @@ -1,5 +1,9 @@ + + + + @@ -12,38 +16,74 @@ - - - - - + + + + + + + + + - + + + + + + + + + - + + + + + + + + + - + + + + + + + + + - + + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.gdpr b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.gdpr new file mode 100644 index 0000000..d1d7d2c --- /dev/null +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.gdpr @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.tracemodel b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.tracemodel new file mode 100644 index 0000000..a2b6957 --- /dev/null +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/DFD/minimal.tracemodel @@ -0,0 +1,175 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dd b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dd index 18533d0..a96afc1 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dd +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dd @@ -1,62 +1,42 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dfd b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dfd index f8d6094..5cd2596 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dfd +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.dfd @@ -1,49 +1,38 @@ - - - - - - - - - - - - - - - - - - - - - - + + + + + + + - - - - - + + + + + + - - - - - + + + + + + - - - - - + + + + + + - - - - - + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.gdpr b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.gdpr index ca804f8..ef68822 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.gdpr +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.gdpr @@ -1,31 +1,17 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + diff --git a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.tracemodel b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.tracemodel index 9a74df5..5466e14 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.tracemodel +++ b/tests/mdpa.gdpr.dfdconverter.tests/models/GDPR/minimal.tracemodel @@ -1,97 +1,68 @@ - - + + - - + + - - + + - - + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ManualModelCreation.java b/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ManualModelCreation.java index 3fade27..f466088 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ManualModelCreation.java +++ b/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ManualModelCreation.java @@ -94,7 +94,7 @@ private void runTransformations(DataFlowDiagram dfd, DataDictionary dd, TraceMod DataDictionary dd2 = gdpr2dfd.getDataDictionary(); trace = gdpr2dfd.getGDPR2DFDTrace(); - assertEquals(dfd2.getNodes().size(), laf.getProcessing().size()); + assertEquals(dfd2.getNodes().size(), laf.getActions().stream().filter(a -> a instanceof Processing).count()); DFD2GDPR dfd2gdpr2 = new DFD2GDPR(dfd2, dd2, trace); dfd2gdpr2.transform(); @@ -159,8 +159,8 @@ private static void buildAlshareef(DataFlowDiagram dfd, DataDictionary dd, Trace user.setEntityName("user"); var guest = gdprFactory.createNaturalPerson(); user.setEntityName("guest"); - laf.getInvolvedParties().add(user); - laf.getInvolvedParties().add(guest); + laf.getContext().add(user); + laf.getContext().add(guest); var dataInstall = createAndAddData("", laf, null); var dataLogin = createAndAddData("", laf, List.of(user, guest)); @@ -193,20 +193,20 @@ private static void buildAlshareef(DataFlowDiagram dfd, DataDictionary dd, Trace var consent = gdprFactory.createConsent(); consent.setConsentee(user); consent.setPersonalData((PersonalData)data); - laf.getLegalBases().add(consent); + laf.getContext().add(consent); mapNodeToProcessing.values().forEach(p -> p.getOnTheBasisOf().add(consent)); }); var controller = gdprFactory.createController(); controller.setEntityName("Controller"); - laf.getInvolvedParties().add(controller); + laf.getSubjects().add(controller); mapNodeToProcessing.values().forEach(p -> p.setResponsible(controller)); } private static Purpose createAndAddPurpose(String name, List processings, LegalAssessmentFacts laf) { var purpose = gdprFactory.createPurpose(); purpose.setEntityName(name); - laf.getPurposes().add(purpose); + laf.getContext().add(purpose); processings.forEach(processing -> processing.getPurpose().add(purpose)); return purpose; @@ -219,7 +219,7 @@ private static Data createAndAddData(String name, LegalAssessmentFacts laf, List ((PersonalData)data).getDataReferences().addAll(persons); } else data = gdprFactory.createData(); data.setEntityName(name); - laf.getData().add(data); + laf.getObjects().add(data); return data; } @@ -247,24 +247,24 @@ private static void buildSion(DataFlowDiagram dfd, DataDictionary dd, TraceModel var patient = gdprFactory.createNaturalPerson(); patient.setEntityName("Patient"); patient.setName("Patient"); - laf.getInvolvedParties().add(patient); + laf.getContext().add(patient); var personalData = gdprFactory.createPersonalData(); personalData.setEntityName(""); personalData.getDataReferences().add(patient); - laf.getData().add(personalData); + laf.getObjects().add(personalData); var riskData = gdprFactory.createData(); riskData.setEntityName("Risk Data"); - laf.getData().add(riskData); + laf.getObjects().add(riskData); var controller = gdprFactory.createController(); controller.setEntityName("Controller"); - laf.getInvolvedParties().add(controller); + laf.getSubjects().add(controller); var purpose = gdprFactory.createPurpose(); purpose.setEntityName("GP purpose"); - laf.getPurposes().add(purpose); + laf.getContext().add(purpose); mapNodeToProcessing.values().forEach(processing -> processing.setResponsible(controller)); @@ -332,7 +332,7 @@ private static Node createNode(String name, Class type, Map a instanceof Processing).count()); GDPR2DFD gdpr2dfd = new GDPR2DFD(laf, dd, trace); gdpr2dfd.transform(); @@ -162,7 +164,7 @@ public void testModelPair() { DataDictionary dd2 = gdpr2dfd.getDataDictionary(); trace = gdpr2dfd.getGDPR2DFDTrace(); - assertEquals(dfd2.getNodes().size(), laf.getProcessing().size()); + assertEquals(dfd2.getNodes().size(), laf.getActions().stream().filter(a -> a instanceof Processing).count()); DFD2GDPR dfd2gdpr2 = new DFD2GDPR(dfd2, dd2, trace); dfd2gdpr2.transform(); @@ -171,7 +173,7 @@ public void testModelPair() { LegalAssessmentFacts laf2 = dfd2gdpr2.getLegalAssessmentFacts(); trace = dfd2gdpr2.getDFD2GDPRTrace(); - assertEquals(dfd.getNodes().size(), laf2.getProcessing().size()); + assertEquals(dfd.getNodes().size(), laf2.getActions().stream().filter(a -> a instanceof Processing).count()); GDPR2DFD gdpr2dfd2 = new GDPR2DFD(laf2, dd2, trace); gdpr2dfd2.transform(); @@ -245,7 +247,7 @@ public static Collection dataPCM() { } - public static Collection convertPalladio() { + /*public static Collection convertPalladio() { List testData = new ArrayList<>(); var pcmData = dataPCM(); System.out.println(pcmData.size()); @@ -269,7 +271,7 @@ public static Collection convertPalladio() { testData.add(new File[] {new File(resultFolder + name + ".dataflowdiagram"), new File(resultFolder + name + ".datadictionary")}); }); return testData; - } + }*/ public static void annotateMetaData(String fileName, String folder) { StringBuilder builder = new StringBuilder(); @@ -325,9 +327,9 @@ public static void annotateMetaData(String fileName, String folder) { var laf = (LegalAssessmentFacts) gdprResource.getContents().get(0); builder.append("GDPR Cycle " + (i+1) + ":").append("\n"); - builder.append("Number of Processings: ").append(laf.getProcessing().size()).append("\n"); - builder.append("Number of Data: ").append(laf.getData().size()).append("\n"); - builder.append("Number of Purposes: ").append(laf.getPurposes().size()).append("\n"); + builder.append("Number of Processings: ").append(laf.getActions().stream().filter(a -> a instanceof Processing).count()).append("\n"); + builder.append("Number of Data: ").append(laf.getObjects().stream().filter(o -> o instanceof Data).count()).append("\n"); + builder.append("Number of Purposes: ").append(laf.getContext().stream().filter(c -> c instanceof Purpose).count()).append("\n"); newFileName += "2D2G"; } diff --git a/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ScalabilityTests.java b/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ScalabilityTests.java index e1b7b21..f5f9a4a 100644 --- a/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ScalabilityTests.java +++ b/tests/mdpa.gdpr.dfdconverter.tests/src/mdpa/gdpr/dfdconverter/tests/ScalabilityTests.java @@ -39,7 +39,7 @@ public class ScalabilityTests { private static GDPRFactory gdprFactory = GDPRFactory.eINSTANCE; private static final String resultFolder = "C:\\Users\\Huell\\Documents\\Studium\\HIWI\\GDPR2DFD-Converter\\tests\\mdpa.gdpr.dfdconverter.tests\\results\\Scalability\\"; - private static final int max = 6; + private static final int max = 3; @Test @@ -136,7 +136,7 @@ public void runGDPRProcessingTest() { recordedDurations[i-1][j] = durationMs; writer.write("Iteration " + i + " took " + durationMs + " ms " + - "with " + laf.getProcessing().size() + " processing elements."); + "with " + laf.getActions().size() + " processing elements."); writer.newLine(); } @@ -191,7 +191,7 @@ public void runGDPRoleTest() { recordedDurations[i-1][j] = durationMs; writer.write("Iteration " + i + " took " + durationMs + " ms " + - "with " + laf.getInvolvedParties().size() + " role elements."); + "with " + (laf.getSubjects().size() + laf.getContext().stream().filter(NaturalPerson.class::isInstance).count()) + " role + user elements."); writer.newLine(); } @@ -247,7 +247,7 @@ public void runGDPRPurposeTest() { recordedDurations[i-1][j] = durationMs; writer.write("Iteration " + i + " took " + durationMs + " ms " + - "with " + laf.getPurposes().size() + " purpose elements."); + "with " + laf.getContext().stream().filter(Purpose.class::isInstance).count() + " purpose elements."); writer.newLine(); } @@ -340,9 +340,9 @@ private static LegalAssessmentFacts createProcessingLAF(int exponent) { PersonalData data = gdprFactory.createPersonalData(); NaturalPerson user = gdprFactory.createNaturalPerson(); data.getDataReferences().add(user); - laf.getProcessing().add(start); - laf.getInvolvedParties().add(user); - laf.getData().add(data); + laf.getActions().add(start); + laf.getContext().add(user); + laf.getObjects().add(data); start.setEntityName("collecting"); data.setEntityName("data"); user.setEntityName("user"); @@ -350,7 +350,7 @@ private static LegalAssessmentFacts createProcessingLAF(int exponent) { Purpose purposeCollecting = gdprFactory.createPurpose(); purposeCollecting.setEntityName("purposeCollecting"); start.getPurpose().add(purposeCollecting); - laf.getPurposes().add(purposeCollecting); + laf.getContext().add(purposeCollecting); Consent consent = gdprFactory.createConsent(); consent.setEntityName("consent"); @@ -358,13 +358,13 @@ private static LegalAssessmentFacts createProcessingLAF(int exponent) { consent.setPersonalData(data); consent.setConsentee(user); start.getOnTheBasisOf().add(consent); - laf.getLegalBases().add(consent); + laf.getContext().add(consent); Controller controller = gdprFactory.createController(); start.setResponsible(controller); start.getOutputData().add(data); controller.setEntityName("Controller"); - laf.getInvolvedParties().add(controller); + laf.getSubjects().add(controller); List currentProcessing = new ArrayList<>(); currentProcessing.add(start); @@ -383,7 +383,7 @@ private static LegalAssessmentFacts createProcessingLAF(int exponent) { current.getFollowingProcessing().add(processing); newCurrent.add(processing); - laf.getProcessing().add(processing); + laf.getActions().add(processing); } } currentProcessing = newCurrent; @@ -396,21 +396,21 @@ private static LegalAssessmentFacts createProcessingLAF(int exponent) { public LegalAssessmentFacts createRoleLaf(int exponent) { LegalAssessmentFacts laf = createProcessingLAF(1); - PersonalData data = laf.getData().stream().filter(PersonalData.class::isInstance).map(PersonalData.class::cast).findAny().orElseThrow(); + PersonalData data = laf.getObjects().stream().filter(PersonalData.class::isInstance).map(PersonalData.class::cast).findAny().orElseThrow(); for (int i = 0; i < Math.pow(10, exponent) - 2; i++) { NaturalPerson person = gdprFactory.createNaturalPerson(); person.setEntityName("person" + i); data.getDataReferences().add(person); - laf.getInvolvedParties().add(person); + laf.getContext().add(person); Consent consent = gdprFactory.createConsent(); consent.setConsentee(person); - consent.getForPurpose().addAll(laf.getPurposes()); + consent.getForPurpose().addAll(laf.getContext().stream().filter(Purpose.class::isInstance).map(Purpose.class::cast).toList()); consent.setPersonalData(data); - laf.getProcessing().forEach(processing -> processing.getOnTheBasisOf().add(consent)); - laf.getLegalBases().add(consent); + laf.getActions().stream().filter(Processing.class::isInstance).forEach(processing -> ((Processing)processing).getOnTheBasisOf().add(consent)); + laf.getContext().add(consent); } return laf; @@ -418,12 +418,12 @@ public LegalAssessmentFacts createRoleLaf(int exponent) { public LegalAssessmentFacts createPurposeLaf(int exponent) { LegalAssessmentFacts laf = createProcessingLAF(1); - Consent consent = laf.getLegalBases().stream().filter(Consent.class::isInstance).map(Consent.class::cast).findAny().orElseThrow(); + Consent consent = laf.getContext().stream().filter(Consent.class::isInstance).map(Consent.class::cast).findAny().orElseThrow(); for (int i = 0; i < Math.pow(10, exponent) - 1; i++) { Purpose purpose = gdprFactory.createPurpose(); - laf.getPurposes().add(purpose); - laf.getProcessing().forEach(processing -> processing.getPurpose().add(purpose)); + laf.getContext().add(purpose); + laf.getActions().stream().filter(Processing.class::isInstance).forEach(processing -> ((Processing)processing).getPurpose().add(purpose)); consent.getForPurpose().add(purpose); }