use of org.activiti.engine.repository.ProcessDefinition in project Activiti by Activiti.
the class DeploymentManager method removeDeployment.
public void removeDeployment(String deploymentId, boolean cascade) {
DeploymentEntityManager deploymentEntityManager = Context.getCommandContext().getDeploymentEntityManager();
DeploymentEntity deployment = deploymentEntityManager.findDeploymentById(deploymentId);
if (deployment == null)
throw new ActivitiObjectNotFoundException("Could not find a deployment with id '" + deploymentId + "'.", DeploymentEntity.class);
// Remove any process definition from the cache
List<ProcessDefinition> processDefinitions = new ProcessDefinitionQueryImpl(Context.getCommandContext()).deploymentId(deploymentId).list();
ActivitiEventDispatcher eventDispatcher = Context.getProcessEngineConfiguration().getEventDispatcher();
for (ProcessDefinition processDefinition : processDefinitions) {
// Since all process definitions are deleted by a single query, we should dispatch the events in this loop
if (eventDispatcher.isEnabled()) {
eventDispatcher.dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, processDefinition));
}
}
// Delete data
deploymentEntityManager.deleteDeployment(deploymentId, cascade);
// Since we use a delete by query, delete-events are not automatically dispatched
if (eventDispatcher.isEnabled()) {
eventDispatcher.dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, deployment));
}
for (ProcessDefinition processDefinition : processDefinitions) {
processDefinitionCache.remove(processDefinition.getId());
}
}
use of org.activiti.engine.repository.ProcessDefinition in project Activiti by Activiti.
the class TimerStartEventJobHandler method startProcessDefinitionByKey.
protected void startProcessDefinitionByKey(JobEntity job, String configuration, DeploymentManager deploymentManager, CommandContext commandContext) {
// it says getActivityId, but < 5.21, this would have the process definition key stored
String processDefinitionKey = TimerEventHandler.getActivityIdFromConfiguration(configuration);
ProcessDefinition processDefinition = null;
if (job.getTenantId() == null || ProcessEngineConfiguration.NO_TENANT_ID.equals(job.getTenantId())) {
processDefinition = deploymentManager.findDeployedLatestProcessDefinitionByKey(processDefinitionKey);
} else {
processDefinition = deploymentManager.findDeployedLatestProcessDefinitionByKeyAndTenantId(processDefinitionKey, job.getTenantId());
}
if (processDefinition == null) {
throw new ActivitiException("Could not find process definition needed for timer start event");
}
try {
if (!deploymentManager.isProcessDefinitionSuspended(processDefinition.getId())) {
dispatchTimerFiredEvent(job, commandContext);
new StartProcessInstanceCmd<ProcessInstance>(processDefinitionKey, null, null, null, job.getTenantId()).execute(commandContext);
} else {
log.debug("Ignoring timer of suspended process definition {}", processDefinition.getId());
}
} catch (RuntimeException e) {
log.error("exception during timer execution", e);
throw e;
} catch (Exception e) {
log.error("exception during timer execution", e);
throw new ActivitiException("exception during timer execution: " + e.getMessage(), e);
}
}
use of org.activiti.engine.repository.ProcessDefinition in project Activiti by Activiti.
the class StartAuthorizationTest method testProcessDefinitionList.
// this test checks the list without user constraint
@Deployment
public void testProcessDefinitionList() throws Exception {
setUpUsersAndGroups();
try {
// Process 1 has no potential starters
ProcessDefinition latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process1").singleResult();
List<User> authorizedUsers = identityService.createUserQuery().potentialStarter(latestProcessDef.getId()).list();
assertEquals(0, authorizedUsers.size());
// user1 and user2 are potential Startes of Process2
latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process2").singleResult();
authorizedUsers = identityService.createUserQuery().potentialStarter(latestProcessDef.getId()).orderByUserId().asc().list();
assertEquals(2, authorizedUsers.size());
assertEquals("user1", authorizedUsers.get(0).getId());
assertEquals("user2", authorizedUsers.get(1).getId());
// Process 2 has no potential starter groups
latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process2").singleResult();
List<Group> authorizedGroups = identityService.createGroupQuery().potentialStarter(latestProcessDef.getId()).list();
assertEquals(0, authorizedGroups.size());
// Process 3 has 3 groups as authorized starter groups
latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process4").singleResult();
authorizedGroups = identityService.createGroupQuery().potentialStarter(latestProcessDef.getId()).orderByGroupId().asc().list();
assertEquals(3, authorizedGroups.size());
assertEquals("group1", authorizedGroups.get(0).getId());
assertEquals("group2", authorizedGroups.get(1).getId());
assertEquals("group3", authorizedGroups.get(2).getId());
// do not mention user, all processes should be selected
List<ProcessDefinition> processDefinitions = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionName().asc().list();
assertEquals(4, processDefinitions.size());
assertEquals("process1", processDefinitions.get(0).getKey());
assertEquals("process2", processDefinitions.get(1).getKey());
assertEquals("process3", processDefinitions.get(2).getKey());
assertEquals("process4", processDefinitions.get(3).getKey());
// check user1, process3 has "user1" as only authorized starter, and
// process2 has two authorized starters, of which one is "user1"
processDefinitions = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionName().asc().startableByUser("user1").list();
assertEquals(2, processDefinitions.size());
assertEquals("process2", processDefinitions.get(0).getKey());
assertEquals("process3", processDefinitions.get(1).getKey());
// "user2" can only start process2
processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("user2").list();
assertEquals(1, processDefinitions.size());
assertEquals("process2", processDefinitions.get(0).getKey());
// no process could be started with "user4"
processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("user4").list();
assertEquals(0, processDefinitions.size());
// "userInGroup3" is in "group3" and can start only process4 via group authorization
processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("userInGroup3").list();
assertEquals(1, processDefinitions.size());
assertEquals("process4", processDefinitions.get(0).getKey());
// "userInGroup2" can start process4, via both user and group authorizations
// but we have to be sure that process4 appears only once
processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("userInGroup2").list();
assertEquals(1, processDefinitions.size());
assertEquals("process4", processDefinitions.get(0).getKey());
} finally {
tearDownUsersAndGroups();
}
}
use of org.activiti.engine.repository.ProcessDefinition in project Activiti by Activiti.
the class StartAuthorizationTest method testAddAndRemoveIdentityLinks.
@Deployment
public void testAddAndRemoveIdentityLinks() throws Exception {
setUpUsersAndGroups();
try {
ProcessDefinition latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("potentialStarterNoDefinition").singleResult();
assertNotNull(latestProcessDef);
List<IdentityLink> links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(0, links.size());
repositoryService.addCandidateStarterGroup(latestProcessDef.getId(), "group1");
links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(1, links.size());
assertEquals("group1", links.get(0).getGroupId());
repositoryService.addCandidateStarterUser(latestProcessDef.getId(), "user1");
links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(2, links.size());
assertEquals(true, containsUserOrGroup(null, "group1", links));
assertEquals(true, containsUserOrGroup("user1", null, links));
repositoryService.deleteCandidateStarterGroup(latestProcessDef.getId(), "nonexisting");
links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(2, links.size());
repositoryService.deleteCandidateStarterGroup(latestProcessDef.getId(), "group1");
links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(1, links.size());
assertEquals("user1", links.get(0).getUserId());
repositoryService.deleteCandidateStarterUser(latestProcessDef.getId(), "user1");
links = repositoryService.getIdentityLinksForProcessDefinition(latestProcessDef.getId());
assertEquals(0, links.size());
} finally {
tearDownUsersAndGroups();
}
}
use of org.activiti.engine.repository.ProcessDefinition in project Activiti by Activiti.
the class ProcessValidationExecutedAfterDeployTest method testGetStartFormData.
public void testGetStartFormData() {
disableValidation();
repositoryService.createDeployment().addClasspathResource("org/activiti/engine/test/regression/ProcessValidationExecutedAfterDeployTest.bpmn20.xml").deploy();
enableValidation();
clearDeploymentCache();
ProcessDefinition definition = getLatestProcessDefinitionVersionByKey("testProcess1");
if (definition == null) {
fail("Error occurred in fetching process model.");
}
try {
formService.getStartFormData(definition.getId());
assertTrue(true);
} catch (ActivitiException e) {
fail("Error occurred in fetching start form data:");
}
for (org.activiti.engine.repository.Deployment deployment : repositoryService.createDeploymentQuery().list()) {
repositoryService.deleteDeployment(deployment.getId());
}
}
Aggregations