// EPF -> LIB;CONF | |
// OpenCert -> ART;PRO;AA | |
pre { | |
'Running ETL'.println(); | |
var conSelection; | |
// We detect the situation in which there are more than one process component | |
var processComponentList=CONF!ProcessComponent.allInstances; | |
if (processComponentList.size()>1){ | |
// We need to inspect the opencert_export category | |
var exportCategory=CONF!CustomCategory.allInstances.selectOne(cc|cc.name="opencert_export"); | |
var processId=exportCategory.categorizedElement.first(); | |
var containerProcessComponent=LIB!ProcessComponent.allInstances.selectOne(pc|pc.process.id=processId); | |
conSelection=new Sequence; | |
conSelection.add(containerProcessComponent.id); | |
// We add the process component of the extended capability patterns | |
for(patterns in containerProcessComponent.process.includesPattern){ | |
conSelection.add(LIB!ProcessComponent.allInstances.selectOne(pc|pc.process.id=patterns).id); | |
} | |
}else{ | |
var methodConfSelectionValue=CONF!MethodElementProperty. | |
allInstances.selectOne(ite : CONF!MethodElementProperty | ite.name.equals("Config_doneLoadCheckPkgs")).value; | |
conSelection=methodConfSelectionValue.split("/"); | |
} | |
} | |
rule ProcessComponent2ProcessModel | |
transform l : LIB!ProcessComponent | |
to p : PRO!ProcessModel,artm:ART!ArtefactModel{ | |
guard :conSelection.includes(l.id) and l.process.isTypeOf(LIB!DeliveryProcess) | |
p.name=l.process.name; | |
p.id=l.process.id; | |
p.description=l.process.briefDescription; | |
artm.name=l.name; | |
artm.id=l.id; | |
artm.description=l.briefDescription; | |
for (task in LIB!TaskDescriptor.allInstances.select(td|td.isPPEInConfiguration())){//l.getTaskDescriptors(l.process.breakdownElement)) { | |
//"Tasks".println(); | |
//task.name.println(); | |
p.ownedActivity.add(task.equivalent()); | |
} | |
for(activity in LIB!Activity.allInstances.select(act|act.isPPEInConfiguration() and act.isTypeOf(LIB!Activity))){//l.getActivities(l.process.breakdownElement)){ | |
//activity.name.println(); | |
p.ownedActivity.add(activity.equivalent()); | |
} | |
for(pattern in LIB!CapabilityPattern.allInstances.select(cp|cp.isCapabilityPatternInConfiguration() and (not cp.isOriginalCapabilityPattern()))){//l.getCapabilityPatterns(l.process.breakdownElement)){ | |
//pattern.name.println(); | |
p.ownedActivity.add(pattern.equivalent()); | |
} | |
for(rd in LIB!RoleDescriptor.allInstances.select(r|r.isPPEInConfiguration())){//l.getRoleDescriptors(l.process.breakdownElement)){ | |
//rd.name.println(); | |
p.ownedParticipant.add(rd.equivalent()); | |
} | |
// Guidelines -> Techniques | |
for(guideline in LIB!Guideline.allInstances.select(gui|gui.isGuidelineInConfiguration())){ | |
p.ownedTechnique.add(guideline.equivalent()); | |
} | |
// Practices -> Techniques | |
for(practice in LIB!Practice.allInstances.select(pra|pra.isPracticeInConfiguration())){ | |
p.ownedTechnique.add(practice.equivalent()); | |
} | |
for(toolMentor in LIB!ToolMentor.allInstances.select(tm|tm.isToolMentorInConfiguration())){ | |
p.ownedParticipant.add(toolMentor.equivalent()); | |
} | |
for(wpd in LIB!Artifact.allInstances){ | |
artm.artefact.add(wpd.equivalent()); | |
} | |
// Organizations can come from TeamProfiles and RoleSets | |
// Only rolesets with roles that are used in the process are added to the process model | |
for(rs in LIB!RoleSet.allInstances.select(ins|ins.isRoleSetInConfiguration())){ | |
p.ownedParticipant.add(rs.equivalent()); | |
} | |
// All TeamProfiles that are in the configuration can be an organization | |
for(tp in l.process.breakdownElement.select(be|be.isTypeOf(LIB!TeamProfile))){//LIB!TeamProfile.allInstances.select(tpins|tpins.isPPEInConfiguration())){ | |
p.ownedParticipant.add(tp.equivalent()); | |
} | |
} | |
rule Practice2Technique | |
transform pra:LIB!Practice | |
to te:PRO!Technique{ | |
guard : pra.isPracticeInConfiguration() | |
te.id=pra.id; | |
te.name=pra.name; | |
te.description=pra.briefDescription; | |
} | |
rule TeamProfile2Organization | |
transform tp:LIB!TeamProfile | |
to org:PRO!Organization{ | |
guard : tp.isPPEInConfiguration() | |
org.id=tp.id; | |
org.name=tp.name; | |
org.description=tp.briefDescription; | |
for(subTeam in tp.subTeam){ | |
org.subOrganization.add(tp.getTeamProfile(subTeam).equivalent()); | |
} | |
} | |
rule RoleSet2Organization | |
transform rs:LIB!RoleSet | |
to org:PRO!Organization{ | |
guard :rs.isRoleSetInConfiguration() | |
//"El nombre del RoleSet es ".concat(rs.name).println(); | |
org.id=rs.id; | |
org.name=rs.name; | |
org.description=rs.briefDescription; | |
} | |
rule Artifact2ArtifactDefinition | |
transform arti:LIB!Artifact | |
to artDef:ART!ArtefactDefinition{ | |
artDef.name=arti.name; | |
artDef.id=arti.id; | |
artDef.description=arti.briefDescription; | |
// obtenemos la referencia a todos los artefactos | |
var wpDescriptorList=LIB!WorkProductDescriptor.allInstances.select(wpd|wpd.workProduct=arti.id and wpd.isPPEInConfiguration()); | |
for(wpi in wpDescriptorList){ | |
//wpi.name.println(); | |
artDef.artefact.add(wpi.equivalent()); | |
} | |
} | |
rule WorkProductDescriptor2Artefact | |
transform wp:LIB!WorkProductDescriptor | |
to art:ART!Artefact{ | |
guard :(wp.isArtifact() and wp.isPPEInConfiguration())//conSelection.contains(wp.getContainerProcessComponent().id)) | |
art.name=wp.name; | |
art.id=wp.id; | |
art.description=wp.briefDescription; | |
} | |
rule Guideline2Technique | |
transform gu:LIB!Guideline | |
to tec:PRO!Technique{ | |
guard :gu.isGuidelineInConfiguration() | |
tec.name=gu.name; | |
tec.id=gu.id; | |
tec.description=gu.briefDescription; | |
} | |
rule RoleDescriptor2Person | |
transform rd:LIB!RoleDescriptor | |
to per:PRO!Person{ | |
guard :rd.isPPEInConfiguration() | |
per.name=rd.name; | |
per.id=rd.id; | |
per.description=rd.briefDescription; | |
for(art in rd.getResponsibleForArtefacts()){ | |
per.ownedArtefact.add(art.equivalent()); | |
} | |
// Membership from organizations | |
// RoleSet -> If the Role associated to the RoleDescriptor is member of the organization | |
if(rd.role<>null){ | |
for(rs in LIB!RoleSet.allInstances.select(roleSet|roleSet.role.includes(rd.role))){ | |
per.organization.add(rs.equivalent()); | |
} | |
} | |
// TeamProfile | |
for(tp in LIB!TeamProfile.allInstances.select(tpIns|tpIns.isPPEInConfiguration() and tpIns.role.includes(rd.id))){ | |
per.organization.add(tp.equivalent()); | |
} | |
} | |
rule RoleSet2Organization | |
transform rs:LIB!RoleSet | |
to org:PRO!Organization{ | |
guard : rs.isRoleSetInConfiguration() | |
org.name=rs.name; | |
org.id=rs.id; | |
org.description=rs.briefDescription; | |
} | |
rule TaskDescriptor2Activity | |
transform l: LIB!TaskDescriptor | |
to act:PRO!Activity{ | |
guard :l.isPPEInConfiguration()//conSelection.contains(l.getContainerProcessComponent().id) | |
act.name=l.name; | |
act.id=l.id; | |
act.description=l.briefDescription; | |
// Participants equivalent to roles | |
for(rd in l.getTaskParticipants()){ | |
act.participant.add(rd.equivalent()); | |
} | |
// Participant equivalent to tools | |
if(l.task<>null){ | |
var task=LIB!Task.allInstances.selectOne(t|t.id=l.task); | |
var toolMentor; | |
for (toolMentorId in task.toolMentor){ | |
act.participant.add(LIB!ToolMentor.allInstances.selectOne(tm|tm.id=toolMentorId).equivalent()); | |
} | |
} | |
// artefacts required | |
// mandatoryInput, externalInput and optionalInput | |
for(id in l.externalInput){ | |
act.requiredArtefact.add(LIB!WorkProductDescriptor.allInstances.selectOne(wpd|wpd.id=id).equivalent()); | |
} | |
for(id in l.optionalInput){ | |
act.requiredArtefact.add(LIB!WorkProductDescriptor.allInstances.selectOne(wpd|wpd.id=id).equivalent()); | |
} | |
for(id in l.mandatoryInput){ | |
act.requiredArtefact.add(LIB!WorkProductDescriptor.allInstances.selectOne(wpd|wpd.id=id).equivalent()); | |
} | |
// artefacts produced | |
for(id in l.output){ | |
act.producedArtefact.add(LIB!WorkProductDescriptor.allInstances.selectOne(wpd|wpd.id=id).equivalent()); | |
} | |
// Techniques associated to this task can come from guidelines associated to the taskdescriptor | |
for(guid in l.guideline){ | |
act.technique.add(l.getGuideline(guid).equivalent()); | |
} | |
// precedent activities -> WorkOrder of the task | |
if(l.predecessor.size()>0){ | |
for(pred in l.predecessor.select(p|p.linkType=LIB!WorkOrderType#finishToStart)){ | |
act.precedingActivity.add(getWorkBreakdownElementById(pred.value).equivalent()); | |
} | |
} | |
} | |
rule TooMentor2Tool | |
transform et:LIB!ToolMentor | |
to ot:PRO!Tool{ | |
guard :et.isToolMentorInConfiguration() | |
var tool=et.getTool(); | |
ot.id=tool.id; | |
ot.name=tool.name; | |
ot.description=tool.briefDescription; | |
} | |
rule CapabilityPattern2Activity | |
transform cp: LIB!CapabilityPattern | |
to act:PRO!Activity{ | |
guard : ((cp.isCapabilityPatternInConfiguration()) and (not cp.isExtendedCapabilityPattern()) | |
and (not cp.isOriginalCapabilityPattern()))//not cp.isContainedInProcessComponent() | |
//cp.getProcessComponentName().println(); | |
//"Se ejecuta original capability pattern".println(); | |
act.name=cp.name; | |
act.id=cp.id; | |
for (task in cp.getTaskDescriptors(cp.breakdownElement)) { | |
act.subActivity.add(task.equivalent()); | |
} | |
for(activity in cp.getActivities(cp.breakdownElement)){ | |
//activity.name.println(); | |
act.subActivity.add(activity.equivalent()); | |
} | |
for (pattern in cp.getCapabilityPatterns(cp.breakdownElement)){ | |
//pattern.name.println(); | |
act.subActivity.add(pattern.equivalent()); | |
} | |
// Techniques associated to this capability pattern can come from guidelines | |
for(guid in cp.guideline){ | |
act.technique.add(l.getGuideline(guid).equivalent()); | |
} | |
// precedent activities -> WorkOrder of the task | |
if(cp.predecessor.size()>0){ | |
for(pred in cp.predecessor.select(p|p.linkType=LIB!WorkOrderType#finishToStart)){ | |
act.precedingActivity.add(getWorkBreakdownElementById(pred.value).equivalent()); | |
} | |
} | |
} | |
rule ExtendedCapabilityPattern2Activity | |
transform cp: LIB!CapabilityPattern | |
to act:PRO!Activity{ | |
guard : ((cp.isCapabilityPatternInConfiguration()) and (cp.isExtendedCapabilityPattern()) | |
and (not cp.isOriginalCapabilityPattern())) | |
// We obtain the original capability pattern. | |
var originalCP=LIB!CapabilityPattern.allInstances.selectOne(ocp|ocp.id=cp.variabilityBasedOnElement); | |
act.name=cp.name; | |
act.id=cp.id; | |
var auxActivity; | |
for (task in originalCP.getTaskDescriptors(originalCP.breakdownElement)) { | |
act.subActivity.add(task.equivalent()); | |
} | |
for(activity in originalCP.getActivities(originalCP.breakdownElement)){ | |
//activity.name.println(); | |
act.subActivity.add(activity.equivalent()); | |
} | |
for (pattern in originalCP.getCapabilityPatterns(originalCP.breakdownElement)){ | |
//pattern.name.println(); | |
act.subActivity.add(pattern.equivalent()); | |
} | |
// Techniques associated to this capability pattern can come from guidelines | |
for(guid in originalCP.guideline){ | |
act.technique.add(cp.getGuideline(guid).equivalent()); | |
} | |
// precedent activities -> WorkOrder of the task | |
if(cp.predecessor.size()>0){ | |
for(pred in cp.predecessor.select(p|p.linkType=LIB!WorkOrderType#finishToStart)){ | |
act.precedingActivity.add(getWorkBreakdownElementById(pred.value).equivalent()); | |
} | |
} | |
} | |
rule Activity2Activity | |
transform a : LIB!Activity | |
to act:PRO!Activity{ | |
guard :conSelection.contains(a.getContainerProcessComponent().id) | |
//"Se aplica Activity2Activity a ".concat(a.name).println(); | |
//l.name.println(); | |
act.name=a.name; | |
act.id=a.id; | |
for (task in a.getTaskDescriptors(a.breakdownElement)) { | |
act.subActivity.add(task.equivalent()); | |
} | |
for(activity in a.getActivities(a.breakdownElement)){ | |
//activity.name.println(); | |
act.subActivity.add(activity.equivalent()); | |
} | |
for (pattern in a.getCapabilityPatterns(a.breakdownElement)){ | |
//pattern.name.println(); | |
act.subActivity.add(pattern.equivalent()); | |
} | |
// Techniques associated to this capability pattern can come from guidelines aand practices | |
// definition | |
for(guid in a.guideline){ | |
act.technique.add(a.getGuideline(guid).equivalent()); | |
} | |
// precedent activities -> WorkOrder of the task | |
if(a.predecessor.size()>0){ | |
for(pred in a.predecessor.select(p|p.linkType=LIB!WorkOrderType#finishToStart)){ | |
act.precedingActivity.add(getWorkBreakdownElementById(pred.value).equivalent()); | |
} | |
} | |
} | |
operation Any getTaskDescriptors(source : Set(LIB!BreadkDownElement)):Set(LIB!TaskDescriptor) { | |
var res = source.select(act|act.isTypeOf(LIB!TaskDescriptor)); | |
//res.size().println(); | |
return res; | |
} | |
operation Any getActivities(source : Set(LIB!BreadkDownElement)):Set(LIB!Activity) { | |
var res = source.select(act|act.isTypeOf(LIB!Activity)); | |
//res.size().println(); | |
return res; | |
} | |
operation Any getCapabilityPatterns(source : Set(LIB!BreadkDownElement)):Set(LIB!CapabilityPattern) { | |
var res = source.select(act|act.isTypeOf(LIB!CapabilityPattern)); | |
//res.size().println(); | |
return res; | |
} | |
operation Any getRoleDescriptors(source : Set(LIB!BreadkDownElement)):Set(LIB!RoleDescriptor){ | |
return source.select(rd|rd.isTypeOf(LIB!RoleDescriptor)); | |
} | |
operation Any getWorkProductDescriptors(source : Set(LIB!BreadkDownElement)):Set(LIB!WorkProductDescriptor){ | |
return source.select(rd|rd.isTypeOf(LIB!WorkProductDescriptor)); | |
} | |
operation LIB!WorkProductDescriptor isArtifact():Boolean{ | |
return LIB!Artifact.allInstances.exists(art|art.id=self.workProduct); | |
} | |
/*operation LIB!CapabilityPattern isContainedInProcessComponent():Boolean{ | |
var res=LIB!ProcessComponent.allInstances.exists(pc|pc.process.id=self.id); | |
//self.name.println(); | |
//res.println(); | |
return res; | |
}*/ | |
operation LIB!Process getProcessComponentName():String{ | |
var pc=LIB!ProcessComponent.allInstances.select(pc|pc.process.id=self.id); | |
if(pc.isEmpty()){ | |
return "No tiene processComponent"; | |
}else{ | |
return pc.first().id; | |
} | |
} | |
// A process element can be contained in a process in two ways | |
// As a part of its list of processElement | |
// As one of the breakdown elements included in its contained process. | |
operation Any getContainerProcessComponent():LIB!ProcessComponent{ | |
var res; | |
// 1. List of processElements of the process components included in the library. | |
res=LIB!ProcessComponent.allInstances.selectOne(pe|pe.processElement.includes(self)); | |
if(res=null){ | |
// Breakdown element | |
if (self.superActivity=null){ | |
res=LIB!ProcessComponent.allInstances.selectOne(pc|pc.process.id=self.id); | |
}else{ | |
res=LIB!BreakdownElement.allInstances.selectOne(su|su.id=self.superActivity).getContainerProcessComponent(); | |
} | |
} | |
return res; | |
} | |
operation Any getRoleDescriptor(id:String):LIB!BreakdownElement{ | |
return LIB!RoleDescriptor.allInstance.selectOne(rd|rd.id=id); | |
} | |
operation LIB!TaskDescriptor getTaskParticipants():Set(LIB!RoleDescriptor){ | |
var res=new Set(LIB!RoleDescriptor); | |
// performedPrimarilyBy; additionallyPerformedBy; assistedBy | |
for(p in self.performedPrimarilyBy){ | |
res.add(LIB!RoleDescriptor.allInstances.selectOne(role|role.id=p)); | |
} | |
for(a in self.additionallyPerformedBy){ | |
res.add(LIB!RoleDescriptor.allInstances.selectOne(role|role.id=a)); | |
} | |
for(asi in self.assistedBy){ | |
res.add(LIB!RoleDescriptor.allInstances.selectOne(role|role.id=asi)); | |
} | |
return res; | |
} | |
operation LIB!RoleDescriptor getResponsibleForArtefacts():Set(LIB!WorkProductDescriptor){ | |
var res=new Set(LIB!WorkProductDescriptor); | |
var wp; | |
for(wp_id in self.responsibleFor){ | |
wp=LIB!WorkProductDescriptor.allInstances.selectOne(ins|ins.id=wp_id); | |
if(wp.isArtifact()){ | |
res.add(wp); | |
} | |
} | |
//res.size().println(); | |
return res; | |
} | |
operation LIB!Process getGuidelines():Set(LIB!Guideline){ | |
var res=new Set(LIB!Guideline); | |
for(gId in self.guideline){ | |
res.add(LIB!Guideline.allInstances.selectOne(guideline|guideline.id=gId)); | |
} | |
return res; | |
} | |
operation Any getGuideline(guidelineId:String):LIB!Guideline{ | |
return LIB!Guideline.allInstances.selectOne(guid|guid.id=guidelineId); | |
} | |
// Esto hay que modificarlo para tener en cuenta que una guideline puede estar contenida en cualquier tipo de elemento que desciende | |
// de breakdownelement | |
// Una guideline está incluida en la configuración si esta enlazada a un elemento que está en la configuración. | |
operation LIB!Guideline isGuidelineInConfiguration():Boolean{ | |
var breakDownElements=LIB!BreakdownElement.allInstances.select(be|be.guideline.includes(self.id)); | |
var res=false; | |
var i=0; | |
while(i<breakDownElements.size() and not res){ | |
if(breakDownElements.at(i).isPPEInConfiguration()){ | |
res=true; | |
} | |
i++; | |
} | |
return res; | |
} | |
operation LIB!ToolMentor isToolMentorInConfiguration():Boolean{ | |
var taskSet=LIB!Task.allInstances.select(t|t.toolMentor.contains(self.id)); | |
var taskSetString=new Set(String); | |
for(task in taskSet){ | |
taskSetString.add(task.id); | |
} | |
// Se seleccionan todas las tareas que tienen referencia al task que incluye el toolMentor | |
var taskDescriptorSet=LIB!TaskDescriptor.allInstances.select(td|taskSetString.includes(td.task)); | |
var res=false; | |
var i=0; | |
var pc; | |
// Si alguna de estos task descriptors está en la configuración -> el ToolMentor está en la configuración | |
while(i<taskDescriptorSet.size() and not res){ | |
if(taskDescriptorSet.at(i).isPPEInConfiguration()){ | |
res=true; | |
} | |
i++; | |
} | |
return res; | |
} | |
operation LIB!TaskDescriptor getTools():Set(LIB!Tool){ | |
var res=new Set(LIB!Tool); | |
var candTool; | |
// 1. Encontramos la tarea asociada | |
var task=LIB!Task.allInstances.selectOne(t|t.id=self.task); | |
// 2. Encontramos todos los tools asociados a los tool mentors de la tarea | |
if(task<>null){ | |
for(tool in LIB!Tool.allInstances){ | |
for(toolMentor in task.toolMentor){ | |
if(tool.toolMentor.includes(toolMentor)){ | |
if(not res.incudes(tool)){ | |
res.add(tool); | |
} | |
} | |
} | |
} | |
} | |
return res; | |
} | |
operation LIB!ToolMentor getTool():LIB!Tool{ | |
return LIB!Tool.allInstances.selectOne(tool|tool.toolMentor.contains(self.id)); | |
} | |
// This method returns true if the process element is part of the configuration that is passed as second model | |
operation Any isPPEInConfiguration():Boolean{ | |
//self.name.println(); | |
var pc=self.getContainerProcessComponent(); | |
return conSelection.contains(pc.id); | |
} | |
// This method determine if a RoleSet is involved in the process given in the | |
// configuration. | |
// roleIdList is the list of the id of the Role used in the process | |
operation LIB!RoleSet isRoleSetInConfiguration():Boolean{ | |
var roleList=new Set(String); | |
roleList=self.getRolesFromConfiguration(); | |
return self.role.exists(roleId|roleList.includes(roleId)); | |
} | |
// A capability pattern can be part of the configuration in two cases | |
// 1. It is contained in a process component that is the process component selected in the configuration. | |
// 2. It is included in a process or other capability pattern which is part of the configuration. | |
operation LIB!CapabilityPattern isCapabilityPatternInConfiguration():Boolean{ | |
// The process component associated to the capability pattern is the process component of the configuration | |
var res=false; | |
if (LIB!ProcessComponent.allInstances.exists(pc|pc.process.id=self.id)){ | |
if(conSelection.contains(LIB!ProcessComponent.allInstances.selectOne(pc|pc.process.id=self.id).id)){ | |
res=true; | |
} | |
}else{ | |
res=self.isPPEInConfiguration(); | |
} | |
return res; | |
} | |
// This operation obtain all the identifications fo the role defintions associated to the roledescriptors in the process passed in the configuration | |
operation Any getRolesFromConfiguration():Set(String){ | |
var roleIdList=new Set(String); | |
for(rd in LIB!RoleDescriptor.allInstances.select(r|r.isPPEInConfiguration())){//l.getRoleDescriptors(l.process.breakdownElement)){ | |
if(rd.role<>null){ | |
roleIdList.add(rd.role); | |
} | |
} | |
return roleIdList; | |
} | |
// Get the TeamProfile element with the id passed as argument. | |
operation LIB!TeamProfile getTeamProfile(subTeamId:String):LIB!TeamProfile{ | |
return LIB!TeamProfile.allInstances.selectOne(tp|tp.id=subTeamId); | |
} | |
// A practice is in a configuration if one of the elements of its reference section (for content or activities) is in the configuration | |
operation LIB!Practice isPracticeInConfiguration():Boolean{ | |
// First checking the activities | |
var res=false; | |
var activityReferenceList=self.activityReference.getListActivitiesById(); | |
if(activityReferenceList.exists(ca|ca.isPPEInConfiguration())){ | |
res=true; | |
// Checking method content elements and practices -> contentReference (Guidance is considered content element) | |
}else{ | |
var i=0; | |
var descriptorList=getConfigurationDescriptors(); | |
// Checking Descriptors -> Descriptor can be a WorkProductDescriptor or a RoleDescriptor | |
while((not res) and (i<descriptorList.size())){ | |
if(descriptorList.at(i).isTypeOf(LIB!WorkProductDescriptor)){ | |
if(descriptorList.at(i).workProduct<>null){ | |
res=self.contentReference.includes(descriptorList.at(i).workProduct); | |
} | |
}else{ | |
if(descriptorList.at(i).role<>null){ | |
res=self.contentReference.includes(descriptorList.at(i).role); | |
} | |
} | |
i++; | |
} | |
// Checking the taskdescriptors | |
if(not res){ | |
var taskDescriptorList=getConfigurationTaskDescriptors(); | |
i=0; | |
while((not res) and (i<taskDescriptorList.size())){ | |
if(taskDescriptorList.at(i).task<>null){ | |
res=self.contentReference.includes(taskDescriptorList.at(i).task); | |
} | |
i++; | |
} | |
} | |
// Checking the guidelines, which is the only type of guidance of relevance for the process model. | |
// Practices are of relevance too but they cannot be attached to a process. | |
if(not res){ | |
var configurationGuidelineList=getGuidelinesInConfiguration(); | |
i=0; | |
while((not res) and (i<configurationGuidelineList.size())){ | |
res=self.contentReference.includes(configurationGuidelineList.at(i).id); | |
i++; | |
} | |
} | |
} | |
return res; | |
} | |
// Get the content element with the id passed in self | |
operation String getContentElementById():LIB!ContentElement{ | |
return LIB!ContentElement.allInstances.selectOne(ce|ce.id=self); | |
} | |
// Get a list of content elements whose id is included in the list passed in self | |
operation Set(String) getListContentElementById():Set(LIB!ContentElement){ | |
var res=new Set(LIB!ContentElement); | |
for(ce in LIB!ContentElement.allInstances){ | |
if(self.includes(ce.id)){ | |
res.add(ce); | |
} | |
} | |
return res; | |
} | |
// Get a list of activities whose id is included in the list passed in Self | |
operation Sequence(String) getListActivitiesById():Set(LIB!Activity){ | |
var res=new Set(LIB!Activity); | |
for(act in LIB!Activity.allInstances){ | |
if(self.includes(act.id)){ | |
res.add(act); | |
} | |
} | |
return res; | |
} | |
operation getConfigurationDescriptors():Sequence(LIB!Descriptor){ | |
return LIB!Descriptor.allInstances.select(des|des.isPPEInConfiguration()); | |
} | |
operation getConfigurationTaskDescriptors():Sequence(LIB!TaskDescriptor){ | |
return LIB!TaskDescriptor.allInstances.select(td|td.isPPEInConfiguration()); | |
} | |
operation getGuidelinesInConfiguration():Sequence(LIB!Guideline){ | |
return LIB!Guideline.allInstances.select(gui|gui.isGuidelineInConfiguration()); | |
} | |
operation LIB!WorkOrder isWorkOrderInConfiguration():Boolean{ | |
var res=false; | |
var workBreakdownInConf=LIB!WorkBreakdownElement.allInstances.select(wbe|wbe.isPPEInConfiguration); | |
var i=0; | |
while((not res) and (i<workBreakdownInConf.size())){ | |
if(workBreakdownInConf.at(i).predecessor.includes(self)){ | |
res=true; | |
} | |
i++; | |
} | |
return res; | |
} | |
operation getWorkBreakdownElementById(id : String):LIB!WorkBreakdownElement{ | |
return LIB!WorkBreakdownElement.allInstances.selectOne(wbe|wbe.id=id); | |
} | |
operation LIB!CapabilityPattern isExtendedCapabilityPattern():Boolean{ | |
return self.variabilityType<>LIB!VariabilityType#na and self.variabilityType<>LIB!VariabilityType#contributes | |
and self.variabilityType<>LIB!VariabilityType#replaces and self.variabilityType<>LIB!VariabilityType#localContribution | |
and self.variabilityType<>LIB!VariabilityType#localReplacement and self.variabilityType<>LIB!VariabilityType#extendsReplaces; | |
} | |
operation LIB!CapabilityPattern isOriginalCapabilityPattern():Boolean{ | |
var res=false; | |
var processComponent=LIB!ProcessComponent.allInstances.selectOne(pc|pc.process.id=self.id); | |
if(processComponent<>null){ | |
res=true; | |
} | |
return res; | |
} | |
post{ | |
"End of transformation".println(); | |
} | |