org.activiti.engine.ActivitiIllegalArgumentException Java Examples

@Override
public HistoricTaskInstanceQueryImpl processInstanceIdIn(List<String> processInstanceIds) {
  if (processInstanceIds == null) {
    throw new ActivitiIllegalArgumentException("Process instance id list is null");
  }
  if (processInstanceIds.isEmpty()) {
    throw new ActivitiIllegalArgumentException("Process instance id list is empty");
  }
  for (String processInstanceId : processInstanceIds) {
    if (processInstanceId == null) {
      throw new ActivitiIllegalArgumentException("None of the given process instance ids can be null");
    }
  }

  if (inOrStatement) {
    this.currentOrQueryObject.processInstanceIds = processInstanceIds;
  } else {
    this.processInstanceIds = processInstanceIds;
  }
  return this;
}
 

public VariableInstance execute(CommandContext commandContext) {
  if (executionId == null) {
    throw new ActivitiIllegalArgumentException("executionId is null");
  }
  if (variableName == null) {
    throw new ActivitiIllegalArgumentException("variableName is null");
  }
  
  ExecutionEntity execution = commandContext.getExecutionEntityManager().findExecutionById(executionId);

  if (execution == null) {
    throw new ActivitiObjectNotFoundException("execution " + executionId + " doesn't exist", Execution.class);
  }
  
  VariableInstance variableEntity = null;
  if (isLocal) {
    variableEntity = execution.getVariableInstanceLocal(variableName, false);
  } else {
    variableEntity = execution.getVariableInstance(variableName, false);
  }
  
  return variableEntity;
}
 

@Override
public JobEntity moveDeadLetterJobToExecutableJob(DeadLetterJobEntity deadLetterJobEntity, int retries) {
  if (deadLetterJobEntity == null) {
    throw new ActivitiIllegalArgumentException("Null job provided");
  }
  
  JobEntity executableJob = createExecutableJobFromOtherJob(deadLetterJobEntity);
  executableJob.setRetries(retries);
  boolean insertSuccesful = processEngineConfiguration.getJobEntityManager().insertJobEntity(executableJob);
  if (insertSuccesful) {
    processEngineConfiguration.getDeadLetterJobEntityManager().delete(deadLetterJobEntity);
    triggerExecutorIfNeeded(executableJob);
    return executableJob;
  }
  return null;
}
 

@Override
public HistoricTaskInstanceQuery processCategoryNotIn(List<String> processCategoryNotInList) {
  if (processCategoryNotInList == null) {
    throw new ActivitiIllegalArgumentException("Process category list is null");
  }
  if (processCategoryNotInList.isEmpty()) {
    throw new ActivitiIllegalArgumentException("Process category list is empty");
  }
  for (String processCategory : processCategoryNotInList) {
    if (processCategory == null) {
      throw new ActivitiIllegalArgumentException("None of the given process categories can be null");
    }
  }

  if(inOrStatement) {
    currentOrQueryObject.processCategoryNotInList = processCategoryNotInList;
  } else {
    this.processCategoryNotInList = processCategoryNotInList;
  }
  return this;
}
 

public JobEntity execute(CommandContext commandContext) {

    if (jobId == null) {
      throw new ActivitiIllegalArgumentException("jobId and job is null");
    }

    TimerJobEntity timerJob = commandContext.getTimerJobEntityManager().findById(jobId);

    if (timerJob == null) {
      throw new JobNotFoundException(jobId);
    }

    if (log.isDebugEnabled()) {
      log.debug("Executing timer job {}", timerJob.getId());
    }
    
    return commandContext.getJobManager().moveTimerJobToExecutableJob(timerJob);
  }
 

public void testQueryByInvalidDescriptionLikeOr() {
  TaskQuery query = taskService.createTaskQuery()
      .or()
      .taskId("invalid")
      .taskDescriptionLike("invalid");
  assertNull(query.singleResult());
  assertEquals(0, query.list().size());
  assertEquals(0, query.count());
  
  try {
    taskService.createTaskQuery()
      .or()
      .taskId("invalid")
      .taskDescriptionLike(null).list();
    fail();
  } catch (ActivitiIllegalArgumentException e) {
    
  }
}
 

public Void execute(CommandContext commandContext) {
  if (group == null) {
    throw new ActivitiIllegalArgumentException("group is null");
  }

  if (commandContext.getGroupEntityManager().isNewGroup(group)) {
    if (group instanceof GroupEntity) {
      commandContext.getGroupEntityManager().insert((GroupEntity) group);
    } else {
      commandContext.getDbSqlSession().insert((Entity) group);
    }
  } else {
    if (group instanceof GroupEntity) {
      commandContext.getGroupEntityManager().update((GroupEntity) group);
    } else {
      commandContext.getDbSqlSession().update((Entity) group);
    }
    
  }
  return null;
}
 

public void testQueryByInvalidNameOr() {
  TaskQuery query = taskService.createTaskQuery()
      .or()
      .taskId("invalid")
      .taskName("invalid");
  assertNull(query.singleResult());
  assertEquals(0, query.list().size());
  assertEquals(0, query.count());
  
  try {
    taskService.createTaskQuery()
      .or()
      .taskId("invalid")
      .taskName(null).singleResult();
    fail("expected exception");
  } catch (ActivitiIllegalArgumentException e) {
    // OK
  }
}
 

public ProcessDefinition findDeployedProcessDefinitionById(String processDefinitionId) {
  if (processDefinitionId == null) {
    throw new ActivitiIllegalArgumentException("Invalid process definition id : null");
  }

  // first try the cache
  ProcessDefinitionCacheEntry cacheEntry = processDefinitionCache.get(processDefinitionId);
  ProcessDefinition processDefinition = cacheEntry != null ? cacheEntry.getProcessDefinition() : null;

  if (processDefinition == null) {
    processDefinition = processDefinitionEntityManager.findById(processDefinitionId);
    if (processDefinition == null) {
      throw new ActivitiObjectNotFoundException("no deployed process definition found with id '" + processDefinitionId + "'", ProcessDefinition.class);
    }
    processDefinition = resolveProcessDefinition(processDefinition).getProcessDefinition();
  }
  return processDefinition;
}
 

public static Date getDate(Map<String, String> requestParams, String name) {
  Date value = null;
  if (requestParams.get(name) != null) {

    String input = requestParams.get(name).trim();

    // this is zero time so we need to add that TZ indicator for
    if (input.endsWith("Z")) {
      input = input.substring(0, input.length() - 1) + "GMT-00:00";
    } else {
      int inset = 6;

      String s0 = input.substring(0, input.length() - inset);
      String s1 = input.substring(input.length() - inset, input.length());

      input = s0 + "GMT" + s1;
    }

    try {
      value = longDateFormat.parse(input);
    } catch (Exception e) {
      throw new ActivitiIllegalArgumentException("Failed to parse date " + input);
    }
  }
  return value;
}
 

public void testQueryByInvalidId() {
  GroupQuery query = identityService.createGroupQuery().groupId("invalid");
  verifyQueryResults(query, 0);
  
  try {
    identityService.createGroupQuery().groupId(null).list();
    fail();
  } catch (ActivitiIllegalArgumentException e) {}
}
 

public static boolean shouldSkipFlowElement(CommandContext commandContext, DelegateExecution execution, String skipExpressionString) {
  Expression skipExpression = commandContext.getProcessEngineConfiguration().getExpressionManager().createExpression(skipExpressionString);
  Object value = skipExpression.getValue(execution);

  if (value instanceof Boolean) {
    return ((Boolean) value).booleanValue();

  } else {
    throw new ActivitiIllegalArgumentException("Skip expression does not resolve to a boolean: " + skipExpression.getExpressionText());
  }
}
 

public void testQueryByProcessInstanceIdsNull() {
  try {
    runtimeService.createProcessInstanceQuery().processInstanceIds(null);
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException re) {
    assertTextPresent("Set of process instance ids is null", re.getMessage());
  }
}
 

public void testAddCandidateGroupNullGroupId() {
  try {
    taskService.addCandidateGroup("taskId", null);
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException ae) {
    assertTextPresent("identityId is null", ae.getMessage());
  }
}
 

public ExecutionQuery processInstanceBusinessKey(String businessKey) {
  if (businessKey == null) {
    throw new ActivitiIllegalArgumentException("Business key is null");
  }
  this.businessKey = businessKey;
  return this;
}
 

public JobQuery jobTenantId(String tenantId) {
  if (tenantId == null) {
    throw new ActivitiIllegalArgumentException("job is null");
  }
  this.tenantId = tenantId;
  return this;
}
 

public void testQueryByNullCandidateUserOr() {
  try {
    taskService.createTaskQuery()
      .or()
      .taskId("invalid")
      .taskCandidateUser(null).list();
    fail();
  } catch(ActivitiIllegalArgumentException e) {}
}
 

public void setVariableLocal(String executionId, String variableName, Object value) {
  if (variableName == null) {
    throw new ActivitiIllegalArgumentException("variableName is null");
  }
  Map<String, Object> variables = new HashMap<String, Object>();
  variables.put(variableName, value);
  commandExecutor.execute(new SetExecutionVariablesCmd(executionId, variables, true));
}
 

public DeploymentQueryImpl deploymentNameLike(String nameLike) {
  if (nameLike == null) {
    throw new ActivitiIllegalArgumentException("deploymentNameLike is null");
  }
  this.nameLike = nameLike;
  return this;
}
 

public TimerJobQueryImpl duedateLowerThan(Date date) {
  if (date == null) {
    throw new ActivitiIllegalArgumentException("Provided date is null");
  }
  this.duedateLowerThan = date;
  return this;
}
 

public void testFindDeploymentResourceNamesNullDeploymentId() {
  try {
    repositoryService.getDeploymentResourceNames(null);
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException ae) {
    assertTextPresent("deploymentId is null", ae.getMessage());
  }
}
 

public void testAddCandidateGroupNullTaskId() {
  try {
    taskService.addCandidateGroup(null, "groupId");
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException ae) {
    assertTextPresent("taskId is null", ae.getMessage());
  }
}
 

public GroupQuery groupMember(String userId) {
  if (userId == null) {
    throw new ActivitiIllegalArgumentException("Provided userId is null");
  }
  this.userId = userId;
  return this;
}
 

public void testInvalidOnlyTimersUsage() {
  try {
    managementService.createJobQuery().timers().messages().list();
    fail();
  } catch (ActivitiIllegalArgumentException e) {
    assertTextPresent("Cannot combine onlyTimers() with onlyMessages() in the same query", e.getMessage());
  }
}
 

public void testQueryByInvalidDeploymentId() {
  ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery().deploymentId("invalid");
  verifyQueryResults(query, 0);
  
  try {
    repositoryService.createProcessDefinitionQuery().deploymentId(null);
    fail();
  } catch (ActivitiIllegalArgumentException e) {}
}
 

public void testFindActiveActivityIdsNullExecututionId() {
  try {
    runtimeService.getActiveActivityIds(null);      
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException ae) {
    assertTextPresent("executionId is null", ae.getMessage());
  }
}
 

public void testRemoveVariableNullTaskId() {
  try {
    taskService.removeVariable(null, "variable");
    fail("ActivitiException expected");
  } catch (ActivitiIllegalArgumentException ae) {
    assertTextPresent("taskId is null", ae.getMessage());
  }
}
 

public static RestVariableScope getScopeFromString(String scope) {
  if (scope != null) {
    for (RestVariableScope s : RestVariableScope.values()) {
      if (s.name().equalsIgnoreCase(scope)) {
        return s;
      }
    }
    throw new ActivitiIllegalArgumentException("Invalid variable scope: '" + scope + "'");
  } else {
    return null;
  }
}
 

public ModelQueryImpl modelCategoryNotEquals(String categoryNotEquals) {
  if (categoryNotEquals == null) {
    throw new ActivitiIllegalArgumentException("categoryNotEquals is null");
  }
  this.categoryNotEquals = categoryNotEquals;
  return this;
}
 

public Object convertFormValueToModelValue(String propertyValue) {
  if (StringUtils.isEmpty(propertyValue)) {
    return null;
  }
  try {
    return dateFormat.parseObject(propertyValue);
  } catch (ParseException e) {
    throw new ActivitiIllegalArgumentException("invalid date value " + propertyValue);
  }
}