import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
@Override
public void configure(ProcessEngineConfigurationImpl processEngineConfiguration)
{
    // There is an issue when using Activiti with Oracle. When workflow variables have a length greater then 2000 and smaller than 4001,
    // Activiti tries to store that as a String column, but the Oracle database column length (ACT_RU_VARIABLE.TEXT_, ACT_HI_VARINST.TEXT_) is 2000.
    // Since Activiti uses NVARCHAR as the column type which requires 2 bytes for every character, the maximum size Oracle allows for the column is
    // 2000 (i.e. 4000 bytes).

    // Replace the StringType and LongType to store greater than 2000 length variables as blob.
    VariableTypes variableTypes = processEngineConfiguration.getVariableTypes();

    VariableType stringType = new StringType(2000);
    int indexToInsert = replaceVariableType(variableTypes, stringType, 0);

    VariableType longStringType = new LongStringType(2001);
    replaceVariableType(variableTypes, longStringType, ++indexToInsert);
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
/**
 * Inserts the variableType in variableTypes at the given index. If variableType already exists, then it replaces the type at the location where it already
 * exists.
 *
 * @param variableTypes the variableTypes
 * @param variableTypeToReplace the variableType to insert
 * @param indexToInsert the index to insert variableType
 *
 * @return the index where variableType was inserted.
 */
private int replaceVariableType(VariableTypes variableTypes, VariableType variableTypeToReplace, int indexToInsert)
{
    int indexToInsertReturn = indexToInsert;

    VariableType existingVariableType = variableTypes.getVariableType(variableTypeToReplace.getTypeName());
    if (existingVariableType != null)
    {
        indexToInsertReturn = variableTypes.getTypeIndex(existingVariableType.getTypeName());

        variableTypes.removeType(existingVariableType);
    }
    variableTypes.addType(variableTypeToReplace, indexToInsertReturn);

    return indexToInsertReturn;
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
public void createVariableLocal(String variableName, Object value) {
  ensureVariableInstancesInitialized();
  
  if (variableInstances.containsKey(variableName)) {
    throw new ActivitiException("variable '"+variableName+"' already exists. Use setVariableLocal if you want to overwrite the value");
  }
  
  VariableTypes variableTypes = Context
    .getProcessEngineConfiguration()
    .getVariableTypes();
  
  VariableType type = variableTypes.findVariableType(value);
 
  VariableInstanceEntity variableInstance = VariableInstanceEntity.createAndInsert(variableName, type, value);
  initializeVariableInstanceBackPointer(variableInstance);
  variableInstances.put(variableName, variableInstance);
  
  setVariableInstanceValue(value, variableInstance);
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected void updateVariableInstance(VariableInstanceEntity variableInstance, Object value, ExecutionEntity sourceActivityExecution) {

     // type should be changed
 if ((variableInstance != null) && (!variableInstance.getType().isAbleToStore(value))) {
	    VariableTypes variableTypes = Context
	    	      .getProcessEngineConfiguration()
	    	      .getVariableTypes();
	    VariableType newType = variableTypes.findVariableType(value);
	    variableInstance.setValue(null);
	    variableInstance.setType(newType);
	    variableInstance.forceUpdate();
  }
   variableInstance.setValue(value);

   Context.getCommandContext().getHistoryManager()
     .recordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, isActivityIdUsedForDetails());
   
   Context.getCommandContext().getHistoryManager()
     .recordVariableUpdate(variableInstance);
 }
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected VariableInstanceEntity createVariableInstance(String variableName, Object value, ExecutionEntity sourceActivityExecution) {
  VariableTypes variableTypes = Context
    .getProcessEngineConfiguration()
    .getVariableTypes();
  
  VariableType type = variableTypes.findVariableType(value);
 
  VariableInstanceEntity variableInstance = VariableInstanceEntity.createAndInsert(variableName, type, value);
  initializeVariableInstanceBackPointer(variableInstance);
  variableInstances.put(variableName, variableInstance);
  
  // Record historic variable
  Context.getCommandContext().getHistoryManager()
    .recordVariableCreate(variableInstance);

  // Record historic detail
  Context.getCommandContext().getHistoryManager()
    .recordHistoricDetailVariableCreate(variableInstance, sourceActivityExecution, isActivityIdUsedForDetails());

  return variableInstance;
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected void ensureVariablesInitialized() {
    VariableTypes types = Context.getProcessEngineConfiguration()
            .getVariableTypes();

    for (QueryVariableValue var : queryVariableValues) {
        var.initialize(types);
    }

    for (TaskQueryImpl orQueryObject : orQueryObjects) {
        orQueryObject.ensureVariablesInitialized();
    }
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected void ensureVariablesInitialized() {
  if (!queryVariableValues.isEmpty()) {
    VariableTypes variableTypes = Context
            .getProcessEngineConfiguration()
            .getVariableTypes();
    for(QueryVariableValue queryVariableValue : queryVariableValues) {
      queryVariableValue.initialize(variableTypes);
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected VariableTypes getVariableTypes() {
  if (variableTypes==null) {
    variableTypes = Context
      .getProcessEngineConfiguration()
      .getVariableTypes();
  }
  return variableTypes;
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
public void initialize(VariableTypes types) {
  if(variableInstanceEntity == null) {
    VariableType type = types.findVariableType(value);
    if(type instanceof ByteArrayType) {
      throw new ActivitiException("Variables of type ByteArray cannot be used to query");
    } else if(type instanceof JPAEntityVariableType && operator != QueryOperator.EQUALS) {
      throw new ActivitiException("JPA entity variables can only be used in 'variableValueEquals'");
    } else {
      // Type implementation determines which fields are set on the entity
      variableInstanceEntity = VariableInstanceEntity.create(name, type, value);
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
public void initialize(VariableTypes types) {
  if(variableInstanceEntity == null) {
    VariableType type = types.findVariableType(value);
    if(type instanceof ByteArrayType) {
      throw new ActivitiIllegalArgumentException("Variables of type ByteArray cannot be used to query");
    } else if(type instanceof JPAEntityVariableType && operator != QueryOperator.EQUALS) {
      throw new ActivitiIllegalArgumentException("JPA entity variables can only be used in 'variableValueEquals'");
    } else {
      // Type implementation determines which fields are set on the entity
      variableInstanceEntity = VariableInstanceEntity.create(name, type, value);
    }
  }
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
@Scheduled(cron = "${analytics.pollingInterval}")
public void analyticsProcessing() throws Exception {

	if (isEnterprise.equals("true")) {
		if (processEngine.getVariableTypes().getVariableType("data-model-type") == null) {
			// Adding the data model type variable type to engine config for
			// APS implementations.
			VariableTypes variableTypes = processEngine.getVariableTypes();
			int serializableIndex = variableTypes.getTypeIndex(SerializableType.TYPE_NAME);
			if (serializableIndex > -1) {
				variableTypes.addType(new VariableDataEntityType(), serializableIndex);
			} else {
				variableTypes.addType(new VariableDataEntityType());
			}
		}
	}

	customAnalyticsEndpoint.preProcessing();
	boolean newEventsExist = true;
	int loopSize = 0;
	while (newEventsExist == true) {
		loopSize++;
		logger.info("processing loop counter - " + loopSize);
		// Fetch latest watermark
		String timeStamp = watermark.fetchWatermark();

		Map<String, Object> processBatchMetadata = processBatchPreparation.getBatchMetadata(timeStamp);

		newEventsExist = (boolean) processBatchMetadata.get("newEventsExist");
		List<Map<String, Object>> processList = (List<Map<String, Object>>) processBatchMetadata
				.get("processIdList");

		if (processList != null) {
			logger.debug("process list is - " + processList.toString());
			for (Map<String, Object> processInstance : processList) {
				try {
					generateProcessAndTaskDocs.execute(processInstance);
				} catch (Exception e) {

				}
			}
			// Update watermark
			watermark.updateWatermark((String) processBatchMetadata.get("toTimestamp"));
		} else {
			logger.info("process list is null");
		}
	}

	logger.info(watermark.fetchWatermark());
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
public VariableTypes getVariableTypes() {
  return variableTypes;
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
public ProcessEngineConfigurationImpl setVariableTypes(VariableTypes variableTypes) {
  this.variableTypes = variableTypes;
  return this;
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected void ensureVariablesInitialized() {    
  VariableTypes types = Context.getProcessEngineConfiguration().getVariableTypes();
  for(QueryVariableValue var : variables) {
    var.initialize(types);
  }
}
 

import org.activiti.engine.impl.variable.VariableTypes; //导入依赖的package包/类
protected void ensureVariablesInitialized() {
  if (this.queryVariableValue != null) {
    VariableTypes variableTypes = Context.getProcessEngineConfiguration().getVariableTypes();
    queryVariableValue.initialize(variableTypes);
  }
}