@Override
public boolean isAllowed(final String key, final Map<String, Serializable> context)
throws SExecutionException {
long userId = getLoggedUserId(sessionAccessor, sessionService);
Long processInstanceId = getLongParameter(context, URLAdapterConstants.ID_QUERY_PARAM);
if (processInstanceId == null) {
throw new IllegalArgumentException(
"Parameter 'id' is mandatory to execute Page Authorization rule 'IsProcessInitiatorRule'");
}
// is user assigned or has pending tasks on this process instance:
final QueryOptions queryOptions =
new QueryOptions(
0,
1,
Collections.EMPTY_LIST,
Arrays.asList(
new FilterOption(SHumanTaskInstance.class, "logicalGroup2", processInstanceId)),
null);
try {
return activityInstanceService.getNumberOfPendingOrAssignedTasks(userId, queryOptions) > 0;
} catch (SBonitaReadException e) {
throw new SExecutionException(e);
}
}
private void deleteFlowNodeInstances(
final long processInstanceId, final SProcessDefinition processDefinition)
throws SFlowNodeReadException, SProcessInstanceModificationException {
List<SFlowNodeInstance> activityInstances;
do {
activityInstances = activityService.getFlowNodeInstances(processInstanceId, 0, BATCH_SIZE);
for (final SFlowNodeInstance activityInstance : activityInstances) {
deleteFlowNodeInstance(activityInstance, processDefinition);
}
} while (!activityInstances.isEmpty());
}
@Override
public void deleteFlowNodeInstance(
final SFlowNodeInstance flowNodeInstance, final SProcessDefinition processDefinition)
throws SProcessInstanceModificationException {
try {
deleteFlowNodeInstanceElements(flowNodeInstance, processDefinition);
activityService.deleteFlowNodeInstance(flowNodeInstance);
} catch (final SBonitaException e) {
throw new SProcessInstanceModificationException(e);
}
}
private void deleteFlowNodeInstanceElements(
final SFlowNodeInstance flowNodeInstance, final SProcessDefinition processDefinition)
throws SBonitaException {
if (flowNodeInstance.getType().equals(SFlowNodeType.INTERMEDIATE_CATCH_EVENT)) {
bpmEventInstanceService.deleteWaitingEvents(flowNodeInstance);
}
if (flowNodeInstance instanceof SEventInstance) {
bpmEventInstanceService.deleteEventTriggerInstances(flowNodeInstance.getId());
} else if (flowNodeInstance instanceof SActivityInstance) {
deleteDataInstancesIfNecessary(flowNodeInstance, processDefinition);
deleteConnectorInstancesIfNecessary(flowNodeInstance, processDefinition);
if (SFlowNodeType.USER_TASK.equals(flowNodeInstance.getType())
|| SFlowNodeType.MANUAL_TASK.equals(flowNodeInstance.getType())) {
activityService.deleteHiddenTasksForActivity(flowNodeInstance.getId());
try {
activityService.deletePendingMappings(flowNodeInstance.getId());
} catch (final SActivityModificationException e) {
throw new SFlowNodeReadException(e);
}
} else if (SFlowNodeType.CALL_ACTIVITY.equals(flowNodeInstance.getType())
|| SFlowNodeType.SUB_PROCESS.equals(flowNodeInstance.getType())) {
// in the case of a call activity or subprocess activity delete the child process instance
try {
deleteProcessInstance(getChildOfActivity(flowNodeInstance.getId()));
} catch (final SProcessInstanceNotFoundException e) {
final StringBuilder stb = new StringBuilder();
stb.append("Can't find the process instance called by the activity [id: ");
stb.append(flowNodeInstance.getId());
stb.append(", name: ");
stb.append(flowNodeInstance.getName());
stb.append("]. This process may be already finished");
// if the child process is not found, it's because it has already finished and archived or
// it was not created
if (logger.isLoggable(getClass(), TechnicalLogSeverity.DEBUG)) {
logger.log(getClass(), TechnicalLogSeverity.DEBUG, stb.toString());
logger.log(getClass(), TechnicalLogSeverity.DEBUG, e);
}
}
}
}
}
private void deleteArchivedFlowNodeInstances(final long processInstanceId)
throws SFlowNodeReadException, SBonitaSearchException, SConnectorInstanceDeletionException,
SFlowNodeDeletionException, SDataInstanceException {
List<SAFlowNodeInstance> activityInstances;
do {
activityInstances =
activityService.getArchivedFlowNodeInstances(processInstanceId, 0, BATCH_SIZE);
final HashSet<Long> orgActivityIds = new HashSet<Long>();
final ArrayList<SAFlowNodeInstance> orgActivities = new ArrayList<SAFlowNodeInstance>();
for (final SAFlowNodeInstance activityInstance : activityInstances) {
if (!orgActivityIds.contains(activityInstance.getSourceObjectId())) {
orgActivityIds.add(activityInstance.getSourceObjectId());
orgActivities.add(activityInstance);
}
activityService.deleteArchivedFlowNodeInstance(activityInstance);
}
for (final SAFlowNodeInstance orgActivity : orgActivities) {
deleteArchivedFlowNodeInstanceElements(orgActivity);
}
} while (!activityInstances.isEmpty());
}
@Override
public void execute() throws SBonitaException {
final SActivityInstance activityInstance =
activityInstanceService.getActivityInstance(userTaskId);
if (userId == 0 && SFlowNodeType.MANUAL_TASK.equals(activityInstance.getType())) {
throw new SUnreleasableTaskException(
"The activity with id "
+ activityInstance.getId()
+ " can't be assigned because it is a manual sub task");
}
activityInstanceService.assignHumanTask(userTaskId, userId);
if (userId > 0) {
activityInstanceService.deleteHiddenTasksForActivity(activityInstance.getId());
final SUser user = identityService.getUser(userId);
if (commentService.isCommentEnabled(SystemCommentType.STATE_CHANGE)) {
commentService.addSystemComment(
activityInstance.getRootContainerId(),
"The task \""
+ activityInstance.getDisplayName()
+ "\" is now assigned to "
+ user.getUserName());
}
}
}
@Test
public void shouldBeAllowedIAnArchivedTaskIsAssignedToGivenUserWithPagination() throws Exception {
Map<String, Serializable> context = buildContext(541L, null);
final SAUserTaskInstance notMatchingArchivedTask = mock(SAUserTaskInstance.class);
final SAUserTaskInstance userTaskInstance = mock(SAUserTaskInstance.class);
doReturn(loggedUserId).when(userTaskInstance).getAssigneeId();
when(activityInstanceService.searchArchivedTasks(any(QueryOptions.class)))
.thenReturn(
Arrays.<SAHumanTaskInstance>asList(notMatchingArchivedTask),
Arrays.<SAHumanTaskInstance>asList(userTaskInstance));
final boolean allowed = rule.isAllowed("someKey", context);
assertThat(allowed).isTrue();
}
protected void checkIfCallerIsNotActive(final long callerId)
throws SFlowNodeReadException, SProcessInstanceHierarchicalDeletionException {
if (callerId > 0) {
try {
final SFlowNodeInstance flowNodeInstance = activityService.getFlowNodeInstance(callerId);
throw new SProcessInstanceHierarchicalDeletionException(
"Unable to delete the process instance because the parent is still active: activity "
+ flowNodeInstance.getName()
+ " with id "
+ flowNodeInstance.getId(),
flowNodeInstance.getRootProcessInstanceId());
} catch (final SFlowNodeNotFoundException e) {
// ok the activity that called this process do not exists anymore
}
}
}
private void deleteArchivedFlowNodeInstanceElements(final SAFlowNodeInstance activityInstance)
throws SFlowNodeReadException, SBonitaSearchException, SConnectorInstanceDeletionException,
SDataInstanceException {
if (activityInstance instanceof SAActivityInstance) {
dataInstanceService.deleteLocalArchivedDataInstances(
activityInstance.getSourceObjectId(), DataInstanceContainer.ACTIVITY_INSTANCE.toString());
connectorInstanceService.deleteArchivedConnectorInstances(
activityInstance.getSourceObjectId(), SConnectorInstance.FLOWNODE_TYPE);
if (SFlowNodeType.USER_TASK.equals(activityInstance.getType())
|| SFlowNodeType.MANUAL_TASK.equals(activityInstance.getType())) {
try {
activityService.deleteArchivedPendingMappings(activityInstance.getSourceObjectId());
} catch (final SActivityModificationException e) {
throw new SFlowNodeReadException(e);
}
}
}
}
@Override
public void execute() throws SBonitaException {
isHidden = activityInstanceService.isTaskHidden(userId, activityInstanceId);
}
@Override
public List<SActivityInstance> executeSearch(final QueryOptions searchOptions)
throws SBonitaSearchException {
return activityInstanceService.searchActivityInstances(getEntityClass(), searchOptions);
}
@Override
public long executeCount(final QueryOptions searchOptions) throws SBonitaSearchException {
return activityInstanceService.getNumberOfActivityInstances(getEntityClass(), searchOptions);
}
@Override
public void execute() throws SBonitaException {
humanTaskInstance = activityInstanceService.getHumanTaskInstance(activityInstanceId);
}