Skip to content

F
Flowable Engine

开发团队 / Flowable Engine

通知 9
Star 0
Fork 0
F
Flowable Engine

体验新版 GitCode，发现更多精彩内容 >>

提交 240fa4dd 编写于 作者: J Joram Barrez
浏览文件
操作

Refactoring the persistence: splitting of persistence specific code in the... 

Refactoring the persistence: splitting of persistence specific code in the EntityManager classes into a DataManager class.
The EntityManager -> EntityManagerImpl  now each have a dedicated DataManagerImpl that contains all the MyBatis specific code,
effectively making it possible to plug that layer with some other implementation.

Note: Still need to check the usages of DbSqlSession in the behaviors/commands, but those should be easily portable too.
上级 a89384f0
展开全部 隐藏空白更改
内联 并排
Showing with 4539 addition and 1221 deletion
modules/activiti-engine/src/main/java/org/activiti/engine/impl/cfg/ProcessEngineConfigurationImpl.java
浏览文件 @ 240fa4dd
......@@ -212,6 +212,56 @@ import org.activiti.engine.impl.persistence.entity.UserEntityManager;
import org.activiti.engine.impl.persistence.entity.UserEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.AttachmentDataManager;
import org.activiti.engine.impl.persistence.entity.data.AttachmentDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.ByteArrayDataManager;
import org.activiti.engine.impl.persistence.entity.data.ByteArrayDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.CommentDataManager;
import org.activiti.engine.impl.persistence.entity.data.CommentDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.DeploymentDataManager;
import org.activiti.engine.impl.persistence.entity.data.DeploymentDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.EventLogEntryDataManager;
import org.activiti.engine.impl.persistence.entity.data.EventLogEntryDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.EventSubscriptionDataManager;
import org.activiti.engine.impl.persistence.entity.data.EventSubscriptionDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.ExecutionDataManager;
import org.activiti.engine.impl.persistence.entity.data.ExecutionDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.GroupDataManager;
import org.activiti.engine.impl.persistence.entity.data.GroupDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricActivityInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricActivityInstanceDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricDetailDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricDetailDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricIdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricIdentityLinkDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricProcessInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricProcessInstanceDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricTaskInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricTaskInstanceDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.HistoricVariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricVariableInstanceDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.IdentityInfoDataManager;
import org.activiti.engine.impl.persistence.entity.data.IdentityInfoDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.IdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.IdentityLinkDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.JobDataManager;
import org.activiti.engine.impl.persistence.entity.data.JobDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.MembershipDataManager;
import org.activiti.engine.impl.persistence.entity.data.MembershipDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.ModelDataManager;
import org.activiti.engine.impl.persistence.entity.data.ModelDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.ProcessDefinitionDataManager;
import org.activiti.engine.impl.persistence.entity.data.ProcessDefinitionDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.PropertyDataManager;
import org.activiti.engine.impl.persistence.entity.data.PropertyDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.ResourceDataManager;
import org.activiti.engine.impl.persistence.entity.data.ResourceDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.TaskDataManager;
import org.activiti.engine.impl.persistence.entity.data.TaskDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.UserDataManager;
import org.activiti.engine.impl.persistence.entity.data.UserDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.VariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.VariableInstanceDataManagerImpl;
import org.activiti.engine.impl.scripting.BeansResolverFactory;
import org.activiti.engine.impl.scripting.ResolverFactory;
import org.activiti.engine.impl.scripting.ScriptBindingsFactory;
......@@ -305,6 +355,35 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
/** this will be initialized during the configurationComplete() */
protected CommandExecutor commandExecutor;
// DATA MANAGERS /////////////////////////////////////////////////////////////
protected AttachmentDataManager attachmentDataManager;
protected ByteArrayDataManager byteArrayDataManager;
protected CommentDataManager commentDataManager;
protected DeploymentDataManager deploymentDataManager;
protected EventLogEntryDataManager eventLogEntryDataManager;
protected EventSubscriptionDataManager eventSubscriptionDataManager;
protected ExecutionDataManager executionDataManager;
protected GroupDataManager groupDataManager;
protected HistoricActivityInstanceDataManager historicActivityInstanceDataManager;
protected HistoricDetailDataManager historicDetailDataManager;
protected HistoricIdentityLinkDataManager historicIdentityLinkDataManager;
protected HistoricProcessInstanceDataManager historicProcessInstanceDataManager;
protected HistoricTaskInstanceDataManager historicTaskInstanceDataManager;
protected HistoricVariableInstanceDataManager historicVariableInstanceDataManager;
protected IdentityInfoDataManager identityInfoDataManager;
protected IdentityLinkDataManager identityLinkDataManager;
protected JobDataManager jobDataManager;
protected MembershipDataManager membershipDataManager;
protected ModelDataManager modelDataManager;
protected ProcessDefinitionDataManager processDefinitionDataManager;
protected PropertyDataManager propertyDataManager;
protected ResourceDataManager resourceDataManager;
protected TaskDataManager taskDataManager;
protected UserDataManager userDataManager;
protected VariableInstanceDataManager variableInstanceDataManager;
// ENTITY MANAGERS ///////////////////////////////////////////////////////////
protected AttachmentEntityManager attachmentEntityManager;
......@@ -541,6 +620,7 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
initTransactionFactory();
initSqlSessionFactory();
initSessionFactories();
initDataManagers();
initEntityManagers();
initHistoryManager();
initJpa();
......@@ -889,35 +969,65 @@ public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfig
this.customMybatisXMLMappers = customMybatisXMLMappers;
}
// Data managers ///////////////////////////////////////////////////////////
protected void initDataManagers() {
attachmentDataManager = new AttachmentDataManagerImpl();
byteArrayDataManager = new ByteArrayDataManagerImpl();
commentDataManager = new CommentDataManagerImpl();
deploymentDataManager = new DeploymentDataManagerImpl();
eventLogEntryDataManager = new EventLogEntryDataManagerImpl();
eventSubscriptionDataManager = new EventSubscriptionDataManagerImpl();
executionDataManager = new ExecutionDataManagerImpl();
groupDataManager = new GroupDataManagerImpl();
historicActivityInstanceDataManager = new HistoricActivityInstanceDataManagerImpl();
historicDetailDataManager = new HistoricDetailDataManagerImpl();
historicIdentityLinkDataManager = new HistoricIdentityLinkDataManagerImpl();
historicProcessInstanceDataManager = new HistoricProcessInstanceDataManagerImpl();
historicTaskInstanceDataManager = new HistoricTaskInstanceDataManagerImpl();
historicVariableInstanceDataManager = new HistoricVariableInstanceDataManagerImpl();
identityInfoDataManager = new IdentityInfoDataManagerImpl();
identityLinkDataManager = new IdentityLinkDataManagerImpl();
jobDataManager = new JobDataManagerImpl();
membershipDataManager = new MembershipDataManagerImpl();
modelDataManager = new ModelDataManagerImpl();
processDefinitionDataManager = new ProcessDefinitionDataManagerImpl();
propertyDataManager = new PropertyDataManagerImpl();
resourceDataManager = new ResourceDataManagerImpl();
taskDataManager = new TaskDataManagerImpl();
userDataManager = new UserDataManagerImpl();
variableInstanceDataManager = new VariableInstanceDataManagerImpl();
}
// Entity managers //////////////////////////////////////////////////////////
protected void initEntityManagers() {
attachmentEntityManager = new AttachmentEntityManagerImpl();
byteArrayEntityManager = new ByteArrayEntityManagerImpl();
commentEntityManager = new CommentEntityManagerImpl();
deploymentEntityManager = new DeploymentEntityManagerImpl();
eventLogEntryEntityManager = new EventLogEntryEntityManagerImpl();
eventSubscriptionEntityManager = new EventSubscriptionEntityManagerImpl();
executionEntityManager = new ExecutionEntityManagerImpl();
groupEntityManager = new GroupEntityManagerImpl();
historicActivityInstanceEntityManager = new HistoricActivityInstanceEntityManagerImpl();
historicDetailEntityManager = new HistoricDetailEntityManagerImpl();
historicIdentityLinkEntityManager = new HistoricIdentityLinkEntityManagerImpl();
historicProcessInstanceEntityManager = new HistoricProcessInstanceEntityManagerImpl();
historicTaskInstanceEntityManager = new HistoricTaskInstanceEntityManagerImpl();
historicVariableInstanceEntityManager = new HistoricVariableInstanceEntityManagerImpl();
identityInfoEntityManager = new IdentityInfoEntityManagerImpl();
identityLinkEntityManager = new IdentityLinkEntityManagerImpl();
jobEntityManager = new JobEntityManagerImpl();
membershipEntityManager = new MembershipEntityManagerImpl();
modelEntityManager = new ModelEntityManagerImpl();
processDefinitionEntityManager = new ProcessDefinitionEntityManagerImpl();
propertyEntityManager = new PropertyEntityManagerImpl();
resourceEntityManager = new ResourceEntityManagerImpl();
attachmentEntityManager = new AttachmentEntityManagerImpl(attachmentDataManager);
byteArrayEntityManager = new ByteArrayEntityManagerImpl(byteArrayDataManager);
commentEntityManager = new CommentEntityManagerImpl(commentDataManager);
deploymentEntityManager = new DeploymentEntityManagerImpl(deploymentDataManager);
eventLogEntryEntityManager = new EventLogEntryEntityManagerImpl(eventLogEntryDataManager);
eventSubscriptionEntityManager = new EventSubscriptionEntityManagerImpl(eventSubscriptionDataManager);
executionEntityManager = new ExecutionEntityManagerImpl(executionDataManager);
groupEntityManager = new GroupEntityManagerImpl(groupDataManager);
historicActivityInstanceEntityManager = new HistoricActivityInstanceEntityManagerImpl(historicActivityInstanceDataManager);
historicDetailEntityManager = new HistoricDetailEntityManagerImpl(historicDetailDataManager);
historicIdentityLinkEntityManager = new HistoricIdentityLinkEntityManagerImpl(historicIdentityLinkDataManager);
historicProcessInstanceEntityManager = new HistoricProcessInstanceEntityManagerImpl(historicProcessInstanceDataManager);
historicTaskInstanceEntityManager = new HistoricTaskInstanceEntityManagerImpl(historicTaskInstanceDataManager);
historicVariableInstanceEntityManager = new HistoricVariableInstanceEntityManagerImpl(historicVariableInstanceDataManager);
identityInfoEntityManager = new IdentityInfoEntityManagerImpl(identityInfoDataManager);
identityLinkEntityManager = new IdentityLinkEntityManagerImpl(identityLinkDataManager);
jobEntityManager = new JobEntityManagerImpl(jobDataManager);
membershipEntityManager = new MembershipEntityManagerImpl(membershipDataManager);
modelEntityManager = new ModelEntityManagerImpl(modelDataManager);
processDefinitionEntityManager = new ProcessDefinitionEntityManagerImpl(processDefinitionDataManager);
propertyEntityManager = new PropertyEntityManagerImpl(propertyDataManager);
resourceEntityManager = new ResourceEntityManagerImpl(resourceDataManager);
tableDataManager = new TableDataManagerImpl();
taskEntityManager = new TaskEntityManagerImpl();
userEntityManager = new UserEntityManagerImpl();
variableInstanceEntityManager = new VariableInstanceEntityManagerImpl();
taskEntityManager = new TaskEntityManagerImpl(taskDataManager);
userEntityManager = new UserEntityManagerImpl(userDataManager);
variableInstanceEntityManager = new VariableInstanceEntityManagerImpl(variableInstanceDataManager);
}
// History manager ///////////////////////////////////////////////////////////
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/SaveGroupCmd.java
浏览文件 @ 240fa4dd
......@@ -45,7 +45,12 @@ public class SaveGroupCmd implements Command<Void>, Serializable {
commandContext.getDbSqlSession().insert((Entity) group);
}
} else {
commandContext.getGroupEntityManager().updateGroup(group);
if (group instanceof GroupEntity) {
commandContext.getGroupEntityManager().update((GroupEntity) group);
} else {
commandContext.getDbSqlSession().update((Entity) group);
}
}
return null;
}
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/SetProcessDefinitionVersionCmd.java
浏览文件 @ 240fa4dd
......@@ -86,7 +86,8 @@ public class SetProcessDefinitionVersionCmd implements Command<Void>, Serializab
DeploymentManager deploymentCache = commandContext.getProcessEngineConfiguration().getDeploymentManager();
ProcessDefinitionEntity currentProcessDefinition = deploymentCache.findDeployedProcessDefinitionById(processInstance.getProcessDefinitionId());
ProcessDefinitionEntity newProcessDefinition = deploymentCache.findDeployedProcessDefinitionByKeyAndVersion(currentProcessDefinition.getKey(), processDefinitionVersion);
ProcessDefinitionEntity newProcessDefinition = deploymentCache
.findDeployedProcessDefinitionByKeyAndVersionAndTenantId(currentProcessDefinition.getKey(), processDefinitionVersion, currentProcessDefinition.getTenantId());
validateAndSwitchVersionOfExecution(commandContext, processInstance, newProcessDefinition);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/deploy/DeploymentManager.java
浏览文件 @ 240fa4dd
......@@ -91,9 +91,9 @@ public class DeploymentManager {
return processDefinition;
}
public ProcessDefinitionEntity findDeployedProcessDefinitionByKeyAndVersion(String processDefinitionKey, Integer processDefinitionVersion) {
public ProcessDefinitionEntity findDeployedProcessDefinitionByKeyAndVersionAndTenantId(String processDefinitionKey, Integer processDefinitionVersion, String tenantId) {
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) Context.getCommandContext().getProcessDefinitionEntityManager()
.findProcessDefinitionByKeyAndVersion(processDefinitionKey, processDefinitionVersion);
.findProcessDefinitionByKeyAndVersionAndTenantId(processDefinitionKey, processDefinitionVersion, tenantId);
if (processDefinition == null) {
throw new ActivitiObjectNotFoundException("no processes deployed with key = '" + processDefinitionKey + "' and version = '" + processDefinitionVersion + "'", ProcessDefinition.class);
}
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/AbstractEntityManager.java
浏览文件 @ 240fa4dd
package org.activiti.engine.impl.persistence.entity;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.activiti.engine.ActivitiIllegalArgumentException;
import org.activiti.engine.delegate.event.ActivitiEventDispatcher;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.db.Entity;
import org.activiti.engine.impl.persistence.AbstractManager;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.cache.CachedEntity;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
/**
* @author Joram Barrez
*/
public class AbstractEntityManager<EntityImpl extends Entity> extends AbstractManager implements EntityManager<EntityImpl> {
public abstract class AbstractEntityManager<EntityImpl extends Entity> extends AbstractManager implements EntityManager<EntityImpl> {
public Class<EntityImpl> getManagedEntity() {
// Cannot make abstract cause some managers don't use db persistence (eg ldap)
throw new UnsupportedOperationException();
}
public List<Class<? extends EntityImpl>> getManagedEntitySubClasses() {
return null;
}
/*
* CRUD operations
*/
@Override
public EntityImpl findById(String entityId) {
return getDataManager().findById(entityId);
}
@Override
public void insert(EntityImpl entity) {
......@@ -40,7 +28,7 @@ public class AbstractEntityManager<EntityImpl extends Entity> extends AbstractMa
@Override
public void insert(EntityImpl entity, boolean fireCreateEvent) {
getDbSqlSession().insert(entity);
getDataManager().insert(entity);
ActivitiEventDispatcher eventDispatcher = getEventDispatcher();
if (fireCreateEvent && eventDispatcher.isEnabled()) {
......@@ -49,6 +37,22 @@ public class AbstractEntityManager<EntityImpl extends Entity> extends AbstractMa
}
}
@Override
public EntityImpl update(EntityImpl entity) {
return update(entity, true);
}
@Override
public EntityImpl update(EntityImpl entity, boolean fireUpdateEvent) {
EntityImpl updatedEntity = getDataManager().update(entity);
if (fireUpdateEvent && getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, entity));
}
return updatedEntity;
}
@Override
public void delete(String id) {
EntityImpl entity = findById(id);
......@@ -62,108 +66,13 @@ public class AbstractEntityManager<EntityImpl extends Entity> extends AbstractMa
@Override
public void delete(EntityImpl entity, boolean fireDeleteEvent) {
getDbSqlSession().delete(entity);
getDataManager().delete(entity);
if (fireDeleteEvent && getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, entity));
}
}
/*
* Advanced operations
*/
@Override
public EntityImpl findById(String entityId) {
if (entityId == null) {
throw new ActivitiIllegalArgumentException("Invalid entity id : null");
}
// Cache
EntityImpl cachedEntity = getEntityCache().findInCache(getManagedEntity(), entityId);
if (cachedEntity != null) {
return cachedEntity;
}
// Database
return getDbSqlSession().selectById(getManagedEntity(), entityId);
}
@Override
@SuppressWarnings("unchecked")
public EntityImpl findByQuery(String selectQuery, Object parameter, CachedEntityMatcher<EntityImpl> cachedEntityMatcher) {
// Cache
for (EntityImpl cachedEntity : getEntityCache().findInCache(getManagedEntity())) {
if (cachedEntityMatcher.isRetained(cachedEntity)) {
return cachedEntity;
}
}
// Database
return (EntityImpl) getDbSqlSession().selectOne(selectQuery, parameter);
}
@Override
@SuppressWarnings("unchecked")
public List<EntityImpl> getList(String dbQueryName, Object parameter, CachedEntityMatcher<EntityImpl> retainEntityCondition, boolean checkCache) {
protected abstract DataManager<EntityImpl> getDataManager();
Collection<EntityImpl> result = getDbSqlSession().selectList(dbQueryName, parameter);
if (checkCache) {
Collection<CachedEntity> cachedObjects = getEntityCache().findInCacheAsCachedObjects(getManagedEntity());
if ( (cachedObjects != null && cachedObjects.size() > 0) || getManagedEntitySubClasses() != null) {
HashMap<String, EntityImpl> entityMap = new HashMap<String, EntityImpl>(result.size());
// Database entities
for (EntityImpl entity : result) {
entityMap.put(entity.getId(), entity);
}
// Cache entities
if (cachedObjects != null) {
for (CachedEntity cachedObject : cachedObjects) {
EntityImpl cachedEntity = (EntityImpl) cachedObject.getEntity();
if (retainEntityCondition.isRetained(cachedEntity)) {
entityMap.put(cachedEntity.getId(), cachedEntity); // will overwite db version with newer version
}
}
}
if (getManagedEntitySubClasses() != null) {
for (Class<? extends EntityImpl> entitySubClass : getManagedEntitySubClasses()) {
Collection<CachedEntity> subclassCachedObjects = getEntityCache().findInCacheAsCachedObjects(entitySubClass);
if (subclassCachedObjects != null) {
for (CachedEntity subclassCachedObject : subclassCachedObjects) {
EntityImpl cachedSubclassEntity = (EntityImpl) subclassCachedObject.getEntity();
if (retainEntityCondition.isRetained(cachedSubclassEntity)) {
entityMap.put(cachedSubclassEntity.getId(), cachedSubclassEntity); // will overwite db version with newer version
}
}
}
}
}
result = entityMap.values();
}
}
// Remove entries which are already deleted
if (result.size() > 0) {
Iterator<EntityImpl> resultIterator = result.iterator();
while (resultIterator.hasNext()) {
if (getDbSqlSession().isEntityToBeDeleted(resultIterator.next())) {
resultIterator.remove();
}
}
}
return new ArrayList<EntityImpl>(result);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/AttachmentEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -18,6 +18,8 @@ import java.util.List;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.persistence.entity.data.AttachmentDataManager;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.task.Attachment;
import org.activiti.engine.task.Task;
......@@ -27,30 +29,37 @@ import org.activiti.engine.task.Task;
*/
public class AttachmentEntityManagerImpl extends AbstractEntityManager<AttachmentEntity> implements AttachmentEntityManager {
protected AttachmentDataManager attachmentDataManager;
public AttachmentEntityManagerImpl() {
}
public AttachmentEntityManagerImpl(AttachmentDataManager attachmentDataManager) {
this.attachmentDataManager = attachmentDataManager;
}
@Override
public Class<AttachmentEntity> getManagedEntity() {
return AttachmentEntity.class;
protected DataManager<AttachmentEntity> getDataManager() {
return attachmentDataManager;
}
@Override
@SuppressWarnings("unchecked")
public List<Attachment> findAttachmentsByProcessInstanceId(String processInstanceId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectAttachmentsByProcessInstanceId", processInstanceId);
return attachmentDataManager.findAttachmentsByProcessInstanceId(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Attachment> findAttachmentsByTaskId(String taskId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectAttachmentsByTaskId", taskId);
return attachmentDataManager.findAttachmentsByTaskId(taskId);
}
@Override
@SuppressWarnings("unchecked")
public void deleteAttachmentsByTaskId(String taskId) {
checkHistoryEnabled();
List<AttachmentEntity> attachments = getDbSqlSession().selectList("selectAttachmentsByTaskId", taskId);
List<Attachment> attachments = findAttachmentsByTaskId(taskId);
boolean dispatchEvents = getEventDispatcher().isEnabled();
String processInstanceId = null;
......@@ -68,12 +77,14 @@ public class AttachmentEntityManagerImpl extends AbstractEntityManager<Attachmen
}
}
for (AttachmentEntity attachment : attachments) {
for (Attachment attachment : attachments) {
String contentId = attachment.getContentId();
if (contentId != null) {
getByteArrayEntityManager().deleteByteArrayById(contentId);
}
getDbSqlSession().delete(attachment);
attachmentDataManager.delete((AttachmentEntity) attachment);
if (dispatchEvents) {
getEventDispatcher().dispatchEvent(
ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, attachment, executionId, processInstanceId, processDefinitionId));
......@@ -86,4 +97,13 @@ public class AttachmentEntityManagerImpl extends AbstractEntityManager<Attachmen
throw new ActivitiException("In order to use attachments, history should be enabled");
}
}
public AttachmentDataManager getAttachmentDataManager() {
return attachmentDataManager;
}
public void setAttachmentDataManager(AttachmentDataManager attachmentDataManager) {
this.attachmentDataManager = attachmentDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ByteArrayEntityManager.java
浏览文件 @ 240fa4dd
......@@ -28,6 +28,4 @@ public interface ByteArrayEntityManager extends EntityManager<ByteArrayEntity> {
*/
void deleteByteArrayById(String byteArrayEntityId);
void deleteByteArray(ByteArrayEntity byteArray);
}
\ No newline at end of file
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ByteArrayEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,16 +13,29 @@
package org.activiti.engine.impl.persistence.entity;
import org.activiti.engine.impl.persistence.entity.data.ByteArrayDataManager;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
/**
* @author Joram Barrez
* @author Marcus Klimstra (CGI)
*/
public class ByteArrayEntityManagerImpl extends AbstractEntityManager<ByteArrayEntity> implements ByteArrayEntityManager {
protected ByteArrayDataManager byteArrayDataManager;
public ByteArrayEntityManagerImpl() {
}
public ByteArrayEntityManagerImpl(ByteArrayDataManager byteArrayDataManager) {
this.byteArrayDataManager = byteArrayDataManager;
}
@Override
public Class<ByteArrayEntity> getManagedEntity() {
return ByteArrayEntity.class;
protected DataManager<ByteArrayEntity> getDataManager() {
return byteArrayDataManager;
}
@Override
......@@ -33,18 +46,21 @@ public class ByteArrayEntityManagerImpl extends AbstractEntityManager<ByteArrayE
@Override
public ByteArrayEntity createAndInsert(String name, byte[] bytes) {
ByteArrayEntity byteArrayEntity = new ByteArrayEntity(name, bytes);
insert(byteArrayEntity);
byteArrayDataManager.insert(byteArrayEntity);
return byteArrayEntity;
}
@Override
public void deleteByteArrayById(String byteArrayEntityId) {
getDbSqlSession().delete("deleteByteArrayNoRevisionCheck", byteArrayEntityId);
byteArrayDataManager.deleteByteArrayNoRevisionCheck(byteArrayEntityId);
}
@Override
public void deleteByteArray(ByteArrayEntity byteArray) {
getDbSqlSession().delete(byteArray);
public ByteArrayDataManager getByteArrayDataManager() {
return byteArrayDataManager;
}
public void setByteArrayDataManager(ByteArrayDataManager byteArrayDataManager) {
this.byteArrayDataManager = byteArrayDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ByteArrayRef.java
浏览文件 @ 240fa4dd
......@@ -80,7 +80,7 @@ public final class ByteArrayRef implements Serializable {
if (entity != null) {
// if the entity has been loaded already,
// we might as well use the safer optimistic locking delete.
Context.getCommandContext().getByteArrayEntityManager().deleteByteArray(entity);
Context.getCommandContext().getByteArrayEntityManager().delete(entity);
} else {
Context.getCommandContext().getByteArrayEntityManager().deleteByteArrayById(id);
}
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/CommentEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,13 +13,13 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.persistence.entity.data.CommentDataManager;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.Event;
......@@ -28,16 +28,27 @@ import org.activiti.engine.task.Event;
* @author Joram Barrez
*/
public class CommentEntityManagerImpl extends AbstractEntityManager<CommentEntity> implements CommentEntityManager {
protected CommentDataManager commentDataManager;
public CommentEntityManagerImpl() {
}
public CommentEntityManagerImpl(CommentDataManager commentDataManager) {
this.commentDataManager = commentDataManager;
}
@Override
public Class<CommentEntity> getManagedEntity() {
return CommentEntity.class;
protected DataManager<CommentEntity> getDataManager() {
return commentDataManager;
}
@Override
public void insert(CommentEntity commentEntity) {
checkHistoryEnabled();
super.insert(commentEntity, false);
insert(commentEntity, false);
Comment comment = (Comment) commentEntity;
if (getEventDispatcher().isEnabled()) {
......@@ -59,86 +70,74 @@ public class CommentEntityManagerImpl extends AbstractEntityManager<CommentEntit
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByTaskId(String taskId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectCommentsByTaskId", taskId);
return commentDataManager.findCommentsByTaskId(taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByTaskIdAndType(String taskId, String type) {
checkHistoryEnabled();
Map<String, Object> params = new HashMap<String, Object>();
params.put("taskId", taskId);
params.put("type", type);
return getDbSqlSession().selectListWithRawParameter("selectCommentsByTaskIdAndType", params, 0, Integer.MAX_VALUE);
return commentDataManager.findCommentsByTaskIdAndType(taskId, type);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByType(String type) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectCommentsByType", type);
return commentDataManager.findCommentsByType(type);
}
@Override
@SuppressWarnings("unchecked")
public List<Event> findEventsByTaskId(String taskId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectEventsByTaskId", taskId);
return commentDataManager.findEventsByTaskId(taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<Event> findEventsByProcessInstanceId(String processInstanceId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectEventsByProcessInstanceId", processInstanceId);
return commentDataManager.findEventsByProcessInstanceId(processInstanceId);
}
@Override
public void deleteCommentsByTaskId(String taskId) {
checkHistoryEnabled();
getDbSqlSession().delete("deleteCommentsByTaskId", taskId);
commentDataManager.deleteCommentsByTaskId(taskId);
}
@Override
public void deleteCommentsByProcessInstanceId(String processInstanceId) {
checkHistoryEnabled();
getDbSqlSession().delete("deleteCommentsByProcessInstanceId", processInstanceId);
commentDataManager.deleteCommentsByProcessInstanceId(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByProcessInstanceId(String processInstanceId) {
checkHistoryEnabled();
return getDbSqlSession().selectList("selectCommentsByProcessInstanceId", processInstanceId);
return commentDataManager.findCommentsByProcessInstanceId(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByProcessInstanceId(String processInstanceId, String type) {
checkHistoryEnabled();
Map<String, Object> params = new HashMap<String, Object>();
params.put("processInstanceId", processInstanceId);
params.put("type", type);
return getDbSqlSession().selectListWithRawParameter("selectCommentsByProcessInstanceIdAndType", params, 0, Integer.MAX_VALUE);
return commentDataManager.findCommentsByProcessInstanceId(processInstanceId, type);
}
@Override
public Comment findComment(String commentId) {
return getDbSqlSession().selectById(CommentEntity.class, commentId);
return commentDataManager.findComment(commentId);
}
@Override
public Event findEvent(String commentId) {
return getDbSqlSession().selectById(CommentEntity.class, commentId);
return commentDataManager.findEvent(commentId);
}
@Override
public void delete(CommentEntity commentEntity) {
checkHistoryEnabled();
super.delete(commentEntity, false);
delete(commentEntity, false);
Comment comment = (Comment) commentEntity;
if (getEventDispatcher().isEnabled()) {
......@@ -162,4 +161,13 @@ public class CommentEntityManagerImpl extends AbstractEntityManager<CommentEntit
throw new ActivitiException("In order to use comments, history should be enabled");
}
}
public CommentDataManager getCommentDataManager() {
return commentDataManager;
}
public void setCommentDataManager(CommentDataManager commentDataManager) {
this.commentDataManager = commentDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/DeploymentEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -23,10 +23,13 @@ import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.DeploymentQueryImpl;
import org.activiti.engine.impl.ModelQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.ProcessDefinitionQueryImpl;
import org.activiti.engine.impl.jobexecutor.TimerEventHandler;
import org.activiti.engine.impl.jobexecutor.TimerStartEventJobHandler;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.DeploymentDataManager;
import org.activiti.engine.impl.util.ProcessDefinitionUtil;
import org.activiti.engine.impl.util.TimerUtil;
import org.activiti.engine.repository.Deployment;
......@@ -41,14 +44,24 @@ import org.apache.commons.collections.CollectionUtils;
*/
public class DeploymentEntityManagerImpl extends AbstractEntityManager<DeploymentEntity> implements DeploymentEntityManager {
protected DeploymentDataManager deploymentDataManager;
public DeploymentEntityManagerImpl() {
}
public DeploymentEntityManagerImpl(DeploymentDataManager deploymentDataManager) {
this.deploymentDataManager = deploymentDataManager;
}
@Override
public Class<DeploymentEntity> getManagedEntity() {
return DeploymentEntity.class;
protected DataManager<DeploymentEntity> getDataManager() {
return deploymentDataManager;
}
@Override
public void insert(DeploymentEntity deployment) {
getDbSqlSession().insert(deployment);
insert(deployment, false);
for (ResourceEntity resource : deployment.getResources().values()) {
resource.setDeploymentId(deployment.getId());
......@@ -58,12 +71,12 @@ public class DeploymentEntityManagerImpl extends AbstractEntityManager<Deploymen
@Override
public void deleteDeployment(String deploymentId, boolean cascade) {
List<ProcessDefinition> processDefinitions = getDbSqlSession().createProcessDefinitionQuery().deploymentId(deploymentId).list();
List<ProcessDefinition> processDefinitions = new ProcessDefinitionQueryImpl().deploymentId(deploymentId).list();
// Remove the deployment link from any model.
// The model will still exists, as a model is a source for a deployment
// model and has a different lifecycle
List<Model> models = getDbSqlSession().createModelQueryImpl().deploymentId(deploymentId).list();
List<Model> models = new ModelQueryImpl().deploymentId(deploymentId).list();
for (Model model : models) {
ModelEntity modelEntity = (ModelEntity) model;
modelEntity.setDeploymentId(null);
......@@ -102,7 +115,7 @@ public class DeploymentEntityManagerImpl extends AbstractEntityManager<Deploymen
if (timerStartJobs != null && timerStartJobs.size() > 0) {
for (Job timerStartJob : timerStartJobs) {
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.JOB_CANCELED, timerStartJob, null, null, processDefinition.getId()));
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.JOB_CANCELED, timerStartJob, null, null, processDefinition.getId()));
}
getJobEntityManager().delete((JobEntity) timerStartJob);
......@@ -180,44 +193,47 @@ public class DeploymentEntityManagerImpl extends AbstractEntityManager<Deploymen
getResourceEntityManager().deleteResourcesByDeploymentId(deploymentId);
getDbSqlSession().delete("deleteDeployment", deploymentId);
delete(findById(deploymentId), false);
}
@Override
public DeploymentEntity findLatestDeploymentByName(String deploymentName) {
List<?> list = getDbSqlSession().selectList("selectDeploymentsByName", deploymentName, 0, 1);
if (list != null && !list.isEmpty()) {
return (DeploymentEntity) list.get(0);
}
return null;
return deploymentDataManager.findLatestDeploymentByName(deploymentName);
}
@Override
public long findDeploymentCountByQueryCriteria(DeploymentQueryImpl deploymentQuery) {
return (Long) getDbSqlSession().selectOne("selectDeploymentCountByQueryCriteria", deploymentQuery);
return deploymentDataManager.findDeploymentCountByQueryCriteria(deploymentQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<Deployment> findDeploymentsByQueryCriteria(DeploymentQueryImpl deploymentQuery, Page page) {
final String query = "selectDeploymentsByQueryCriteria";
return getDbSqlSession().selectList(query, deploymentQuery, page);
return deploymentDataManager.findDeploymentsByQueryCriteria(deploymentQuery, page);
}
@Override
public List<String> getDeploymentResourceNames(String deploymentId) {
return getDbSqlSession().getSqlSession().selectList("selectResourceNamesByDeploymentId", deploymentId);
return deploymentDataManager.getDeploymentResourceNames(deploymentId);
}
@Override
@SuppressWarnings("unchecked")
public List<Deployment> findDeploymentsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectDeploymentByNativeQuery", parameterMap, firstResult, maxResults);
return deploymentDataManager.findDeploymentsByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findDeploymentCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectDeploymentCountByNativeQuery", parameterMap);
return deploymentDataManager.findDeploymentCountByNativeQuery(parameterMap);
}
public DeploymentDataManager getDeploymentDataManager() {
return deploymentDataManager;
}
public void setDeploymentDataManager(DeploymentDataManager deploymentDataManager) {
this.deploymentDataManager = deploymentDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/EntityManager.java
浏览文件 @ 240fa4dd
......@@ -12,37 +12,23 @@
*/
package org.activiti.engine.impl.persistence.entity;
import java.util.List;
import org.activiti.engine.impl.db.Entity;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
/**
* @author Joram Barrez
*/
public interface EntityManager<EntityImpl extends Entity> {
EntityImpl findById(String entityId);
void insert(EntityImpl entity);
void insert(EntityImpl entity, boolean fireCreateEvent);
EntityImpl findById(String entityId);
EntityImpl findByQuery(String selectQuery, Object parameter, CachedEntityMatcher<EntityImpl> cachedEntityMatcher);
/**
* Gets a list by querying the database and the cache using {@link CachedEntityMatcher}.
* First, the entities are fetched from the database using the provided query.
* The cache is then queried for the entities of the same type. If an entity matches
* the {@link CachedEntityMatcher} condition, it replaces the entity from the database (as it is newer).
*
* @param dbQueryName The query name that needs to be executed.
* @param parameter The parameters for the query.
* @param entityMatcher The matcher used to determine which entities from the cache needs to be retained
* @param checkCache If false, no cache check will be done, and the returned list will simply be the list from the database.
*/
List<EntityImpl> getList(String dbQueryName, Object parameter, CachedEntityMatcher<EntityImpl> entityMatcher, boolean checkCache);
EntityImpl update(EntityImpl entity);
EntityImpl update(EntityImpl entity, boolean fireUpdateEvent);
void delete(String id);
void delete(EntityImpl entity);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/EventLogEntryEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,50 +13,58 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.event.EventLogEntry;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.EventLogEntryDataManager;
/**
* @author Joram Barrez
*/
public class EventLogEntryEntityManagerImpl extends AbstractEntityManager<EventLogEntryEntity> implements EventLogEntryEntityManager {
protected EventLogEntryDataManager eventLogEntryDataManager;
public EventLogEntryEntityManagerImpl() {
}
public EventLogEntryEntityManagerImpl(EventLogEntryDataManager eventLogEntryDataManager) {
this.eventLogEntryDataManager = eventLogEntryDataManager;
}
@Override
public Class<EventLogEntryEntity> getManagedEntity() {
return EventLogEntryEntity.class;
protected DataManager<EventLogEntryEntity> getDataManager() {
return eventLogEntryDataManager;
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findAllEventLogEntries() {
return getDbSqlSession().selectList("selectAllEventLogEntries");
return eventLogEntryDataManager.findAllEventLogEntries();
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findEventLogEntries(long startLogNr, long pageSize) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("startLogNr", startLogNr);
if (pageSize > 0) {
params.put("endLogNr", startLogNr + pageSize + 1);
}
return getDbSqlSession().selectList("selectEventLogEntries", params);
return eventLogEntryDataManager.findEventLogEntries(startLogNr, pageSize);
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findEventLogEntriesByProcessInstanceId(String processInstanceId) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("processInstanceId", processInstanceId);
return getDbSqlSession().selectList("selectEventLogEntriesByProcessInstanceId", params);
return eventLogEntryDataManager.findEventLogEntriesByProcessInstanceId(processInstanceId);
}
@Override
public void deleteEventLogEntry(long logNr) {
getDbSqlSession().getSqlSession().delete("deleteEventLogEntry", logNr);
eventLogEntryDataManager.deleteEventLogEntry(logNr);
}
public EventLogEntryDataManager getEventLogEntryDataManager() {
return eventLogEntryDataManager;
}
public void setEventLogEntryDataManager(EventLogEntryDataManager eventLogEntryDataManager) {
this.eventLogEntryDataManager = eventLogEntryDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/EventSubscriptionEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -14,12 +14,9 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.bpmn.model.MessageEventDefinition;
import org.activiti.bpmn.model.Signal;
......@@ -30,8 +27,8 @@ import org.activiti.engine.impl.EventSubscriptionQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.event.EventHandler;
import org.activiti.engine.impl.jobexecutor.ProcessEventJobHandler;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.apache.commons.lang3.StringUtils;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.EventSubscriptionDataManager;
/**
* @author Joram Barrez
......@@ -39,26 +36,21 @@ import org.apache.commons.lang3.StringUtils;
*/
public class EventSubscriptionEntityManagerImpl extends AbstractEntityManager<EventSubscriptionEntity> implements EventSubscriptionEntityManager {
@SuppressWarnings("unchecked")
private static final List<Class<? extends EventSubscriptionEntity>> ENTITY_SUBCLASSES =
Arrays.asList(MessageEventSubscriptionEntity.class, SignalEventSubscriptionEntity.class, CompensateEventSubscriptionEntity.class);
protected EventSubscriptionDataManager eventSubscriptionDataManager;
@Override
public Class<EventSubscriptionEntity> getManagedEntity() {
return EventSubscriptionEntity.class;
public EventSubscriptionEntityManagerImpl() {
}
@Override
public List<Class<? extends EventSubscriptionEntity>> getManagedEntitySubClasses() {
return ENTITY_SUBCLASSES;
public EventSubscriptionEntityManagerImpl(EventSubscriptionDataManager eventSubscriptionDataManager) {
this.eventSubscriptionDataManager = eventSubscriptionDataManager;
}
@Override
public void insert(EventSubscriptionEntity eventSubScriptionEntity) {
super.insert(eventSubScriptionEntity);
addToExecution(eventSubScriptionEntity);
protected DataManager<EventSubscriptionEntity> getDataManager() {
return eventSubscriptionDataManager;
}
@Override
public SignalEventSubscriptionEntity insertSignalEvent(SignalEventDefinition signalEventDefinition, Signal signal, ExecutionEntity execution) {
SignalEventSubscriptionEntity subscriptionEntity = new SignalEventSubscriptionEntity();
......@@ -149,230 +141,83 @@ public class EventSubscriptionEntityManagerImpl extends AbstractEntityManager<Ev
@Override
public long findEventSubscriptionCountByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl) {
final String query = "selectEventSubscriptionCountByQueryCriteria";
return (Long) getDbSqlSession().selectOne(query, eventSubscriptionQueryImpl);
return eventSubscriptionDataManager.findEventSubscriptionCountByQueryCriteria(eventSubscriptionQueryImpl);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl, Page page) {
final String query = "selectEventSubscriptionByQueryCriteria";
return getDbSqlSession().selectList(query, eventSubscriptionQueryImpl, page);
return eventSubscriptionDataManager.findEventSubscriptionsByQueryCriteria(eventSubscriptionQueryImpl, page);
}
@Override
public List<MessageEventSubscriptionEntity> findMessageEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName) {
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventName", eventName);
return toMessageEventSubscriptionEntityList(getList("selectMessageEventSubscriptionsByProcessInstanceAndEventName", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(MessageEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId);
}
}, true));
public List<MessageEventSubscriptionEntity> findMessageEventSubscriptionsByProcessInstanceAndEventName(String processInstanceId, String eventName) {
return eventSubscriptionDataManager.findMessageEventSubscriptionsByProcessInstanceAndEventName(processInstanceId, eventName);
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByEventName(final String eventName, final String tenantId) {
final String query = "selectSignalEventSubscriptionsByEventName";
final Map<String, String> params = new HashMap<String, String>();
params.put("eventName", eventName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
List<EventSubscriptionEntity> result = getList(query, params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& (eventSubscriptionEntity.getExecutionId() == null || (eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecution() != null && eventSubscriptionEntity.getExecution().getSuspensionState() == SuspensionState.ACTIVE.getStateCode()) )
&& ( (params.containsKey("tenantId") && tenantId.equals(eventSubscriptionEntity.getTenantId())) || (!params.containsKey("tenantId") && StringUtils.isEmpty(eventSubscriptionEntity.getTenantId())) );
}
}, true);
return toSignalEventSubscriptionEntityList(result);
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByEventName(String eventName, String tenantId) {
return eventSubscriptionDataManager.findSignalEventSubscriptionsByEventName(eventName, tenantId);
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName) {
final String query = "selectSignalEventSubscriptionsByProcessInstanceAndEventName";
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventName", eventName);
return toSignalEventSubscriptionEntityList(getList(query, params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId);
}
}, true));
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByProcessInstanceAndEventName(String processInstanceId, String eventName) {
return eventSubscriptionDataManager.findSignalEventSubscriptionsByProcessInstanceAndEventName(processInstanceId, eventName);
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByExecution(final String executionId) {
return toSignalEventSubscriptionEntityList(getList("selectSignalEventSubscriptionsByExecution", executionId, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true));
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByExecution(String executionId) {
return eventSubscriptionDataManager.findSignalEventSubscriptionsByExecution(executionId);
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByNameAndExecution(final String name, final String executionId) {
Map<String, String> params = new HashMap<String, String>();
params.put("executionId", executionId);
params.put("eventName", name);
return toSignalEventSubscriptionEntityList(getList("selectSignalEventSubscriptionsByNameAndExecution", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(name);
}
}, true));
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByNameAndExecution(String name, String executionId) {
return eventSubscriptionDataManager.findSignalEventSubscriptionsByNameAndExecution(name, executionId);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByExecutionAndType(final String executionId, final String type) {
Map<String, String> params = new HashMap<String, String>();
params.put("executionId", executionId);
params.put("eventType", type);
return getList("selectEventSubscriptionsByExecutionAndType", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true);
return eventSubscriptionDataManager.findEventSubscriptionsByExecutionAndType(executionId, type);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByProcessInstanceAndActivityId(final String processInstanceId, final String activityId, final String type) {
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventType", type);
params.put("activityId", activityId);
return getList("selectEventSubscriptionsByProcessInstanceTypeAndActivity", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId)
&& eventSubscriptionEntity.getActivityId() != null && eventSubscriptionEntity.getActivityId().equals(activityId);
}
}, true);
public List<EventSubscriptionEntity> findEventSubscriptionsByProcessInstanceAndActivityId(String processInstanceId, String activityId, String type) {
return eventSubscriptionDataManager.findEventSubscriptionsByProcessInstanceAndActivityId(processInstanceId, activityId, type);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByExecution(final String executionId) {
return getList("selectEventSubscriptionsByExecution", executionId, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true);
return eventSubscriptionDataManager.findEventSubscriptionsByExecution(executionId);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByConfiguration(String type, String configuration, String tenantId) {
final String query = "selectEventSubscriptionsByConfiguration";
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("configuration", configuration);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
return getDbSqlSession().selectList(query, params);
return eventSubscriptionDataManager.findEventSubscriptionsByConfiguration(type, configuration, tenantId);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByName(final String type, final String eventName, final String tenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("eventName", eventName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
return getList("selectEventSubscriptionsByName", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
if (eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)) {
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
return eventSubscriptionEntity.getTenantId() != null && eventSubscriptionEntity.getTenantId().equals(tenantId);
} else {
return ProcessEngineConfiguration.NO_TENANT_ID.equals(eventSubscriptionEntity.getTenantId()) || eventSubscriptionEntity.getTenantId() == null;
}
}
return false;
}
}, true);
public List<EventSubscriptionEntity> findEventSubscriptionsByName(String type, String eventName, String tenantId) {
return eventSubscriptionDataManager.findEventSubscriptionsByName(type, eventName, tenantId);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByNameAndExecution(String type, String eventName, String executionId) {
final String query = "selectEventSubscriptionsByNameAndExecution";
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("eventName", eventName);
params.put("executionId", executionId);
return getDbSqlSession().selectList(query, params);
return eventSubscriptionDataManager.findEventSubscriptionsByNameAndExecution(type, eventName, executionId);
}
@Override
public MessageEventSubscriptionEntity findMessageStartEventSubscriptionByName(String messageName, String tenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("eventName", messageName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
MessageEventSubscriptionEntity entity = (MessageEventSubscriptionEntity) getDbSqlSession().selectOne("selectMessageStartEventSubscriptionByName", params);
return entity;
return eventSubscriptionDataManager.findMessageStartEventSubscriptionByName(messageName, tenantId);
}
@Override
public void updateEventSubscriptionTenantId(String oldTenantId, String newTenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("oldTenantId", oldTenantId);
params.put("newTenantId", newTenantId);
getDbSqlSession().update("updateTenantIdOfEventSubscriptions", params);
eventSubscriptionDataManager.updateEventSubscriptionTenantId(oldTenantId, newTenantId);
}
@Override
public void deleteEventSubscriptionsForProcessDefinition(String processDefinitionId) {
eventSubscriptionDataManager.deleteEventSubscriptionsForProcessDefinition(processDefinitionId);
}
// Processing /////////////////////////////////////////////////////////////
......@@ -420,11 +265,6 @@ public class EventSubscriptionEntityManagerImpl extends AbstractEntityManager<Ev
getJobEntityManager().send(message);
}
@Override
public void deleteEventSubscriptionsForProcessDefinition(String processDefinitionId) {
getDbSqlSession().delete("deleteEventSubscriptionsForProcessDefinition", processDefinitionId);
}
protected List<SignalEventSubscriptionEntity> toSignalEventSubscriptionEntityList(List<EventSubscriptionEntity> result) {
List<SignalEventSubscriptionEntity> signalEventSubscriptionEntities = new ArrayList<SignalEventSubscriptionEntity>(result.size());
for (EventSubscriptionEntity eventSubscriptionEntity : result ) {
......@@ -440,6 +280,14 @@ public class EventSubscriptionEntityManagerImpl extends AbstractEntityManager<Ev
}
return messageEventSubscriptionEntities;
}
public EventSubscriptionDataManager getEventSubscriptionDataManager() {
return eventSubscriptionDataManager;
}
public void setEventSubscriptionDataManager(EventSubscriptionDataManager eventSubscriptionDataManager) {
this.eventSubscriptionDataManager = eventSubscriptionDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ExecutionEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -15,23 +15,21 @@ package org.activiti.engine.impl.persistence.entity;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.activiti.engine.ActivitiObjectNotFoundException;
import org.activiti.engine.ActivitiOptimisticLockingException;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.ExecutionQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.ProcessInstanceQueryImpl;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.ExecutionDataManager;
import org.activiti.engine.impl.util.tree.ExecutionTree;
import org.activiti.engine.impl.util.tree.ExecutionTreeNode;
import org.activiti.engine.impl.util.tree.ExecutionTreeUtil;
......@@ -48,93 +46,67 @@ import org.slf4j.LoggerFactory;
public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionEntity> implements ExecutionEntityManager {
private static final Logger logger = LoggerFactory.getLogger(ExecutionEntityManagerImpl.class);
protected ExecutionDataManager executionDataManager;
public ExecutionEntityManagerImpl() {
}
public ExecutionEntityManagerImpl(ExecutionDataManager executionDataManager) {
this.executionDataManager = executionDataManager;
}
@Override
public Class<ExecutionEntity> getManagedEntity() {
return ExecutionEntity.class;
protected DataManager<ExecutionEntity> getDataManager() {
return executionDataManager;
}
// FIND METHODS
@Override
public ExecutionEntity findSubProcessInstanceBySuperExecutionId(final String superExecutionId) {
return findByQuery("selectSubProcessInstanceBySuperExecutionId", superExecutionId, new CachedEntityMatcher<ExecutionEntity>() {
public boolean isRetained(ExecutionEntity executionEntity) {
return executionEntity.getSuperExecutionId() != null && superExecutionId.equals(executionEntity.getSuperExecutionId());
}
});
public ExecutionEntity findSubProcessInstanceBySuperExecutionId(String superExecutionId) {
return executionDataManager.findSubProcessInstanceBySuperExecutionId(superExecutionId);
}
@Override
public List<ExecutionEntity> findChildExecutionsByParentExecutionId(final String parentExecutionId) {
return getList("selectExecutionsByParentExecutionId", parentExecutionId, new CachedEntityMatcher<ExecutionEntity>() {
@Override
public boolean isRetained(ExecutionEntity entity) {
return entity.getParentId() != null && entity.getParentId().equals(parentExecutionId);
}
}, true);
public List<ExecutionEntity> findChildExecutionsByParentExecutionId(String parentExecutionId) {
return executionDataManager.findChildExecutionsByParentExecutionId(parentExecutionId);
}
@Override
public List<ExecutionEntity> findChildExecutionsByProcessInstanceId(final String processInstanceId) {
return getList("selectChildExecutionsByProcessInstanceId", processInstanceId, new CachedEntityMatcher<ExecutionEntity>() {
@Override
public boolean isRetained(ExecutionEntity executionEntity) {
return executionEntity.getProcessInstanceId() != null && executionEntity.getProcessInstanceId().equals(processInstanceId) && executionEntity.getParentId() != null;
}
}, true);
public List<ExecutionEntity> findChildExecutionsByProcessInstanceId(String processInstanceId) {
return executionDataManager.findChildExecutionsByProcessInstanceId(processInstanceId);
}
@Override
public List<ExecutionEntity> findExecutionsByParentExecutionAndActivityIds(final String parentExecutionId, final Collection<String> activityIds) {
Map<String, Object> parameters = new HashMap<String, Object>(2);
parameters.put("parentExecutionId", parentExecutionId);
parameters.put("activityIds", activityIds);
return getList("selectExecutionsByParentExecutionAndActivityIds", parameters, new CachedEntityMatcher<ExecutionEntity>() {
public boolean isRetained(ExecutionEntity executionEntity) {
return executionEntity.getParentId() != null && executionEntity.getParentId().equals(parentExecutionId)
&& executionEntity.getActivityId() != null && activityIds.contains(executionEntity.getActivityId());
}
}, true);
return executionDataManager.findExecutionsByParentExecutionAndActivityIds(parentExecutionId, activityIds);
}
@Override
public long findExecutionCountByQueryCriteria(ExecutionQueryImpl executionQuery) {
return (Long) getDbSqlSession().selectOne("selectExecutionCountByQueryCriteria", executionQuery);
return executionDataManager.findExecutionCountByQueryCriteria(executionQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<ExecutionEntity> findExecutionsByQueryCriteria(ExecutionQueryImpl executionQuery, Page page) {
return getDbSqlSession().selectList("selectExecutionsByQueryCriteria", executionQuery, page);
return executionDataManager.findExecutionsByQueryCriteria(executionQuery, page);
}
@Override
public long findProcessInstanceCountByQueryCriteria(ProcessInstanceQueryImpl executionQuery) {
return (Long) getDbSqlSession().selectOne("selectProcessInstanceCountByQueryCriteria", executionQuery);
return executionDataManager.findProcessInstanceCountByQueryCriteria(executionQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<ProcessInstance> findProcessInstanceByQueryCriteria(ProcessInstanceQueryImpl executionQuery) {
return getDbSqlSession().selectList("selectProcessInstanceByQueryCriteria", executionQuery);
return executionDataManager.findProcessInstanceByQueryCriteria(executionQuery);
}
@Override
public ExecutionTree findExecutionTree(final String rootProcessInstanceId) {
List<ExecutionEntity> executions = getList("selectExecutionsByRootProcessInstanceId", rootProcessInstanceId, new CachedEntityMatcher<ExecutionEntity>() {
@Override
public boolean isRetained(ExecutionEntity entity) {
return entity.getRootProcessInstanceId() != null && entity.getRootProcessInstanceId().equals(rootProcessInstanceId);
}
}, true);
return ExecutionTreeUtil.buildExecutionTree(executions);
public ExecutionTree findExecutionTree(String rootProcessInstanceId) {
return ExecutionTreeUtil.buildExecutionTree(executionDataManager.findExecutionsByRootProcessInstanceId(rootProcessInstanceId));
}
/**
......@@ -142,113 +114,47 @@ public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionE
* (i.e. does not treat the id as the root process instance id and fetches everything for that root process instance id)
*/
protected ExecutionTree findExecutionTreeInCurrentProcessInstance(final String processInstanceId) {
List<ExecutionEntity> executions = getList("selectExecutionsByProcessInstanceId", processInstanceId, new CachedEntityMatcher<ExecutionEntity>() {
@Override
public boolean isRetained(ExecutionEntity entity) {
return entity.getProcessInstanceId() != null && entity.getProcessInstanceId().equals(processInstanceId);
}
}, true);
return ExecutionTreeUtil.buildExecutionTreeForProcessInstance(executions);
}
return ExecutionTreeUtil.buildExecutionTreeForProcessInstance(executionDataManager.findExecutionsByProcessInstanceId(processInstanceId));
}
@Override
@SuppressWarnings("unchecked")
public List<ProcessInstance> findProcessInstanceAndVariablesByQueryCriteria(ProcessInstanceQueryImpl executionQuery) {
// paging doesn't work for combining process instances and variables due
// to an outer join, so doing it in-memory
if (executionQuery.getFirstResult() < 0 || executionQuery.getMaxResults() <= 0) {
return Collections.EMPTY_LIST;
}
int firstResult = executionQuery.getFirstResult();
int maxResults = executionQuery.getMaxResults();
// setting max results, limit to 20000 results for performance reasons
executionQuery.setMaxResults(20000);
executionQuery.setFirstResult(0);
List<ProcessInstance> instanceList = getDbSqlSession().selectListWithRawParameterWithoutFilter("selectProcessInstanceWithVariablesByQueryCriteria", executionQuery,
executionQuery.getFirstResult(), executionQuery.getMaxResults());
if (instanceList != null && !instanceList.isEmpty()) {
if (firstResult > 0) {
if (firstResult <= instanceList.size()) {
int toIndex = firstResult + Math.min(maxResults, instanceList.size() - firstResult);
return instanceList.subList(firstResult, toIndex);
} else {
return Collections.EMPTY_LIST;
}
} else {
int toIndex = Math.min(maxResults, instanceList.size());
return instanceList.subList(0, toIndex);
}
}
return Collections.EMPTY_LIST;
return executionDataManager.findProcessInstanceAndVariablesByQueryCriteria(executionQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<ExecutionEntity> findEventScopeExecutionsByActivityId(String activityRef, String parentExecutionId) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("activityId", activityRef);
parameters.put("parentExecutionId", parentExecutionId);
return getDbSqlSession().selectList("selectExecutionsByParentExecutionId", parameters);
return executionDataManager.findEventScopeExecutionsByActivityId(activityRef, parentExecutionId);
}
@Override
public Collection<ExecutionEntity> findInactiveExecutionsByActivityId(final String activityId) {
HashMap<String, Object> params = new HashMap<String, Object>(2);
params.put("activityId", activityId);
params.put("isActive", false);
return getList("selectInactiveExecutionsInActivity", params, new CachedEntityMatcher<ExecutionEntity>() {
public boolean isRetained(ExecutionEntity entity) {
return !entity.isActive() && entity.getActivityId() != null && entity.getActivityId().equals(activityId);
}
}, true);
return executionDataManager.findInactiveExecutionsByActivityId(activityId);
}
@Override
public Collection<ExecutionEntity> findInactiveExecutionsByProcessInstanceId(final String processInstanceId) {
HashMap<String, Object> params = new HashMap<String, Object>(2);
params.put("processInstanceId", processInstanceId);
params.put("isActive", false);
return getList("selectInactiveExecutionsForProcessInstance", params, new CachedEntityMatcher<ExecutionEntity>() {
public boolean isRetained(ExecutionEntity executionEntity) {
return executionEntity.getProcessInstanceId() != null && executionEntity.getProcessInstanceId().equals(processInstanceId) && !executionEntity.isActive();
}
}, true);
return executionDataManager.findInactiveExecutionsByProcessInstanceId(processInstanceId);
}
@Override
public Collection<ExecutionEntity> findInactiveExecutionsByActivityIdAndProcessInstanceId(final String activityId, final String processInstanceId) {
HashMap<String, Object> params = new HashMap<String, Object>(3);
params.put("activityId", activityId);
params.put("processInstanceId", processInstanceId);
params.put("isActive", false);
return getList("selectInactiveExecutionsInActivityAndProcessInstance", params, new CachedEntityMatcher<ExecutionEntity>() {
public boolean isRetained(ExecutionEntity executionEntity) {
return executionEntity.getProcessInstanceId() != null && executionEntity.getProcessInstanceId().equals(processInstanceId) && !executionEntity.isActive() &&
executionEntity.getActivityId() != null && executionEntity.getActivityId().equals(activityId);
}
}, true);
return executionDataManager.findInactiveExecutionsByActivityIdAndProcessInstanceId(activityId, processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Execution> findExecutionsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectExecutionByNativeQuery", parameterMap, firstResult, maxResults);
return executionDataManager.findExecutionsByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
@SuppressWarnings("unchecked")
public List<ProcessInstance> findProcessInstanceByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectExecutionByNativeQuery", parameterMap, firstResult, maxResults);
return executionDataManager.findProcessInstanceByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findExecutionCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectExecutionCountByNativeQuery", parameterMap);
return executionDataManager.findExecutionCountByNativeQuery(parameterMap);
}
// CREATE METHODS
......@@ -267,7 +173,7 @@ public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionE
}
// Store in database
getExecutionEntityManager().insert(processInstanceExecution, false);
insert(processInstanceExecution, false);
// Need to be after insert, cause we need the id
String authenticatedUserId = Authentication.getAuthenticatedUserId();
......@@ -333,18 +239,14 @@ public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionE
@Override
public void updateExecutionTenantIdForDeployment(String deploymentId, String newTenantId) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("deploymentId", deploymentId);
params.put("tenantId", newTenantId);
getDbSqlSession().update("updateExecutionTenantIdForDeployment", params);
executionDataManager.updateExecutionTenantIdForDeployment(deploymentId, newTenantId);
}
// DELETE METHODS
@Override
@SuppressWarnings("unchecked")
public void deleteProcessInstancesByProcessDefinition(String processDefinitionId, String deleteReason, boolean cascade) {
List<String> processInstanceIds = getDbSqlSession().selectList("selectProcessInstanceIdsByProcessDefinitionId", processDefinitionId);
List<String> processInstanceIds = executionDataManager.findProcessInstanceIdsByProcessDefinitionId(processDefinitionId);
for (String processInstanceId : processInstanceIds) {
deleteProcessInstance(processInstanceId, deleteReason, cascade);
......@@ -536,27 +438,18 @@ public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionE
public void updateProcessInstanceLockTime(String processInstanceId) {
Date expirationTime = getClock().getCurrentTime();
int lockMillis = getAsyncExecutor().getAsyncJobLockTimeInMillis();
GregorianCalendar lockCal = new GregorianCalendar();
lockCal.setTime(expirationTime);
lockCal.add(Calendar.MILLISECOND, lockMillis);
Date lockDate = lockCal.getTime();
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("id", processInstanceId);
params.put("lockTime", lockCal.getTime());
params.put("expirationTime", expirationTime);
int result = getDbSqlSession().update("updateProcessInstanceLockTime", params);
if (result == 0) {
throw new ActivitiOptimisticLockingException("Could not lock process instance");
}
executionDataManager.updateProcessInstanceLockTime(processInstanceId, lockDate, expirationTime);
}
@Override
public void clearProcessInstanceLockTime(String processInstanceId) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("id", processInstanceId);
getDbSqlSession().update("clearProcessInstanceLockTime", params);
executionDataManager.clearProcessInstanceLockTime(processInstanceId);
}
@Override
......@@ -574,4 +467,12 @@ public class ExecutionEntityManagerImpl extends AbstractEntityManager<ExecutionE
return null;
}
public ExecutionDataManager getExecutionDataManager() {
return executionDataManager;
}
public void setExecutionDataManager(ExecutionDataManager executionDataManager) {
this.executionDataManager = executionDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/GroupEntityManager.java
浏览文件 @ 240fa4dd
......@@ -28,8 +28,6 @@ public interface GroupEntityManager extends EntityManager<GroupEntity> {
Group createNewGroup(String groupId);
void updateGroup(Group updatedGroup);
GroupQuery createNewGroupQuery();
List<Group> findGroupByQueryCriteria(GroupQueryImpl query, Page page);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/GroupEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -22,6 +22,8 @@ import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.GroupQuery;
import org.activiti.engine.impl.GroupQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.GroupDataManager;
/**
* @author Tom Baeyens
......@@ -29,39 +31,38 @@ import org.activiti.engine.impl.Page;
* @author Joram Barrez
*/
public class GroupEntityManagerImpl extends AbstractEntityManager<GroupEntity> implements GroupEntityManager {
protected GroupDataManager groupDataManager;
public GroupEntityManagerImpl() {
}
public GroupEntityManagerImpl(GroupDataManager groupDataManager) {
this.groupDataManager = groupDataManager;
}
@Override
public Class<GroupEntity> getManagedEntity() {
return GroupEntity.class;
protected DataManager<GroupEntity> getDataManager() {
return groupDataManager;
}
public Group createNewGroup(String groupId) {
return new GroupEntity(groupId);
}
public void updateGroup(Group updatedGroup) {
getDbSqlSession().update((GroupEntity) updatedGroup);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, updatedGroup));
}
}
@Override
public void delete(String groupId) {
GroupEntity group = getDbSqlSession().selectById(GroupEntity.class, groupId);
GroupEntity group = groupDataManager.findById(groupId);
if (group != null) {
getMembershipEntityManager().deleteMembershipByGroupId(groupId);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIPS_DELETED, groupId, null));
}
getDbSqlSession().delete("deleteMembershipsByGroupId", groupId);
getDbSqlSession().delete(group);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, group));
}
delete(group);
}
}
......@@ -69,27 +70,24 @@ public class GroupEntityManagerImpl extends AbstractEntityManager<GroupEntity> i
return new GroupQueryImpl(getCommandExecutor());
}
@SuppressWarnings("unchecked")
public List<Group> findGroupByQueryCriteria(GroupQueryImpl query, Page page) {
return getDbSqlSession().selectList("selectGroupByQueryCriteria", query, page);
return groupDataManager.findGroupByQueryCriteria(query, page);
}
public long findGroupCountByQueryCriteria(GroupQueryImpl query) {
return (Long) getDbSqlSession().selectOne("selectGroupCountByQueryCriteria", query);
return groupDataManager.findGroupCountByQueryCriteria(query);
}
@SuppressWarnings("unchecked")
public List<Group> findGroupsByUser(String userId) {
return getDbSqlSession().selectList("selectGroupsByUserId", userId);
return groupDataManager.findGroupsByUser(userId);
}
@SuppressWarnings("unchecked")
public List<Group> findGroupsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectGroupByNativeQuery", parameterMap, firstResult, maxResults);
return groupDataManager.findGroupsByNativeQuery(parameterMap, firstResult, maxResults);
}
public long findGroupCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectGroupCountByNativeQuery", parameterMap);
return groupDataManager.findGroupCountByNativeQuery(parameterMap);
}
@Override
......@@ -97,4 +95,12 @@ public class GroupEntityManagerImpl extends AbstractEntityManager<GroupEntity> i
return ((GroupEntity) group).getRevision() == 0;
}
public GroupDataManager getGroupDataManager() {
return groupDataManager;
}
public void setGroupDataManager(GroupDataManager groupDataManager) {
this.groupDataManager = groupDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricActivityInstanceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -20,39 +20,63 @@ import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.impl.HistoricActivityInstanceQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.history.HistoryLevel;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricActivityInstanceDataManager;
/**
* @author Tom Baeyens
* @author Joram Barrez
*/
public class HistoricActivityInstanceEntityManagerImpl extends AbstractEntityManager<HistoricActivityInstanceEntity> implements HistoricActivityInstanceEntityManager {
protected HistoricActivityInstanceDataManager historicActivityInstanceDataManager;
public HistoricActivityInstanceEntityManagerImpl() {
}
public HistoricActivityInstanceEntityManagerImpl(HistoricActivityInstanceDataManager historicActivityInstanceDataManager) {
this.historicActivityInstanceDataManager = historicActivityInstanceDataManager;
}
@Override
protected DataManager<HistoricActivityInstanceEntity> getDataManager() {
return historicActivityInstanceDataManager;
}
@Override
public void deleteHistoricActivityInstancesByProcessInstanceId(String historicProcessInstanceId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
getDbSqlSession().delete("deleteHistoricActivityInstancesByProcessInstanceId", historicProcessInstanceId);
historicActivityInstanceDataManager.deleteHistoricActivityInstancesByProcessInstanceId(historicProcessInstanceId);
}
}
@Override
public long findHistoricActivityInstanceCountByQueryCriteria(HistoricActivityInstanceQueryImpl historicActivityInstanceQuery) {
return (Long) getDbSqlSession().selectOne("selectHistoricActivityInstanceCountByQueryCriteria", historicActivityInstanceQuery);
return historicActivityInstanceDataManager.findHistoricActivityInstanceCountByQueryCriteria(historicActivityInstanceQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricActivityInstance> findHistoricActivityInstancesByQueryCriteria(HistoricActivityInstanceQueryImpl historicActivityInstanceQuery, Page page) {
return getDbSqlSession().selectList("selectHistoricActivityInstancesByQueryCriteria", historicActivityInstanceQuery, page);
return historicActivityInstanceDataManager.findHistoricActivityInstancesByQueryCriteria(historicActivityInstanceQuery, page);
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricActivityInstance> findHistoricActivityInstancesByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectHistoricActivityInstanceByNativeQuery", parameterMap, firstResult, maxResults);
return historicActivityInstanceDataManager.findHistoricActivityInstancesByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findHistoricActivityInstanceCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectHistoricActivityInstanceCountByNativeQuery", parameterMap);
return historicActivityInstanceDataManager.findHistoricActivityInstanceCountByNativeQuery(parameterMap);
}
public HistoricActivityInstanceDataManager getHistoricActivityInstanceDataManager() {
return historicActivityInstanceDataManager;
}
public void setHistoricActivityInstanceDataManager(HistoricActivityInstanceDataManager historicActivityInstanceDataManager) {
this.historicActivityInstanceDataManager = historicActivityInstanceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricDetailEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -20,6 +20,8 @@ import org.activiti.engine.history.HistoricDetail;
import org.activiti.engine.impl.HistoricDetailQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.history.HistoryLevel;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricDetailDataManager;
/**
* @author Tom Baeyens
......@@ -27,6 +29,21 @@ import org.activiti.engine.impl.history.HistoryLevel;
*/
public class HistoricDetailEntityManagerImpl extends AbstractEntityManager<HistoricDetailEntity> implements HistoricDetailEntityManager {
protected HistoricDetailDataManager historicDetailDataManager;
public HistoricDetailEntityManagerImpl() {
}
public HistoricDetailEntityManagerImpl(HistoricDetailDataManager historicDetailDataManager) {
this.historicDetailDataManager = historicDetailDataManager;
}
@Override
protected DataManager<HistoricDetailEntity> getDataManager() {
return historicDetailDataManager;
}
@Override
public HistoricFormPropertyEntity insertHistoricFormPropertyEntity(ExecutionEntity execution,
String propertyId, String propertyValue, String taskId) {
......@@ -45,7 +62,6 @@ public class HistoricDetailEntityManagerImpl extends AbstractEntityManager<Histo
}
insert(historicFormPropertyEntity);
return historicFormPropertyEntity;
}
......@@ -83,10 +99,9 @@ public class HistoricDetailEntityManagerImpl extends AbstractEntityManager<Histo
}
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public void deleteHistoricDetailsByProcessInstanceId(String historicProcessInstanceId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
List<HistoricDetailEntity> historicDetails = (List) getDbSqlSession().createHistoricDetailQuery().processInstanceId(historicProcessInstanceId).list();
List<HistoricDetailEntity> historicDetails = historicDetailDataManager.findHistoricDetailsByProcessInstanceId(historicProcessInstanceId);
for (HistoricDetailEntity historicDetail : historicDetails) {
delete(historicDetail);
......@@ -96,20 +111,18 @@ public class HistoricDetailEntityManagerImpl extends AbstractEntityManager<Histo
@Override
public long findHistoricDetailCountByQueryCriteria(HistoricDetailQueryImpl historicVariableUpdateQuery) {
return (Long) getDbSqlSession().selectOne("selectHistoricDetailCountByQueryCriteria", historicVariableUpdateQuery);
return historicDetailDataManager.findHistoricDetailCountByQueryCriteria(historicVariableUpdateQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricDetail> findHistoricDetailsByQueryCriteria(HistoricDetailQueryImpl historicVariableUpdateQuery, Page page) {
return getDbSqlSession().selectList("selectHistoricDetailsByQueryCriteria", historicVariableUpdateQuery, page);
return historicDetailDataManager.findHistoricDetailsByQueryCriteria(historicVariableUpdateQuery, page);
}
@Override
public void deleteHistoricDetailsByTaskId(String taskId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.FULL)) {
HistoricDetailQueryImpl detailsQuery = (HistoricDetailQueryImpl) new HistoricDetailQueryImpl().taskId(taskId);
List<HistoricDetail> details = detailsQuery.list();
List<HistoricDetailEntity> details = historicDetailDataManager.findHistoricDetailsByTaskId(taskId);
for (HistoricDetail detail : details) {
delete((HistoricDetailEntity) detail);
}
......@@ -117,13 +130,21 @@ public class HistoricDetailEntityManagerImpl extends AbstractEntityManager<Histo
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricDetail> findHistoricDetailsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectHistoricDetailByNativeQuery", parameterMap, firstResult, maxResults);
return historicDetailDataManager.findHistoricDetailsByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findHistoricDetailCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectHistoricDetailCountByNativeQuery", parameterMap);
return historicDetailDataManager.findHistoricDetailCountByNativeQuery(parameterMap);
}
public HistoricDetailDataManager getHistoricDetailDataManager() {
return historicDetailDataManager;
}
public void setHistoricDetailDataManager(HistoricDetailDataManager historicDetailDataManager) {
this.historicDetailDataManager = historicDetailDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricIdentityLinkEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -15,7 +15,8 @@ package org.activiti.engine.impl.persistence.entity;
import java.util.List;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricIdentityLinkDataManager;
/**
* @author Frederik Heremans
......@@ -23,21 +24,29 @@ import org.activiti.engine.impl.persistence.CachedEntityMatcher;
*/
public class HistoricIdentityLinkEntityManagerImpl extends AbstractEntityManager<HistoricIdentityLinkEntity> implements HistoricIdentityLinkEntityManager {
protected HistoricIdentityLinkDataManager historicIdentityLinkDataManager;
public HistoricIdentityLinkEntityManagerImpl() {
}
public HistoricIdentityLinkEntityManagerImpl(HistoricIdentityLinkDataManager historicIdentityLinkDataManager) {
this.historicIdentityLinkDataManager = historicIdentityLinkDataManager;
}
@Override
public Class<HistoricIdentityLinkEntity> getManagedEntity() {
return HistoricIdentityLinkEntity.class;
protected DataManager<HistoricIdentityLinkEntity> getDataManager() {
return historicIdentityLinkDataManager;
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricIdentityLinkEntity> findHistoricIdentityLinksByTaskId(String taskId) {
return getDbSqlSession().selectList("selectHistoricIdentityLinksByTask", taskId);
return historicIdentityLinkDataManager.findHistoricIdentityLinksByTaskId(taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricIdentityLinkEntity> findHistoricIdentityLinksByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectHistoricIdentityLinksByProcessInstance", processInstanceId);
return historicIdentityLinkDataManager.findHistoricIdentityLinksByProcessInstanceId(processInstanceId);
}
@Override
......@@ -51,14 +60,8 @@ public class HistoricIdentityLinkEntityManagerImpl extends AbstractEntityManager
@Override
public void deleteHistoricIdentityLinksByProcInstance(final String processInstanceId) {
List<HistoricIdentityLinkEntity> identityLinks = getList("selectHistoricIdentityLinksByProcessInstance", processInstanceId, new CachedEntityMatcher<HistoricIdentityLinkEntity>() {
@Override
public boolean isRetained(HistoricIdentityLinkEntity historicIdentityLinkEntity) {
return historicIdentityLinkEntity.getProcessInstanceId() != null && historicIdentityLinkEntity.getProcessInstanceId().equals(processInstanceId);
}
}, true);
List<HistoricIdentityLinkEntity> identityLinks = historicIdentityLinkDataManager
.findHistoricIdentityLinksByProcessInstanceId(processInstanceId);
for (HistoricIdentityLinkEntity identityLink : identityLinks) {
delete(identityLink);
......@@ -66,4 +69,12 @@ public class HistoricIdentityLinkEntityManagerImpl extends AbstractEntityManager
}
public HistoricIdentityLinkDataManager getHistoricIdentityLinkDataManager() {
return historicIdentityLinkDataManager;
}
public void setHistoricIdentityLinkDataManager(HistoricIdentityLinkDataManager historicIdentityLinkDataManager) {
this.historicIdentityLinkDataManager = historicIdentityLinkDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricProcessInstanceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -19,6 +19,8 @@ import java.util.Map;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.impl.HistoricProcessInstanceQueryImpl;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricProcessInstanceDataManager;
/**
* @author Tom Baeyens
......@@ -26,17 +28,25 @@ import org.activiti.engine.impl.HistoricProcessInstanceQueryImpl;
*/
public class HistoricProcessInstanceEntityManagerImpl extends AbstractEntityManager<HistoricProcessInstanceEntity> implements HistoricProcessInstanceEntityManager {
protected HistoricProcessInstanceDataManager historicProcessInstanceDataManager;
public HistoricProcessInstanceEntityManagerImpl() {
}
public HistoricProcessInstanceEntityManagerImpl(HistoricProcessInstanceDataManager historicProcessInstanceDataManager) {
this.historicProcessInstanceDataManager = historicProcessInstanceDataManager;
}
@Override
public Class<HistoricProcessInstanceEntity> getManagedEntity() {
return HistoricProcessInstanceEntity.class;
protected DataManager<HistoricProcessInstanceEntity> getDataManager() {
return historicProcessInstanceDataManager;
}
@Override
@SuppressWarnings("unchecked")
public void deleteHistoricProcessInstanceByProcessDefinitionId(String processDefinitionId) {
if (getHistoryManager().isHistoryEnabled()) {
List<String> historicProcessInstanceIds = getDbSqlSession().selectList("selectHistoricProcessInstanceIdsByProcessDefinitionId", processDefinitionId);
List<String> historicProcessInstanceIds = historicProcessInstanceDataManager.findHistoricProcessInstanceIdsByProcessDefinitionId(processDefinitionId);
for (String historicProcessInstanceId : historicProcessInstanceIds) {
delete(historicProcessInstanceId);
}
......@@ -55,15 +65,13 @@ public class HistoricProcessInstanceEntityManagerImpl extends AbstractEntityMana
getHistoricIdentityLinkEntityManager().deleteHistoricIdentityLinksByProcInstance(historicProcessInstanceId);
getCommentEntityManager().deleteCommentsByProcessInstanceId(historicProcessInstanceId);
getDbSqlSession().delete(historicProcessInstance);
delete(historicProcessInstance, false);
// Also delete any sub-processes that may be active (ACT-821)
HistoricProcessInstanceQueryImpl subProcessesQueryImpl = new HistoricProcessInstanceQueryImpl();
subProcessesQueryImpl.superProcessInstanceId(historicProcessInstanceId);
List<HistoricProcessInstance> selectList = getDbSqlSession().selectList("selectHistoricProcessInstancesByQueryCriteria", subProcessesQueryImpl);
for (HistoricProcessInstance child : selectList) {
delete(child.getId());
List<HistoricProcessInstanceEntity> selectList = historicProcessInstanceDataManager.findHistoricProcessInstancesBySuperProcessInstanceId(historicProcessInstanceId);
for (HistoricProcessInstanceEntity child : selectList) {
delete(child.getId()); // NEEDS to be by id, to come again through this method!
}
}
}
......@@ -71,7 +79,7 @@ public class HistoricProcessInstanceEntityManagerImpl extends AbstractEntityMana
@Override
public long findHistoricProcessInstanceCountByQueryCriteria(HistoricProcessInstanceQueryImpl historicProcessInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
return (Long) getDbSqlSession().selectOne("selectHistoricProcessInstanceCountByQueryCriteria", historicProcessInstanceQuery);
return historicProcessInstanceDataManager.findHistoricProcessInstanceCountByQueryCriteria(historicProcessInstanceQuery);
}
return 0;
}
......@@ -80,7 +88,7 @@ public class HistoricProcessInstanceEntityManagerImpl extends AbstractEntityMana
@SuppressWarnings("unchecked")
public List<HistoricProcessInstance> findHistoricProcessInstancesByQueryCriteria(HistoricProcessInstanceQueryImpl historicProcessInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
return getDbSqlSession().selectList("selectHistoricProcessInstancesByQueryCriteria", historicProcessInstanceQuery);
return historicProcessInstanceDataManager.findHistoricProcessInstancesByQueryCriteria(historicProcessInstanceQuery);
}
return Collections.EMPTY_LIST;
}
......@@ -89,47 +97,27 @@ public class HistoricProcessInstanceEntityManagerImpl extends AbstractEntityMana
@SuppressWarnings("unchecked")
public List<HistoricProcessInstance> findHistoricProcessInstancesAndVariablesByQueryCriteria(HistoricProcessInstanceQueryImpl historicProcessInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
// paging doesn't work for combining process instances and variables
// due to an outer join, so doing it in-memory
if (historicProcessInstanceQuery.getFirstResult() < 0 || historicProcessInstanceQuery.getMaxResults() <= 0) {
return Collections.EMPTY_LIST;
}
int firstResult = historicProcessInstanceQuery.getFirstResult();
int maxResults = historicProcessInstanceQuery.getMaxResults();
// setting max results, limit to 20000 results for performance reasons
historicProcessInstanceQuery.setMaxResults(20000);
historicProcessInstanceQuery.setFirstResult(0);
List<HistoricProcessInstance> instanceList = getDbSqlSession().selectListWithRawParameterWithoutFilter("selectHistoricProcessInstancesWithVariablesByQueryCriteria",
historicProcessInstanceQuery, historicProcessInstanceQuery.getFirstResult(), historicProcessInstanceQuery.getMaxResults());
if (instanceList != null && !instanceList.isEmpty()) {
if (firstResult > 0) {
if (firstResult <= instanceList.size()) {
int toIndex = firstResult + Math.min(maxResults, instanceList.size() - firstResult);
return instanceList.subList(firstResult, toIndex);
} else {
return Collections.EMPTY_LIST;
}
} else {
int toIndex = Math.min(maxResults, instanceList.size());
return instanceList.subList(0, toIndex);
}
}
return historicProcessInstanceDataManager.findHistoricProcessInstancesAndVariablesByQueryCriteria(historicProcessInstanceQuery);
}
return Collections.EMPTY_LIST;
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricProcessInstance> findHistoricProcessInstancesByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectHistoricProcessInstanceByNativeQuery", parameterMap, firstResult, maxResults);
return historicProcessInstanceDataManager.findHistoricProcessInstancesByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findHistoricProcessInstanceCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectHistoricProcessInstanceCountByNativeQuery", parameterMap);
return historicProcessInstanceDataManager.findHistoricProcessInstanceCountByNativeQuery(parameterMap);
}
public HistoricProcessInstanceDataManager getHistoricProcessInstanceDataManager() {
return historicProcessInstanceDataManager;
}
public void setHistoricProcessInstanceDataManager(HistoricProcessInstanceDataManager historicProcessInstanceDataManager) {
this.historicProcessInstanceDataManager = historicProcessInstanceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricTaskInstanceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -21,6 +21,8 @@ import org.activiti.engine.compatibility.Activiti5CompatibilityHandler;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.HistoricTaskInstanceQueryImpl;
import org.activiti.engine.impl.history.HistoryLevel;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricTaskInstanceDataManager;
import org.activiti.engine.impl.util.Activiti5Util;
/**
......@@ -29,18 +31,27 @@ import org.activiti.engine.impl.util.Activiti5Util;
*/
public class HistoricTaskInstanceEntityManagerImpl extends AbstractEntityManager<HistoricTaskInstanceEntity> implements HistoricTaskInstanceEntityManager {
protected HistoricTaskInstanceDataManager historicTaskInstanceDataManager;
public HistoricTaskInstanceEntityManagerImpl() {
}
public HistoricTaskInstanceEntityManagerImpl(HistoricTaskInstanceDataManager historicTaskInstanceDataManager) {
this.historicTaskInstanceDataManager = historicTaskInstanceDataManager;
}
@Override
public Class<HistoricTaskInstanceEntity> getManagedEntity() {
return HistoricTaskInstanceEntity.class;
protected DataManager<HistoricTaskInstanceEntity> getDataManager() {
return historicTaskInstanceDataManager;
}
@Override
@SuppressWarnings("unchecked")
public void deleteHistoricTaskInstancesByProcessInstanceId(String processInstanceId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
List<String> taskInstanceIds = (List<String>) getDbSqlSession().selectList("selectHistoricTaskInstanceIdsByProcessInstanceId", processInstanceId);
for (String taskInstanceId : taskInstanceIds) {
delete(taskInstanceId);
List<HistoricTaskInstanceEntity> taskInstances = historicTaskInstanceDataManager.findHistoricTaskInstanceByProcessInstanceId(processInstanceId);
for (HistoricTaskInstanceEntity historicTaskInstanceEntity : taskInstances) {
delete(historicTaskInstanceEntity.getId()); // Needs to be by id (since that method is overridden, see below !)
}
}
}
......@@ -48,7 +59,7 @@ public class HistoricTaskInstanceEntityManagerImpl extends AbstractEntityManager
@Override
public long findHistoricTaskInstanceCountByQueryCriteria(HistoricTaskInstanceQueryImpl historicTaskInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
return (Long) getDbSqlSession().selectOne("selectHistoricTaskInstanceCountByQueryCriteria", historicTaskInstanceQuery);
return historicTaskInstanceDataManager.findHistoricTaskInstanceCountByQueryCriteria(historicTaskInstanceQuery);
}
return 0;
}
......@@ -57,7 +68,7 @@ public class HistoricTaskInstanceEntityManagerImpl extends AbstractEntityManager
@SuppressWarnings("unchecked")
public List<HistoricTaskInstance> findHistoricTaskInstancesByQueryCriteria(HistoricTaskInstanceQueryImpl historicTaskInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
return getDbSqlSession().selectList("selectHistoricTaskInstancesByQueryCriteria", historicTaskInstanceQuery);
return historicTaskInstanceDataManager.findHistoricTaskInstancesByQueryCriteria(historicTaskInstanceQuery);
}
return Collections.EMPTY_LIST;
}
......@@ -66,36 +77,7 @@ public class HistoricTaskInstanceEntityManagerImpl extends AbstractEntityManager
@SuppressWarnings("unchecked")
public List<HistoricTaskInstance> findHistoricTaskInstancesAndVariablesByQueryCriteria(HistoricTaskInstanceQueryImpl historicTaskInstanceQuery) {
if (getHistoryManager().isHistoryEnabled()) {
// paging doesn't work for combining task instances and variables
// due to an outer join, so doing it in-memory
if (historicTaskInstanceQuery.getFirstResult() < 0 || historicTaskInstanceQuery.getMaxResults() <= 0) {
return Collections.EMPTY_LIST;
}
int firstResult = historicTaskInstanceQuery.getFirstResult();
int maxResults = historicTaskInstanceQuery.getMaxResults();
// setting max results, limit to 20000 results for performance
// reasons
historicTaskInstanceQuery.setMaxResults(20000);
historicTaskInstanceQuery.setFirstResult(0);
List<HistoricTaskInstance> instanceList = getDbSqlSession().selectListWithRawParameterWithoutFilter("selectHistoricTaskInstancesWithVariablesByQueryCriteria", historicTaskInstanceQuery,
historicTaskInstanceQuery.getFirstResult(), historicTaskInstanceQuery.getMaxResults());
if (instanceList != null && !instanceList.isEmpty()) {
if (firstResult > 0) {
if (firstResult <= instanceList.size()) {
int toIndex = firstResult + Math.min(maxResults, instanceList.size() - firstResult);
return instanceList.subList(firstResult, toIndex);
} else {
return Collections.EMPTY_LIST;
}
} else {
int toIndex = Math.min(maxResults, instanceList.size());
return instanceList.subList(0, toIndex);
}
}
return historicTaskInstanceDataManager.findHistoricTaskInstancesAndVariablesByQueryCriteria(historicTaskInstanceQuery);
}
return Collections.EMPTY_LIST;
}
......@@ -119,19 +101,27 @@ public class HistoricTaskInstanceEntityManagerImpl extends AbstractEntityManager
getAttachmentEntityManager().deleteAttachmentsByTaskId(id);
getHistoricIdentityLinkEntityManager().deleteHistoricIdentityLinksByTaskId(id);
getDbSqlSession().delete(historicTaskInstance);
delete(historicTaskInstance);
}
}
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricTaskInstance> findHistoricTaskInstancesByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectHistoricTaskInstanceByNativeQuery", parameterMap, firstResult, maxResults);
return historicTaskInstanceDataManager.findHistoricTaskInstancesByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findHistoricTaskInstanceCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectHistoricTaskInstanceCountByNativeQuery", parameterMap);
return historicTaskInstanceDataManager.findHistoricTaskInstanceCountByNativeQuery(parameterMap);
}
public HistoricTaskInstanceDataManager getHistoricTaskInstanceDataManager() {
return historicTaskInstanceDataManager;
}
public void setHistoricTaskInstanceDataManager(HistoricTaskInstanceDataManager historicTaskInstanceDataManager) {
this.historicTaskInstanceDataManager = historicTaskInstanceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricVariableInstanceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -21,7 +21,8 @@ import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.impl.HistoricVariableInstanceQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.history.HistoryLevel;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricVariableInstanceDataManager;
/**
* @author Christian Lipphardt (camunda)
......@@ -29,9 +30,19 @@ import org.activiti.engine.impl.persistence.CachedEntityMatcher;
*/
public class HistoricVariableInstanceEntityManagerImpl extends AbstractEntityManager<HistoricVariableInstanceEntity> implements HistoricVariableInstanceEntityManager {
protected HistoricVariableInstanceDataManager historicVariableInstanceDataManager;
public HistoricVariableInstanceEntityManagerImpl() {
}
public HistoricVariableInstanceEntityManagerImpl(HistoricVariableInstanceDataManager historicVariableInstanceDataManager) {
this.historicVariableInstanceDataManager = historicVariableInstanceDataManager;
}
@Override
public Class<HistoricVariableInstanceEntity> getManagedEntity() {
return HistoricVariableInstanceEntity.class;
protected DataManager<HistoricVariableInstanceEntity> getDataManager() {
return historicVariableInstanceDataManager;
}
@Override
......@@ -83,59 +94,56 @@ public class HistoricVariableInstanceEntityManagerImpl extends AbstractEntityMan
@Override
public void deleteHistoricVariableInstanceByProcessInstanceId(final String historicProcessInstanceId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
List<HistoricVariableInstanceEntity> historicProcessVariables = getList("selectHistoricVariableInstanceByProcessInstanceId",
historicProcessInstanceId, new CachedEntityMatcher<HistoricVariableInstanceEntity>() {
@Override
public boolean isRetained(HistoricVariableInstanceEntity historicVariableInstanceEntity) {
return historicVariableInstanceEntity.getProcessInstanceId() != null && historicVariableInstanceEntity.getProcessInstanceId().equals(historicProcessInstanceId);
}
}, true);
List<HistoricVariableInstanceEntity> historicProcessVariables = historicVariableInstanceDataManager.findHistoricVariableInstancesByProcessInstanceId(historicProcessInstanceId);
for (HistoricVariableInstanceEntity historicProcessVariable : historicProcessVariables) {
delete(historicProcessVariable);
}
}
}
@Override
public long findHistoricVariableInstanceCountByQueryCriteria(HistoricVariableInstanceQueryImpl historicProcessVariableQuery) {
return (Long) getDbSqlSession().selectOne("selectHistoricVariableInstanceCountByQueryCriteria", historicProcessVariableQuery);
return historicVariableInstanceDataManager.findHistoricVariableInstanceCountByQueryCriteria(historicProcessVariableQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricVariableInstance> findHistoricVariableInstancesByQueryCriteria(HistoricVariableInstanceQueryImpl historicProcessVariableQuery, Page page) {
return getDbSqlSession().selectList("selectHistoricVariableInstanceByQueryCriteria", historicProcessVariableQuery, page);
return historicVariableInstanceDataManager.findHistoricVariableInstancesByQueryCriteria(historicProcessVariableQuery, page);
}
@Override
public HistoricVariableInstanceEntity findHistoricVariableInstanceByVariableInstanceId(String variableInstanceId) {
return (HistoricVariableInstanceEntity) getDbSqlSession().selectOne("selectHistoricVariableInstanceByVariableInstanceId", variableInstanceId);
return historicVariableInstanceDataManager.findHistoricVariableInstanceByVariableInstanceId(variableInstanceId);
}
@Override
public void deleteHistoricVariableInstancesByTaskId(String taskId) {
if (getHistoryManager().isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
List<HistoricVariableInstance> historicProcessVariables = new HistoricVariableInstanceQueryImpl().taskId(taskId).list();
for (HistoricVariableInstance historicProcessVariable : historicProcessVariables) {
List<HistoricVariableInstanceEntity> historicProcessVariables = historicVariableInstanceDataManager.findHistoricVariableInstancesByTaskId(taskId);
for (HistoricVariableInstanceEntity historicProcessVariable : historicProcessVariables) {
delete((HistoricVariableInstanceEntity) historicProcessVariable);
}
}
}
@Override
@SuppressWarnings("unchecked")
public List<HistoricVariableInstance> findHistoricVariableInstancesByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectHistoricVariableInstanceByNativeQuery", parameterMap, firstResult, maxResults);
return historicVariableInstanceDataManager.findHistoricVariableInstancesByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findHistoricVariableInstanceCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectHistoricVariableInstanceCountByNativeQuery", parameterMap);
return historicVariableInstanceDataManager.findHistoricVariableInstanceCountByNativeQuery(parameterMap);
}
public HistoricVariableInstanceDataManager getHistoricVariableInstanceDataManager() {
return historicVariableInstanceDataManager;
}
public void setHistoricVariableInstanceDataManager(HistoricVariableInstanceDataManager historicVariableInstanceDataManager) {
this.historicVariableInstanceDataManager = historicVariableInstanceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/IdentityInfoEntityManager.java
浏览文件 @ 240fa4dd
......@@ -24,6 +24,8 @@ public interface IdentityInfoEntityManager extends EntityManager<IdentityInfoEnt
List<String> findUserInfoKeysByUserIdAndType(String userId, String type);
List<IdentityInfoEntity> findIdentityInfoByUserId(String userId);
void updateUserInfo(String userId, String userPassword, String type, String key, String value, String accountPassword, Map<String, String> accountDetails);
void deleteUserInfoByUserIdAndKey(String userId, String key);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/IdentityInfoEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -19,15 +19,28 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.IdentityInfoDataManager;
/**
* @author Tom Baeyens
* @author Joram Barrez
*/
public class IdentityInfoEntityManagerImpl extends AbstractEntityManager<IdentityInfoEntity> implements IdentityInfoEntityManager {
protected IdentityInfoDataManager identityInfoDataManager;
public IdentityInfoEntityManagerImpl() {
}
public IdentityInfoEntityManagerImpl(IdentityInfoDataManager identityInfoDataManager) {
this.identityInfoDataManager = identityInfoDataManager;
}
@Override
public Class<IdentityInfoEntity> getManagedEntity() {
return IdentityInfoEntity.class;
protected DataManager<IdentityInfoEntity> getDataManager() {
return identityInfoDataManager;
}
@Override
......@@ -38,10 +51,6 @@ public class IdentityInfoEntityManagerImpl extends AbstractEntityManager<Identit
}
}
protected List<IdentityInfoEntity> findIdentityInfoDetails(String identityInfoId) {
return getDbSqlSession().getSqlSession().selectList("selectIdentityInfoDetails", identityInfoId);
}
@Override
public void updateUserInfo(String userId, String userPassword, String type, String key, String value, String accountPassword, Map<String, String> accountDetails) {
byte[] storedPassword = null;
......@@ -60,7 +69,7 @@ public class IdentityInfoEntityManagerImpl extends AbstractEntityManager<Identit
}
Set<String> newKeys = new HashSet<String>(accountDetails.keySet());
List<IdentityInfoEntity> identityInfoDetails = findIdentityInfoDetails(identityInfoEntity.getId());
List<IdentityInfoEntity> identityInfoDetails = identityInfoDataManager.findIdentityInfoDetails(identityInfoEntity.getId());
for (IdentityInfoEntity identityInfoDetail : identityInfoDetails) {
String detailKey = identityInfoDetail.getKey();
newKeys.remove(detailKey);
......@@ -82,21 +91,21 @@ public class IdentityInfoEntityManagerImpl extends AbstractEntityManager<Identit
identityInfoEntity.setKey(key);
identityInfoEntity.setValue(value);
identityInfoEntity.setPasswordBytes(storedPassword);
getDbSqlSession().insert(identityInfoEntity);
insert(identityInfoEntity, false);
if (accountDetails != null) {
insertAccountDetails(identityInfoEntity, accountDetails, accountDetails.keySet());
}
}
}
private void insertAccountDetails(IdentityInfoEntity identityInfoEntity, Map<String, String> accountDetails, Set<String> keys) {
protected void insertAccountDetails(IdentityInfoEntity identityInfoEntity, Map<String, String> accountDetails, Set<String> keys) {
for (String newKey : keys) {
// insert detail
IdentityInfoEntity identityInfoDetail = new IdentityInfoEntity();
identityInfoDetail.setParentId(identityInfoEntity.getId());
identityInfoDetail.setKey(newKey);
identityInfoDetail.setValue(accountDetails.get(newKey));
getDbSqlSession().insert(identityInfoDetail);
insert(identityInfoDetail, false);
}
}
......@@ -110,18 +119,25 @@ public class IdentityInfoEntityManagerImpl extends AbstractEntityManager<Identit
@Override
public IdentityInfoEntity findUserInfoByUserIdAndKey(String userId, String key) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("userId", userId);
parameters.put("key", key);
return (IdentityInfoEntity) getDbSqlSession().selectOne("selectIdentityInfoByUserIdAndKey", parameters);
return identityInfoDataManager.findUserInfoByUserIdAndKey(userId, key);
}
@Override
public List<IdentityInfoEntity> findIdentityInfoByUserId(String userId) {
return identityInfoDataManager.findIdentityInfoByUserId(userId);
}
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public List<String> findUserInfoKeysByUserIdAndType(String userId, String type) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("userId", userId);
parameters.put("type", type);
return (List) getDbSqlSession().getSqlSession().selectList("selectIdentityInfoKeysByUserIdAndType", parameters);
return identityInfoDataManager.findUserInfoKeysByUserIdAndType(userId, type);
}
public IdentityInfoDataManager getIdentityInfoDataManager() {
return identityInfoDataManager;
}
public void setIdentityInfoDataManager(IdentityInfoDataManager identityInfoDataManager) {
this.identityInfoDataManager = identityInfoDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/IdentityLinkEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -15,12 +15,12 @@ package org.activiti.engine.impl.persistence.entity;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.IdentityLinkDataManager;
import org.activiti.engine.task.IdentityLinkType;
/**
......@@ -30,9 +30,19 @@ import org.activiti.engine.task.IdentityLinkType;
*/
public class IdentityLinkEntityManagerImpl extends AbstractEntityManager<IdentityLinkEntity> implements IdentityLinkEntityManager {
protected IdentityLinkDataManager identityLinkDataManager;
public IdentityLinkEntityManagerImpl() {
}
public IdentityLinkEntityManagerImpl(IdentityLinkDataManager identityLinkDataManager) {
this.identityLinkDataManager = identityLinkDataManager;
}
@Override
public Class<IdentityLinkEntity> getManagedEntity() {
return IdentityLinkEntity.class;
protected DataManager<IdentityLinkEntity> getDataManager() {
return identityLinkDataManager;
}
@Override
......@@ -43,7 +53,7 @@ public class IdentityLinkEntityManagerImpl extends AbstractEntityManager<Identit
@Override
public void deleteIdentityLink(IdentityLinkEntity identityLink, boolean cascadeHistory) {
getDbSqlSession().delete(identityLink);
delete(identityLink, false);
if (cascadeHistory) {
getHistoryManager().deleteHistoricIdentityLink(identityLink.getId());
}
......@@ -54,53 +64,33 @@ public class IdentityLinkEntityManagerImpl extends AbstractEntityManager<Identit
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinksByTaskId(String taskId) {
return getDbSqlSession().selectList("selectIdentityLinksByTask", taskId);
return identityLinkDataManager.findIdentityLinksByTaskId(taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinksByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectIdentityLinksByProcessInstance", processInstanceId);
return identityLinkDataManager.findIdentityLinksByProcessInstanceId(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinksByProcessDefinitionId(String processDefinitionId) {
return getDbSqlSession().selectList("selectIdentityLinksByProcessDefinition", processDefinitionId);
return identityLinkDataManager.findIdentityLinksByProcessDefinitionId(processDefinitionId);
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinkByTaskUserGroupAndType(String taskId, String userId, String groupId, String type) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("taskId", taskId);
parameters.put("userId", userId);
parameters.put("groupId", groupId);
parameters.put("type", type);
return getDbSqlSession().selectList("selectIdentityLinkByTaskUserGroupAndType", parameters);
return identityLinkDataManager.findIdentityLinkByTaskUserGroupAndType(taskId, userId, groupId, type);
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinkByProcessInstanceUserGroupAndType(String processInstanceId, String userId, String groupId, String type) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("processInstanceId", processInstanceId);
parameters.put("userId", userId);
parameters.put("groupId", groupId);
parameters.put("type", type);
return getDbSqlSession().selectList("selectIdentityLinkByProcessInstanceUserGroupAndType", parameters);
return identityLinkDataManager.findIdentityLinkByProcessInstanceUserGroupAndType(processInstanceId, userId, groupId, type);
}
@Override
@SuppressWarnings("unchecked")
public List<IdentityLinkEntity> findIdentityLinkByProcessDefinitionUserAndGroup(String processDefinitionId, String userId, String groupId) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("processDefinitionId", processDefinitionId);
parameters.put("userId", userId);
parameters.put("groupId", groupId);
return getDbSqlSession().selectList("selectIdentityLinkByProcessDefinitionUserAndGroup", parameters);
return identityLinkDataManager.findIdentityLinkByProcessDefinitionUserAndGroup(processDefinitionId, userId, groupId);
}
@Override
......@@ -233,9 +223,7 @@ public class IdentityLinkEntityManagerImpl extends AbstractEntityManager<Identit
@Override
public void deleteIdentityLink(ProcessDefinitionEntity processDefinitionEntity, String userId, String groupId) {
List<IdentityLinkEntity> identityLinks = getIdentityLinkEntityManager()
.findIdentityLinkByProcessDefinitionUserAndGroup(processDefinitionEntity.getId(), userId, groupId);
List<IdentityLinkEntity> identityLinks = findIdentityLinkByProcessDefinitionUserAndGroup(processDefinitionEntity.getId(), userId, groupId);
for (IdentityLinkEntity identityLink : identityLinks) {
deleteIdentityLink(identityLink, false);
}
......@@ -251,7 +239,15 @@ public class IdentityLinkEntityManagerImpl extends AbstractEntityManager<Identit
@Override
public void deleteIdentityLinksByProcDef(String processDefId) {
getDbSqlSession().delete("deleteIdentityLinkByProcDef", processDefId);
identityLinkDataManager.deleteIdentityLinksByProcDef(processDefId);
}
public IdentityLinkDataManager getIdentityLinkDataManager() {
return identityLinkDataManager;
}
public void setIdentityLinkDataManager(IdentityLinkDataManager identityLinkDataManager) {
this.identityLinkDataManager = identityLinkDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/JobEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -15,7 +15,6 @@ package org.activiti.engine.impl.persistence.entity;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
......@@ -42,7 +41,8 @@ import org.activiti.engine.impl.jobexecutor.JobAddedNotification;
import org.activiti.engine.impl.jobexecutor.JobHandler;
import org.activiti.engine.impl.jobexecutor.TimerEventHandler;
import org.activiti.engine.impl.jobexecutor.TimerStartEventJobHandler;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.JobDataManager;
import org.activiti.engine.impl.util.ProcessDefinitionUtil;
import org.activiti.engine.runtime.Job;
import org.slf4j.Logger;
......@@ -57,17 +57,19 @@ public class JobEntityManagerImpl extends AbstractEntityManager<JobEntity> imple
private static final Logger logger = LoggerFactory.getLogger(JobEntityManagerImpl.class);
@SuppressWarnings("unchecked")
protected static final List<Class<? extends JobEntity>> ENTITY_SUBCLASSES = Arrays.asList(TimerEntity.class, MessageEntity.class);
protected JobDataManager jobDataManager;
@Override
public Class<JobEntity> getManagedEntity() {
return JobEntity.class;
public JobEntityManagerImpl() {
}
public JobEntityManagerImpl(JobDataManager jobDataManager) {
this.jobDataManager = jobDataManager;
}
@Override
public List<Class<? extends JobEntity>> getManagedEntitySubClasses() {
return ENTITY_SUBCLASSES;
protected DataManager<JobEntity> getDataManager() {
return jobDataManager;
}
@Override
......@@ -130,7 +132,6 @@ public class JobEntityManagerImpl extends AbstractEntityManager<JobEntity> imple
insert(timer);
if (getProcessEngineConfiguration().isAsyncExecutorEnabled() == false && timer.getDuedate().getTime() <= (getClock().getCurrentTime().getTime())) {
hintJobExecutor(timer);
}
}
......@@ -163,123 +164,78 @@ public class JobEntityManagerImpl extends AbstractEntityManager<JobEntity> imple
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findNextJobsToExecute(Page page) {
Date now = getClock().getCurrentTime();
return getDbSqlSession().selectList("selectNextJobsToExecute", now, page);
return jobDataManager.findNextJobsToExecute(page);
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findNextTimerJobsToExecute(Page page) {
Date now = getClock().getCurrentTime();
return getDbSqlSession().selectList("selectNextTimerJobsToExecute", now, page);
return jobDataManager.findNextTimerJobsToExecute(page);
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findAsyncJobsDueToExecute(Page page) {
Date now = getClock().getCurrentTime();
return getDbSqlSession().selectList("selectAsyncJobsDueToExecute", now, page);
return jobDataManager.findAsyncJobsDueToExecute(page);
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findJobsByLockOwner(String lockOwner, int start, int maxNrOfJobs) {
return getDbSqlSession().selectList("selectJobsByLockOwner", lockOwner, start, maxNrOfJobs);
return jobDataManager.findJobsByLockOwner(lockOwner, start, maxNrOfJobs);
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findJobsByExecutionId(final String executionId) {
return getList("selectJobsByExecutionId", executionId, new CachedEntityMatcher<JobEntity>() {
@Override
public boolean isRetained(JobEntity jobEntity) {
return jobEntity.getExecutionId() != null && jobEntity.getExecutionId().equals(executionId);
}
}, true);
public List<JobEntity> findJobsByExecutionId(String executionId) {
return jobDataManager.findJobsByExecutionId(executionId);
}
@Override
@SuppressWarnings("unchecked")
public List<JobEntity> findExclusiveJobsToExecute(String processInstanceId) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("pid", processInstanceId);
params.put("now", getClock().getCurrentTime());
return getDbSqlSession().selectList("selectExclusiveJobsToExecute", params);
return jobDataManager.findExclusiveJobsToExecute(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<TimerEntity> findUnlockedTimersByDuedate(Date duedate, Page page) {
final String query = "selectUnlockedTimersByDuedate";
return getDbSqlSession().selectList(query, duedate, page);
return jobDataManager.findUnlockedTimersByDuedate(duedate, page);
}
@Override
@SuppressWarnings("unchecked")
public List<TimerEntity> findTimersByExecutionId(String executionId) {
return getDbSqlSession().selectList("selectTimersByExecutionId", executionId);
return jobDataManager.findTimersByExecutionId(executionId);
}
@Override
@SuppressWarnings("unchecked")
public List<Job> findJobsByQueryCriteria(JobQueryImpl jobQuery, Page page) {
final String query = "selectJobByQueryCriteria";
return getDbSqlSession().selectList(query, jobQuery, page);
return jobDataManager.findJobsByQueryCriteria(jobQuery, page);
}
@Override
@SuppressWarnings("unchecked")
public List<Job> findJobsByTypeAndProcessDefinitionIds(String jobHandlerType, List<String> processDefinitionIds) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("handlerType", jobHandlerType);
if (processDefinitionIds != null && processDefinitionIds.size() > 0) {
params.put("processDefinitionIds", processDefinitionIds);
}
return getDbSqlSession().selectList("selectJobsByTypeAndProcessDefinitionIds", params);
return jobDataManager.findJobsByTypeAndProcessDefinitionIds(jobHandlerType, processDefinitionIds);
}
@Override
@SuppressWarnings("unchecked")
public List<Job> findJobsByTypeAndProcessDefinitionKeyNoTenantId(String jobHandlerType, String processDefinitionKey) {
Map<String, String> params = new HashMap<String, String>(2);
params.put("handlerType", jobHandlerType);
params.put("processDefinitionKey", processDefinitionKey);
return getDbSqlSession().selectList("selectJobByTypeAndProcessDefinitionKeyNoTenantId", params);
return jobDataManager.findJobsByTypeAndProcessDefinitionKeyNoTenantId(jobHandlerType, processDefinitionKey);
}
@Override
@SuppressWarnings("unchecked")
public List<Job> findJobsByTypeAndProcessDefinitionKeyAndTenantId(String jobHandlerType, String processDefinitionKey, String tenantId) {
Map<String, String> params = new HashMap<String, String>(3);
params.put("handlerType", jobHandlerType);
params.put("processDefinitionKey", processDefinitionKey);
params.put("tenantId", tenantId);
return getDbSqlSession().selectList("selectJobByTypeAndProcessDefinitionKeyAndTenantId", params);
return jobDataManager.findJobsByTypeAndProcessDefinitionKeyAndTenantId(jobHandlerType, processDefinitionKey, tenantId);
}
@Override
@SuppressWarnings("unchecked")
public List<Job> findJobsByTypeAndProcessDefinitionId(String jobHandlerType, String processDefinitionId) {
Map<String, String> params = new HashMap<String, String>(2);
params.put("handlerType", jobHandlerType);
params.put("processDefinitionId", processDefinitionId);
return getDbSqlSession().selectList("selectJobByTypeAndProcessDefinitionId", params);
return jobDataManager.findJobsByTypeAndProcessDefinitionId(jobHandlerType, processDefinitionId);
}
@Override
public long findJobCountByQueryCriteria(JobQueryImpl jobQuery) {
return (Long) getDbSqlSession().selectOne("selectJobCountByQueryCriteria", jobQuery);
return jobDataManager.findJobCountByQueryCriteria(jobQuery);
}
@Override
public void updateJobTenantIdForDeployment(String deploymentId, String newTenantId) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("deploymentId", deploymentId);
params.put("tenantId", newTenantId);
getDbSqlSession().update("updateJobTenantIdForDeployment", params);
jobDataManager.updateJobTenantIdForDeployment(deploymentId, newTenantId);
}
@Override
......@@ -492,4 +448,12 @@ public class JobEntityManagerImpl extends AbstractEntityManager<JobEntity> imple
return businessCalendar.resolveDuedate(timerEntity.getRepeat(), timerEntity.getMaxIterations());
}
public JobDataManager getJobDataManager() {
return jobDataManager;
}
public void setJobDataManager(JobDataManager jobDataManager) {
this.jobDataManager = jobDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/MembershipEntityManager.java
浏览文件 @ 240fa4dd
......@@ -21,5 +21,9 @@ public interface MembershipEntityManager extends EntityManager<MembershipEntity>
void createMembership(String userId, String groupId);
void deleteMembership(String userId, String groupId);
void deleteMembershipByGroupId(String groupId);
void deleteMembershipByUserId(String userId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/MembershipEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,11 +13,10 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.Map;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.MembershipDataManager;
/**
* @author Tom Baeyens
......@@ -25,16 +24,26 @@ import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
*/
public class MembershipEntityManagerImpl extends AbstractEntityManager<MembershipEntity> implements MembershipEntityManager {
@Override
public Class<MembershipEntity> getManagedEntity() {
return MembershipEntity.class;
protected MembershipDataManager membershipDataManager;
public MembershipEntityManagerImpl() {
}
public MembershipEntityManagerImpl(MembershipDataManager membershipDataManager) {
this.membershipDataManager = membershipDataManager;
}
@Override
protected DataManager<MembershipEntity> getDataManager() {
return membershipDataManager;
}
public void createMembership(String userId, String groupId) {
MembershipEntity membershipEntity = new MembershipEntity();
membershipEntity.setUserId(userId);
membershipEntity.setGroupId(groupId);
getDbSqlSession().insert(membershipEntity);
insert(membershipEntity, false);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIP_CREATED, groupId, userId));
......@@ -42,14 +51,28 @@ public class MembershipEntityManagerImpl extends AbstractEntityManager<Membershi
}
public void deleteMembership(String userId, String groupId) {
Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("userId", userId);
parameters.put("groupId", groupId);
getDbSqlSession().delete("deleteMembership", parameters);
membershipDataManager.deleteMembership(userId, groupId);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIP_DELETED, groupId, userId));
}
}
@Override
public void deleteMembershipByGroupId(String groupId) {
membershipDataManager.deleteMembershipByGroupId(groupId);
}
@Override
public void deleteMembershipByUserId(String userId) {
membershipDataManager.deleteMembershipByUserId(userId);
}
public MembershipDataManager getMembershipDataManager() {
return membershipDataManager;
}
public void setMembershipDataManager(MembershipDataManager membershipDataManager) {
this.membershipDataManager = membershipDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ModelEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -16,10 +16,10 @@ package org.activiti.engine.impl.persistence.entity;
import java.util.List;
import java.util.Map;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.ModelQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.ModelDataManager;
import org.activiti.engine.repository.Model;
/**
......@@ -28,9 +28,24 @@ import org.activiti.engine.repository.Model;
*/
public class ModelEntityManagerImpl extends AbstractEntityManager<ModelEntity> implements ModelEntityManager {
protected ModelDataManager modelDataManager;
public ModelEntityManagerImpl() {
}
public ModelEntityManagerImpl(ModelDataManager modelDataManager) {
this.modelDataManager = modelDataManager;
}
@Override
protected DataManager<ModelEntity> getDataManager() {
return modelDataManager;
}
@Override
public Class<ModelEntity> getManagedEntity() {
return ModelEntity.class;
public ModelEntity findById(String entityId) {
return modelDataManager.findById(entityId);
}
@Override
......@@ -49,16 +64,12 @@ public class ModelEntityManagerImpl extends AbstractEntityManager<ModelEntity> i
@Override
public void updateModel(ModelEntity updatedModel) {
updatedModel.setLastUpdateTime(getClock().getCurrentTime());
getDbSqlSession().update(updatedModel);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, updatedModel));
}
update(updatedModel);
}
@Override
public void delete(String modelId) {
ModelEntity modelEntity = getDbSqlSession().selectById(ModelEntity.class, modelId);
ModelEntity modelEntity = findById(modelId);
super.delete(modelEntity);
deleteEditorSource(modelEntity);
deleteEditorSourceExtra(modelEntity);
......@@ -109,14 +120,13 @@ public class ModelEntityManagerImpl extends AbstractEntityManager<ModelEntity> i
}
@Override
@SuppressWarnings("unchecked")
public List<Model> findModelsByQueryCriteria(ModelQueryImpl query, Page page) {
return getDbSqlSession().selectList("selectModelsByQueryCriteria", query, page);
return modelDataManager.findModelsByQueryCriteria(query, page);
}
@Override
public long findModelCountByQueryCriteria(ModelQueryImpl query) {
return (Long) getDbSqlSession().selectOne("selectModelCountByQueryCriteria", query);
return modelDataManager.findModelCountByQueryCriteria(query);
}
@Override
......@@ -142,13 +152,21 @@ public class ModelEntityManagerImpl extends AbstractEntityManager<ModelEntity> i
}
@Override
@SuppressWarnings("unchecked")
public List<Model> findModelsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectModelByNativeQuery", parameterMap, firstResult, maxResults);
return modelDataManager.findModelsByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findModelCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectModelCountByNativeQuery", parameterMap);
return modelDataManager.findModelCountByNativeQuery(parameterMap);
}
public ModelDataManager getModelDataManager() {
return modelDataManager;
}
public void setModelDataManager(ModelDataManager modelDataManager) {
this.modelDataManager = modelDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ProcessDefinitionEntityManager.java
浏览文件 @ 240fa4dd
......@@ -36,7 +36,7 @@ public interface ProcessDefinitionEntityManager extends EntityManager<ProcessDef
ProcessDefinitionEntity findProcessDefinitionByDeploymentAndKeyAndTenantId(String deploymentId, String processDefinitionKey, String tenantId);
ProcessDefinition findProcessDefinitionByKeyAndVersion(String processDefinitionKey, Integer processDefinitionVersion);
ProcessDefinition findProcessDefinitionByKeyAndVersionAndTenantId(String processDefinitionKey, Integer processDefinitionVersion, String tenantId);
List<ProcessDefinition> findProcessDefinitionsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ProcessDefinitionEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,13 +13,13 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.ProcessDefinitionQueryImpl;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.ProcessDefinitionDataManager;
import org.activiti.engine.repository.ProcessDefinition;
/**
......@@ -30,102 +30,82 @@ import org.activiti.engine.repository.ProcessDefinition;
*/
public class ProcessDefinitionEntityManagerImpl extends AbstractEntityManager<ProcessDefinitionEntity> implements ProcessDefinitionEntityManager {
protected ProcessDefinitionDataManager processDefinitionDataManager;
public ProcessDefinitionEntityManagerImpl() {
}
public ProcessDefinitionEntityManagerImpl(ProcessDefinitionDataManager processDefinitionDataManager) {
this.processDefinitionDataManager = processDefinitionDataManager;
}
@Override
public Class<ProcessDefinitionEntity> getManagedEntity() {
return ProcessDefinitionEntity.class;
protected DataManager<ProcessDefinitionEntity> getDataManager() {
return processDefinitionDataManager;
}
@Override
public ProcessDefinitionEntity findLatestProcessDefinitionByKey(String processDefinitionKey) {
return (ProcessDefinitionEntity) getDbSqlSession().selectOne("selectLatestProcessDefinitionByKey", processDefinitionKey);
return processDefinitionDataManager.findLatestProcessDefinitionByKey(processDefinitionKey);
}
@Override
public ProcessDefinitionEntity findLatestProcessDefinitionByKeyAndTenantId(String processDefinitionKey, String tenantId) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("processDefinitionKey", processDefinitionKey);
params.put("tenantId", tenantId);
return (ProcessDefinitionEntity) getDbSqlSession().selectOne("selectLatestProcessDefinitionByKeyAndTenantId", params);
return processDefinitionDataManager.findLatestProcessDefinitionByKeyAndTenantId(processDefinitionKey, tenantId);
}
@Override
public void deleteProcessDefinitionsByDeploymentId(String deploymentId) {
getDbSqlSession().delete("deleteProcessDefinitionsByDeploymentId", deploymentId);
processDefinitionDataManager.deleteProcessDefinitionsByDeploymentId(deploymentId);
}
@Override
@SuppressWarnings("unchecked")
public List<ProcessDefinition> findProcessDefinitionsByQueryCriteria(ProcessDefinitionQueryImpl processDefinitionQuery, Page page) {
// List<ProcessDefinition> processDefinitions =
return getDbSqlSession().selectList("selectProcessDefinitionsByQueryCriteria", processDefinitionQuery, page);
// skipped this after discussion within the team
// // retrieve process definitions from cache
// (https://activiti.atlassian.net/browse/ACT-1020) to have all available
// information
// ArrayList<ProcessDefinition> result = new
// ArrayList<ProcessDefinition>();
// for (ProcessDefinition processDefinitionEntity : processDefinitions)
// {
// ProcessDefinitionEntity fullProcessDefinition = Context
// .getProcessEngineConfiguration()
// .getDeploymentCache().resolveProcessDefinition((ProcessDefinitionEntity)processDefinitionEntity);
// result.add(fullProcessDefinition);
// }
// return result;
return processDefinitionDataManager.findProcessDefinitionsByQueryCriteria(processDefinitionQuery, page);
}
@Override
public long findProcessDefinitionCountByQueryCriteria(ProcessDefinitionQueryImpl processDefinitionQuery) {
return (Long) getDbSqlSession().selectOne("selectProcessDefinitionCountByQueryCriteria", processDefinitionQuery);
return processDefinitionDataManager.findProcessDefinitionCountByQueryCriteria(processDefinitionQuery);
}
@Override
public ProcessDefinitionEntity findProcessDefinitionByDeploymentAndKey(String deploymentId, String processDefinitionKey) {
Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("deploymentId", deploymentId);
parameters.put("processDefinitionKey", processDefinitionKey);
return (ProcessDefinitionEntity) getDbSqlSession().selectOne("selectProcessDefinitionByDeploymentAndKey", parameters);
return processDefinitionDataManager.findProcessDefinitionByDeploymentAndKey(deploymentId, processDefinitionKey);
}
@Override
public ProcessDefinitionEntity findProcessDefinitionByDeploymentAndKeyAndTenantId(String deploymentId, String processDefinitionKey, String tenantId) {
Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("deploymentId", deploymentId);
parameters.put("processDefinitionKey", processDefinitionKey);
parameters.put("tenantId", tenantId);
return (ProcessDefinitionEntity) getDbSqlSession().selectOne("selectProcessDefinitionByDeploymentAndKeyAndTenantId", parameters);
return processDefinitionDataManager.findProcessDefinitionByDeploymentAndKeyAndTenantId(deploymentId, processDefinitionKey, tenantId);
}
@Override
public ProcessDefinition findProcessDefinitionByKeyAndVersion(String processDefinitionKey, Integer processDefinitionVersion) {
ProcessDefinitionQueryImpl processDefinitionQuery = new ProcessDefinitionQueryImpl().processDefinitionKey(processDefinitionKey).processDefinitionVersion(processDefinitionVersion);
List<ProcessDefinition> results = findProcessDefinitionsByQueryCriteria(processDefinitionQuery, null);
if (results.size() == 1) {
return results.get(0);
} else if (results.size() > 1) {
throw new ActivitiException("There are " + results.size() + " process definitions with key = '" + processDefinitionKey + "' and version = '" + processDefinitionVersion + "'.");
}
return null;
public ProcessDefinition findProcessDefinitionByKeyAndVersionAndTenantId(String processDefinitionKey, Integer processDefinitionVersion, String tenantId) {
return processDefinitionDataManager.findProcessDefinitionByKeyAndVersionAndTenantId(processDefinitionKey, processDefinitionVersion, tenantId);
}
@Override
@SuppressWarnings("unchecked")
public List<ProcessDefinition> findProcessDefinitionsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectProcessDefinitionByNativeQuery", parameterMap, firstResult, maxResults);
return processDefinitionDataManager.findProcessDefinitionsByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findProcessDefinitionCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectProcessDefinitionCountByNativeQuery", parameterMap);
return processDefinitionDataManager.findProcessDefinitionCountByNativeQuery(parameterMap);
}
@Override
public void updateProcessDefinitionTenantIdForDeployment(String deploymentId, String newTenantId) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("deploymentId", deploymentId);
params.put("tenantId", newTenantId);
getDbSqlSession().update("updateProcessDefinitionTenantIdForDeploymentId", params);
processDefinitionDataManager.updateProcessDefinitionTenantIdForDeployment(deploymentId, newTenantId);
}
public ProcessDefinitionDataManager getProcessDefinitionDataManager() {
return processDefinitionDataManager;
}
public void setProcessDefinitionDataManager(ProcessDefinitionDataManager processDefinitionDataManager) {
this.processDefinitionDataManager = processDefinitionDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/PropertyEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,15 +13,28 @@
package org.activiti.engine.impl.persistence.entity;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.PropertyDataManager;
/**
* @author Tom Baeyens
* @author Joram Barrez
*/
public class PropertyEntityManagerImpl extends AbstractEntityManager<PropertyEntity> implements PropertyEntityManager {
protected PropertyDataManager propertyDataManager;
public PropertyEntityManagerImpl() {
}
public PropertyEntityManagerImpl(PropertyDataManager propertyDataManager) {
this.propertyDataManager = propertyDataManager;
}
@Override
public Class<PropertyEntity> getManagedEntity() {
return PropertyEntity.class;
protected DataManager<PropertyEntity> getDataManager() {
return propertyDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ResourceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,9 +13,10 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.ResourceDataManager;
/**
* @author Tom Baeyens
......@@ -23,28 +24,42 @@ import java.util.Map;
*/
public class ResourceEntityManagerImpl extends AbstractEntityManager<ResourceEntity> implements ResourceEntityManager {
protected ResourceDataManager resourceDataManager;
public ResourceEntityManagerImpl() {
}
public ResourceEntityManagerImpl(ResourceDataManager resourceDataManager) {
this.resourceDataManager = resourceDataManager;
}
@Override
public Class<ResourceEntity> getManagedEntity() {
return ResourceEntity.class;
protected DataManager<ResourceEntity> getDataManager() {
return resourceDataManager;
}
@Override
public void deleteResourcesByDeploymentId(String deploymentId) {
getDbSqlSession().delete("deleteResourcesByDeploymentId", deploymentId);
resourceDataManager.deleteResourcesByDeploymentId(deploymentId);
}
@Override
public ResourceEntity findResourceByDeploymentIdAndResourceName(String deploymentId, String resourceName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("deploymentId", deploymentId);
params.put("resourceName", resourceName);
return (ResourceEntity) getDbSqlSession().selectOne("selectResourceByDeploymentIdAndResourceName", params);
return resourceDataManager.findResourceByDeploymentIdAndResourceName(deploymentId, resourceName);
}
@Override
@SuppressWarnings("unchecked")
public List<ResourceEntity> findResourcesByDeploymentId(String deploymentId) {
return getDbSqlSession().selectList("selectResourcesByDeploymentId", deploymentId);
return resourceDataManager.findResourcesByDeploymentId(deploymentId);
}
public ResourceDataManager getResourceDataManager() {
return resourceDataManager;
}
public void setResourceDataManager(ResourceDataManager resourceDataManager) {
this.resourceDataManager = resourceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/TaskEntityManager.java
浏览文件 @ 240fa4dd
......@@ -36,7 +36,7 @@ public interface TaskEntityManager extends EntityManager<TaskEntity> {
List<Task> findTasksByParentTaskId(String parentTaskId);
void update(TaskEntity taskEntity);
TaskEntity update(TaskEntity taskEntity);
void updateTaskTenantIdForDeployment(String deploymentId, String newTenantId);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/TaskEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,9 +13,7 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
......@@ -27,7 +25,8 @@ import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.TaskQueryImpl;
import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.TaskDataManager;
import org.activiti.engine.impl.util.Activiti5Util;
import org.activiti.engine.task.Task;
......@@ -37,9 +36,19 @@ import org.activiti.engine.task.Task;
*/
public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> implements TaskEntityManager {
protected TaskDataManager taskDataManager;
public TaskEntityManagerImpl() {
}
public TaskEntityManagerImpl(TaskDataManager taskDataManager) {
this.taskDataManager = taskDataManager;
}
@Override
public Class<TaskEntity> getManagedEntity() {
return TaskEntity.class;
protected DataManager<TaskEntity> getDataManager() {
return taskDataManager;
}
/**
......@@ -90,7 +99,7 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
}
@Override
public void update(TaskEntity taskEntity) {
public TaskEntity update(TaskEntity taskEntity) {
// Needed to make history work: the setter will also update the historic task
taskEntity.setOwner(taskEntity.getOwner());
taskEntity.setAssignee(taskEntity.getAssignee(), true, false);
......@@ -104,17 +113,12 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
taskEntity.setParentTaskId(taskEntity.getParentTaskId());
taskEntity.setFormKey(taskEntity.getFormKey());
getDbSqlSession().update(taskEntity);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, taskEntity));
}
return super.update(taskEntity);
}
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public void deleteTasksByProcessInstanceId(String processInstanceId, String deleteReason, boolean cascade) {
List<TaskEntity> tasks = (List) getDbSqlSession().createTaskQuery().processInstanceId(processInstanceId).list();
List<TaskEntity> tasks = findTasksByProcessInstanceId(processInstanceId);
String reason = (deleteReason == null || deleteReason.length() == 0) ? TaskEntity.DELETE_REASON_DELETED : deleteReason;
......@@ -143,7 +147,6 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
}
getIdentityLinkEntityManager().deleteIdentityLinksByTaskId(taskId);
getVariableInstanceEntityManager().deleteVariableInstanceByTask(task);
if (cascade) {
......@@ -152,10 +155,9 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
getHistoryManager().recordTaskEnd(taskId, deleteReason);
}
getDbSqlSession().delete(task);
delete(task, false);
if (getEventDispatcher().isEnabled()) {
if (cancel) {
getEventDispatcher().dispatchEvent(
ActivitiEventBuilder.createActivityCancelledEvent(task.getExecution().getActivityId(), task.getName(), task.getExecutionId(), task.getProcessInstanceId(),
......@@ -168,90 +170,49 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
}
@Override
public List<TaskEntity> findTasksByExecutionId(final String executionId) {
return getList("selectTasksByExecutionId", executionId, new CachedEntityMatcher<TaskEntity>() {
public boolean isRetained(TaskEntity taskEntity) {
return taskEntity.getExecutionId() != null && executionId.equals(taskEntity.getExecutionId());
}
}, true);
public List<TaskEntity> findTasksByExecutionId(String executionId) {
return taskDataManager.findTasksByExecutionId(executionId);
}
@Override
@SuppressWarnings("unchecked")
public List<TaskEntity> findTasksByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectTasksByProcessInstanceId", processInstanceId);
return taskDataManager.findTasksByProcessInstanceId(processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Task> findTasksByQueryCriteria(TaskQueryImpl taskQuery) {
final String query = "selectTaskByQueryCriteria";
return getDbSqlSession().selectList(query, taskQuery);
return taskDataManager.findTasksByQueryCriteria(taskQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<Task> findTasksAndVariablesByQueryCriteria(TaskQueryImpl taskQuery) {
final String query = "selectTaskWithVariablesByQueryCriteria";
// paging doesn't work for combining task instances and variables due to
// an outer join, so doing it in-memory
if (taskQuery.getFirstResult() < 0 || taskQuery.getMaxResults() <= 0) {
return Collections.EMPTY_LIST;
}
int firstResult = taskQuery.getFirstResult();
int maxResults = taskQuery.getMaxResults();
// setting max results, limit to 20000 results for performance reasons
taskQuery.setMaxResults(20000);
taskQuery.setFirstResult(0);
List<Task> instanceList = getDbSqlSession().selectListWithRawParameterWithoutFilter(query, taskQuery, taskQuery.getFirstResult(), taskQuery.getMaxResults());
if (instanceList != null && !instanceList.isEmpty()) {
if (firstResult > 0) {
if (firstResult <= instanceList.size()) {
int toIndex = firstResult + Math.min(maxResults, instanceList.size() - firstResult);
return instanceList.subList(firstResult, toIndex);
} else {
return Collections.EMPTY_LIST;
}
} else {
int toIndex = Math.min(maxResults, instanceList.size());
return instanceList.subList(0, toIndex);
}
}
return Collections.EMPTY_LIST;
return taskDataManager.findTasksAndVariablesByQueryCriteria(taskQuery);
}
@Override
public long findTaskCountByQueryCriteria(TaskQueryImpl taskQuery) {
return (Long) getDbSqlSession().selectOne("selectTaskCountByQueryCriteria", taskQuery);
return taskDataManager.findTaskCountByQueryCriteria(taskQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<Task> findTasksByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectTaskByNativeQuery", parameterMap, firstResult, maxResults);
return taskDataManager.findTasksByNativeQuery(parameterMap, firstResult, maxResults);
}
@Override
public long findTaskCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectTaskCountByNativeQuery", parameterMap);
return taskDataManager.findTaskCountByNativeQuery(parameterMap);
}
@Override
@SuppressWarnings("unchecked")
public List<Task> findTasksByParentTaskId(String parentTaskId) {
return getDbSqlSession().selectList("selectTasksByParentTaskId", parentTaskId);
return taskDataManager.findTasksByParentTaskId(parentTaskId);
}
@Override
public void deleteTask(String taskId, String deleteReason, boolean cascade) {
TaskEntity task = getTaskEntityManager().findById(taskId);
TaskEntity task = findById(taskId);
if (task != null) {
if (task.getExecutionId() != null) {
......@@ -273,10 +234,15 @@ public class TaskEntityManagerImpl extends AbstractEntityManager<TaskEntity> imp
@Override
public void updateTaskTenantIdForDeployment(String deploymentId, String newTenantId) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("deploymentId", deploymentId);
params.put("tenantId", newTenantId);
getDbSqlSession().update("updateTaskTenantIdForDeployment", params);
taskDataManager.updateTaskTenantIdForDeployment(deploymentId, newTenantId);
}
public TaskDataManager getTaskDataManager() {
return taskDataManager;
}
public void setTaskDataManager(TaskDataManager taskDataManager) {
this.taskDataManager = taskDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/UserEntityManager.java
浏览文件 @ 240fa4dd
......@@ -40,14 +40,8 @@ public interface UserEntityManager extends EntityManager<UserEntity> {
UserQuery createNewUserQuery();
IdentityInfoEntity findUserInfoByUserIdAndKey(String userId, String key);
List<String> findUserInfoKeysByUserIdAndType(String userId, String type);
Boolean checkPassword(String userId, String password);
List<User> findPotentialStarterUsers(String proceDefId);
List<User> findUsersByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
long findUserCountByNativeQuery(Map<String, Object> parameterMap);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/UserEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -13,20 +13,18 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.ActivitiObjectNotFoundException;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.Picture;
import org.activiti.engine.identity.User;
import org.activiti.engine.identity.UserQuery;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.UserQueryImpl;
import org.activiti.engine.impl.db.Entity;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.UserDataManager;
/**
* @author Tom Baeyens
......@@ -35,9 +33,24 @@ import org.activiti.engine.impl.db.Entity;
*/
public class UserEntityManagerImpl extends AbstractEntityManager<UserEntity> implements UserEntityManager {
protected UserDataManager userDataManager;
public UserEntityManagerImpl() {
}
public UserEntityManagerImpl(UserDataManager userDataManager) {
this.userDataManager = userDataManager;
}
@Override
public Class<UserEntity> getManagedEntity() {
return UserEntity.class;
protected DataManager<UserEntity> getDataManager() {
return userDataManager;
}
@Override
public UserEntity findById(String entityId) {
return userDataManager.findById(entityId);
}
public User createNewUser(String userId) {
......@@ -45,11 +58,7 @@ public class UserEntityManagerImpl extends AbstractEntityManager<UserEntity> imp
}
public void updateUser(User updatedUser) {
getDbSqlSession().update((Entity) updatedUser);
if (getEventDispatcher().isEnabled()) {
getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, updatedUser));
}
super.update((UserEntity) updatedUser);
}
public void delete(UserEntity userEntity) {
......@@ -65,53 +74,34 @@ public class UserEntityManagerImpl extends AbstractEntityManager<UserEntity> imp
}
}
@SuppressWarnings("unchecked")
public void delete(String userId) {
UserEntity user = findById(userId);
if (user != null) {
List<IdentityInfoEntity> identityInfos = getDbSqlSession().selectList("selectIdentityInfoByUserId", userId);
List<IdentityInfoEntity> identityInfos = getIdentityInfoEntityManager().findIdentityInfoByUserId(userId);
for (IdentityInfoEntity identityInfo : identityInfos) {
getIdentityInfoEntityManager().delete(identityInfo);
}
getDbSqlSession().delete("deleteMembershipsByUserId", userId);
getMembershipEntityManager().deleteMembershipByUserId(userId);
delete(user);
}
}
@SuppressWarnings("unchecked")
public List<User> findUserByQueryCriteria(UserQueryImpl query, Page page) {
return getDbSqlSession().selectList("selectUserByQueryCriteria", query, page);
return userDataManager.findUserByQueryCriteria(query, page);
}
public long findUserCountByQueryCriteria(UserQueryImpl query) {
return (Long) getDbSqlSession().selectOne("selectUserCountByQueryCriteria", query);
return userDataManager.findUserCountByQueryCriteria(query);
}
@SuppressWarnings("unchecked")
public List<Group> findGroupsByUser(String userId) {
return getDbSqlSession().selectList("selectGroupsByUserId", userId);
return userDataManager.findGroupsByUser(userId);
}
public UserQuery createNewUserQuery() {
return new UserQueryImpl(getCommandExecutor());
}
public IdentityInfoEntity findUserInfoByUserIdAndKey(String userId, String key) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("userId", userId);
parameters.put("key", key);
return (IdentityInfoEntity) getDbSqlSession().selectOne("selectIdentityInfoByUserIdAndKey", parameters);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public List<String> findUserInfoKeysByUserIdAndType(String userId, String type) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("userId", userId);
parameters.put("type", type);
return (List) getDbSqlSession().getSqlSession().selectList("selectIdentityInfoKeysByUserIdAndType", parameters);
}
public Boolean checkPassword(String userId, String password) {
User user = null;
......@@ -125,21 +115,12 @@ public class UserEntityManagerImpl extends AbstractEntityManager<UserEntity> imp
return false;
}
@SuppressWarnings("unchecked")
public List<User> findPotentialStarterUsers(String proceDefId) {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("procDefId", proceDefId);
return (List<User>) getDbSqlSession().selectOne("selectUserByQueryCriteria", parameters);
}
@SuppressWarnings("unchecked")
public List<User> findUsersByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectUserByNativeQuery", parameterMap, firstResult, maxResults);
return userDataManager.findUsersByNativeQuery(parameterMap, firstResult, maxResults);
}
public long findUserCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectUserCountByNativeQuery", parameterMap);
return userDataManager.findUserCountByNativeQuery(parameterMap);
}
@Override
......@@ -163,4 +144,12 @@ public class UserEntityManagerImpl extends AbstractEntityManager<UserEntity> imp
user.setPicture(picture);
}
public UserDataManager getUserDataManager() {
return userDataManager;
}
public void setUserDataManager(UserDataManager userDataManager) {
this.userDataManager = userDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/VariableInstanceEntityManager.java
浏览文件 @ 240fa4dd
......@@ -22,8 +22,6 @@ import org.activiti.engine.impl.variable.VariableType;
*/
public interface VariableInstanceEntityManager extends EntityManager<VariableInstanceEntity> {
Class<VariableInstanceEntity> getManagedEntity();
VariableInstanceEntity create(String name, VariableType type, Object value);
VariableInstanceEntity createAndInsert(String name, VariableType type, Object value);
......
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/VariableInstanceEntityManagerImpl.java
浏览文件 @ 240fa4dd
......@@ -14,13 +14,13 @@
package org.activiti.engine.impl.persistence.entity;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.data.DataManager;
import org.activiti.engine.impl.persistence.entity.data.VariableInstanceDataManager;
import org.activiti.engine.impl.variable.VariableType;
/**
......@@ -30,9 +30,19 @@ import org.activiti.engine.impl.variable.VariableType;
*/
public class VariableInstanceEntityManagerImpl extends AbstractEntityManager<VariableInstanceEntity> implements VariableInstanceEntityManager {
protected VariableInstanceDataManager variableInstanceDataManager;
public VariableInstanceEntityManagerImpl() {
}
public VariableInstanceEntityManagerImpl(VariableInstanceDataManager variableInstanceDataManager) {
this.variableInstanceDataManager = variableInstanceDataManager;
}
@Override
public Class<VariableInstanceEntity> getManagedEntity() {
return VariableInstanceEntity.class;
protected DataManager<VariableInstanceEntity> getDataManager() {
return variableInstanceDataManager;
}
@Override
......@@ -53,62 +63,38 @@ public class VariableInstanceEntityManagerImpl extends AbstractEntityManager<Var
}
@Override
@SuppressWarnings("unchecked")
public List<VariableInstanceEntity> findVariableInstancesByTaskId(String taskId) {
return getDbSqlSession().selectList("selectVariablesByTaskId", taskId);
return variableInstanceDataManager.findVariableInstancesByTaskId(taskId);
}
@Override
public Collection<VariableInstanceEntity> findVariableInstancesByExecutionId(final String executionId) {
return getList("selectVariablesByExecutionId", executionId, new CachedEntityMatcher<VariableInstanceEntity>() {
public boolean isRetained(VariableInstanceEntity variableInstanceEntity) {
return variableInstanceEntity.getExecutionId() != null && variableInstanceEntity.getExecutionId().equals(executionId);
}
}, true);
return variableInstanceDataManager.findVariableInstancesByExecutionId(executionId);
}
@Override
public VariableInstanceEntity findVariableInstanceByExecutionAndName(String executionId, String variableName) {
Map<String, String> params = new HashMap<String, String>(2);
params.put("executionId", executionId);
params.put("name", variableName);
return (VariableInstanceEntity) getDbSqlSession().selectOne("selectVariableInstanceByExecutionAndName", params);
return variableInstanceDataManager.findVariableInstanceByExecutionAndName(executionId, variableName);
}
@Override
@SuppressWarnings("unchecked")
public List<VariableInstanceEntity> findVariableInstancesByExecutionAndNames(String executionId, Collection<String> names) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("executionId", executionId);
params.put("names", names);
return getDbSqlSession().selectList("selectVariableInstancesByExecutionAndNames", params);
return variableInstanceDataManager.findVariableInstancesByExecutionAndNames(executionId, names);
}
@Override
public VariableInstanceEntity findVariableInstanceByTaskAndName(String taskId, String variableName) {
Map<String, String> params = new HashMap<String, String>(2);
params.put("taskId", taskId);
params.put("name", variableName);
return (VariableInstanceEntity) getDbSqlSession().selectOne("selectVariableInstanceByTaskAndName", params);
return variableInstanceDataManager.findVariableInstanceByTaskAndName(taskId, variableName);
}
@Override
@SuppressWarnings("unchecked")
public List<VariableInstanceEntity> findVariableInstancesByTaskAndNames(String taskId, Collection<String> names) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("taskId", taskId);
params.put("names", names);
return getDbSqlSession().selectList("selectVariableInstancesByTaskAndNames", params);
}
@Override
public void delete(VariableInstanceEntity entity) {
delete(entity, true);
return variableInstanceDataManager.findVariableInstancesByTaskAndNames(taskId, names);
}
@Override
public void delete(VariableInstanceEntity entity, boolean fireDeleteEvent) {
getDbSqlSession().delete(entity);
super.delete(entity, false);
ByteArrayRef byteArrayRef = entity.getByteArrayRef();
if (byteArrayRef != null) {
byteArrayRef.delete();
......@@ -130,4 +116,13 @@ public class VariableInstanceEntityManagerImpl extends AbstractEntityManager<Var
}
}
}
public VariableInstanceDataManager getVariableInstanceDataManager() {
return variableInstanceDataManager;
}
public void setVariableInstanceDataManager(VariableInstanceDataManager variableInstanceDataManager) {
this.variableInstanceDataManager = variableInstanceDataManager;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/AbstractDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.activiti.engine.ActivitiIllegalArgumentException;
import org.activiti.engine.impl.db.Entity;
import org.activiti.engine.impl.persistence.AbstractManager;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.cache.CachedEntity;
/**
* @author Joram Barrez
*/
public abstract class AbstractDataManager<EntityImpl extends Entity> extends AbstractManager implements DataManager<EntityImpl> {
public abstract Class<EntityImpl> getManagedEntityClass();
public List<Class<? extends EntityImpl>> getManagedEntitySubClasses() {
return null;
}
@Override
public EntityImpl findById(String entityId) {
if (entityId == null) {
throw new ActivitiIllegalArgumentException("Invalid entity id : null");
}
// Cache
EntityImpl cachedEntity = getEntityCache().findInCache(getManagedEntityClass(), entityId);
if (cachedEntity != null) {
return cachedEntity;
}
// Database
return getDbSqlSession().selectById(getManagedEntityClass(), entityId);
}
@Override
public void insert(EntityImpl entity) {
getDbSqlSession().insert(entity);
}
public EntityImpl update(EntityImpl entity) {
getDbSqlSession().update(entity);
return entity;
}
@Override
public void delete(String id) {
EntityImpl entity = findById(id);
delete(entity);
}
@Override
public void delete(EntityImpl entity) {
getDbSqlSession().delete(entity);
}
@SuppressWarnings("unchecked")
protected EntityImpl findByQuery(String selectQuery, Object parameter, CachedEntityMatcher<EntityImpl> cachedEntityMatcher) {
// Cache
for (EntityImpl cachedEntity : getEntityCache().findInCache(getManagedEntityClass())) {
if (cachedEntityMatcher.isRetained(cachedEntity)) {
return cachedEntity;
}
}
// Database
return (EntityImpl) getDbSqlSession().selectOne(selectQuery, parameter);
}
/**
* Gets a list by querying the database and the cache using {@link CachedEntityMatcher}.
* First, the entities are fetched from the database using the provided query.
* The cache is then queried for the entities of the same type. If an entity matches
* the {@link CachedEntityMatcher} condition, it replaces the entity from the database (as it is newer).
*
* @param dbQueryName The query name that needs to be executed.
* @param parameter The parameters for the query.
* @param entityMatcher The matcher used to determine which entities from the cache needs to be retained
* @param checkCache If false, no cache check will be done, and the returned list will simply be the list from the database.
*/
@SuppressWarnings("unchecked")
protected List<EntityImpl> getList(String dbQueryName, Object parameter, CachedEntityMatcher<EntityImpl> retainEntityCondition, boolean checkCache) {
Collection<EntityImpl> result = getDbSqlSession().selectList(dbQueryName, parameter);
if (checkCache) {
Collection<CachedEntity> cachedObjects = getEntityCache().findInCacheAsCachedObjects(getManagedEntityClass());
if ( (cachedObjects != null && cachedObjects.size() > 0) || getManagedEntitySubClasses() != null) {
HashMap<String, EntityImpl> entityMap = new HashMap<String, EntityImpl>(result.size());
// Database entities
for (EntityImpl entity : result) {
entityMap.put(entity.getId(), entity);
}
// Cache entities
if (cachedObjects != null) {
for (CachedEntity cachedObject : cachedObjects) {
EntityImpl cachedEntity = (EntityImpl) cachedObject.getEntity();
if (retainEntityCondition.isRetained(cachedEntity)) {
entityMap.put(cachedEntity.getId(), cachedEntity); // will overwite db version with newer version
}
}
}
if (getManagedEntitySubClasses() != null) {
for (Class<? extends EntityImpl> entitySubClass : getManagedEntitySubClasses()) {
Collection<CachedEntity> subclassCachedObjects = getEntityCache().findInCacheAsCachedObjects(entitySubClass);
if (subclassCachedObjects != null) {
for (CachedEntity subclassCachedObject : subclassCachedObjects) {
EntityImpl cachedSubclassEntity = (EntityImpl) subclassCachedObject.getEntity();
if (retainEntityCondition.isRetained(cachedSubclassEntity)) {
entityMap.put(cachedSubclassEntity.getId(), cachedSubclassEntity); // will overwite db version with newer version
}
}
}
}
}
result = entityMap.values();
}
}
// Remove entries which are already deleted
if (result.size() > 0) {
Iterator<EntityImpl> resultIterator = result.iterator();
while (resultIterator.hasNext()) {
if (getDbSqlSession().isEntityToBeDeleted(resultIterator.next())) {
resultIterator.remove();
}
}
}
return new ArrayList<EntityImpl>(result);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/AttachmentDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.impl.persistence.entity.AttachmentEntity;
import org.activiti.engine.task.Attachment;
/**
* @author Joram Barrez
*/
public interface AttachmentDataManager extends DataManager<AttachmentEntity> {
List<Attachment> findAttachmentsByProcessInstanceId(String processInstanceId);
List<Attachment> findAttachmentsByTaskId(String taskId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/AttachmentDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.impl.persistence.entity.AttachmentEntity;
import org.activiti.engine.task.Attachment;
/**
* @author Joram Barrez
*/
public class AttachmentDataManagerImpl extends AbstractDataManager<AttachmentEntity> implements AttachmentDataManager {
@Override
public Class<AttachmentEntity> getManagedEntityClass() {
return AttachmentEntity.class;
}
@Override
@SuppressWarnings("unchecked")
public List<Attachment> findAttachmentsByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectAttachmentsByProcessInstanceId", processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Attachment> findAttachmentsByTaskId(String taskId) {
return getDbSqlSession().selectList("selectAttachmentsByTaskId", taskId);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/ByteArrayDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import org.activiti.engine.impl.persistence.entity.ByteArrayEntity;
/**
* @author Joram Barrez
*/
public interface ByteArrayDataManager extends DataManager<ByteArrayEntity> {
void deleteByteArrayNoRevisionCheck(String byteArrayEntityId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/ByteArrayDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import org.activiti.engine.impl.persistence.entity.ByteArrayEntity;
/**
* @author Joram Barrez
*/
public class ByteArrayDataManagerImpl extends AbstractDataManager<ByteArrayEntity> implements ByteArrayDataManager {
@Override
public Class<ByteArrayEntity> getManagedEntityClass() {
return ByteArrayEntity.class;
}
@Override
public void deleteByteArrayNoRevisionCheck(String byteArrayEntityId) {
getDbSqlSession().delete("deleteByteArrayNoRevisionCheck", byteArrayEntityId);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/CommentDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.impl.persistence.entity.CommentEntity;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.Event;
/**
* @author Joram Barrez
*/
public interface CommentDataManager extends DataManager<CommentEntity> {
List<Comment> findCommentsByTaskId(String taskId);
List<Comment> findCommentsByTaskIdAndType(String taskId, String type);
List<Comment> findCommentsByType(String type);
List<Event> findEventsByTaskId(String taskId);
List<Event> findEventsByProcessInstanceId(String processInstanceId);
void deleteCommentsByTaskId(String taskId);
void deleteCommentsByProcessInstanceId(String processInstanceId);
List<Comment> findCommentsByProcessInstanceId(String processInstanceId);
List<Comment> findCommentsByProcessInstanceId(String processInstanceId, String type);
Comment findComment(String commentId);
Event findEvent(String commentId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/CommentDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.impl.persistence.entity.CommentEntity;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.Event;
/**
* @author Joram Barrez
*/
public class CommentDataManagerImpl extends AbstractDataManager<CommentEntity> implements CommentDataManager {
@Override
public Class<CommentEntity> getManagedEntityClass() {
return CommentEntity.class;
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByTaskId(String taskId) {
return getDbSqlSession().selectList("selectCommentsByTaskId", taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByTaskIdAndType(String taskId, String type) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("taskId", taskId);
params.put("type", type);
return getDbSqlSession().selectListWithRawParameter("selectCommentsByTaskIdAndType", params, 0, Integer.MAX_VALUE);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByType(String type) {
return getDbSqlSession().selectList("selectCommentsByType", type);
}
@Override
@SuppressWarnings("unchecked")
public List<Event> findEventsByTaskId(String taskId) {
return getDbSqlSession().selectList("selectEventsByTaskId", taskId);
}
@Override
@SuppressWarnings("unchecked")
public List<Event> findEventsByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectEventsByProcessInstanceId", processInstanceId);
}
@Override
public void deleteCommentsByTaskId(String taskId) {
getDbSqlSession().delete("deleteCommentsByTaskId", taskId);
}
@Override
public void deleteCommentsByProcessInstanceId(String processInstanceId) {
getDbSqlSession().delete("deleteCommentsByProcessInstanceId", processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByProcessInstanceId(String processInstanceId) {
return getDbSqlSession().selectList("selectCommentsByProcessInstanceId", processInstanceId);
}
@Override
@SuppressWarnings("unchecked")
public List<Comment> findCommentsByProcessInstanceId(String processInstanceId, String type) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("processInstanceId", processInstanceId);
params.put("type", type);
return getDbSqlSession().selectListWithRawParameter("selectCommentsByProcessInstanceIdAndType", params, 0, Integer.MAX_VALUE);
}
@Override
public Comment findComment(String commentId) {
return getDbSqlSession().selectById(CommentEntity.class, commentId);
}
@Override
public Event findEvent(String commentId) {
return getDbSqlSession().selectById(CommentEntity.class, commentId);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/DataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import org.activiti.engine.impl.db.Entity;
/**
* @author Joram Barrez
*/
public interface DataManager<EntityImpl extends Entity> {
EntityImpl findById(String entityId);
void insert(EntityImpl entity);
EntityImpl update(EntityImpl entity);
void delete(String id);
void delete(EntityImpl entity);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/DeploymentDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import java.util.Map;
import org.activiti.engine.impl.DeploymentQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.DeploymentEntity;
import org.activiti.engine.repository.Deployment;
/**
* @author Joram Barrez
*/
public interface DeploymentDataManager extends DataManager<DeploymentEntity> {
DeploymentEntity findLatestDeploymentByName(String deploymentName);
long findDeploymentCountByQueryCriteria(DeploymentQueryImpl deploymentQuery);
List<Deployment> findDeploymentsByQueryCriteria(DeploymentQueryImpl deploymentQuery, Page page);
List<String> getDeploymentResourceNames(String deploymentId);
List<Deployment> findDeploymentsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
long findDeploymentCountByNativeQuery(Map<String, Object> parameterMap);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/DeploymentDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import java.util.Map;
import org.activiti.engine.impl.DeploymentQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.DeploymentEntity;
import org.activiti.engine.repository.Deployment;
/**
* @author Joram Barrez
*/
public class DeploymentDataManagerImpl extends AbstractDataManager<DeploymentEntity> implements DeploymentDataManager {
@Override
public Class<DeploymentEntity> getManagedEntityClass() {
return DeploymentEntity.class;
}
@Override
public DeploymentEntity findLatestDeploymentByName(String deploymentName) {
List<?> list = getDbSqlSession().selectList("selectDeploymentsByName", deploymentName, 0, 1);
if (list != null && !list.isEmpty()) {
return (DeploymentEntity) list.get(0);
}
return null;
}
@Override
public long findDeploymentCountByQueryCriteria(DeploymentQueryImpl deploymentQuery) {
return (Long) getDbSqlSession().selectOne("selectDeploymentCountByQueryCriteria", deploymentQuery);
}
@Override
@SuppressWarnings("unchecked")
public List<Deployment> findDeploymentsByQueryCriteria(DeploymentQueryImpl deploymentQuery, Page page) {
final String query = "selectDeploymentsByQueryCriteria";
return getDbSqlSession().selectList(query, deploymentQuery, page);
}
@Override
public List<String> getDeploymentResourceNames(String deploymentId) {
return getDbSqlSession().getSqlSession().selectList("selectResourceNamesByDeploymentId", deploymentId);
}
@Override
@SuppressWarnings("unchecked")
public List<Deployment> findDeploymentsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectDeploymentByNativeQuery", parameterMap, firstResult, maxResults);
}
@Override
public long findDeploymentCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectDeploymentCountByNativeQuery", parameterMap);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/EventLogEntryDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.event.EventLogEntry;
import org.activiti.engine.impl.persistence.entity.EventLogEntryEntity;
/**
* @author Joram Barrez
*/
public interface EventLogEntryDataManager extends DataManager<EventLogEntryEntity> {
List<EventLogEntry> findAllEventLogEntries();
List<EventLogEntry> findEventLogEntries(long startLogNr, long pageSize);
List<EventLogEntry> findEventLogEntriesByProcessInstanceId(String processInstanceId);
void deleteEventLogEntry(long logNr);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/EventLogEntryDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.event.EventLogEntry;
import org.activiti.engine.impl.persistence.entity.EventLogEntryEntity;
/**
* @author Joram Barrez
*/
public class EventLogEntryDataManagerImpl extends AbstractDataManager<EventLogEntryEntity> implements EventLogEntryDataManager {
@Override
public Class<EventLogEntryEntity> getManagedEntityClass() {
return EventLogEntryEntity.class;
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findAllEventLogEntries() {
return getDbSqlSession().selectList("selectAllEventLogEntries");
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findEventLogEntries(long startLogNr, long pageSize) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("startLogNr", startLogNr);
if (pageSize > 0) {
params.put("endLogNr", startLogNr + pageSize + 1);
}
return getDbSqlSession().selectList("selectEventLogEntries", params);
}
@Override
@SuppressWarnings("unchecked")
public List<EventLogEntry> findEventLogEntriesByProcessInstanceId(String processInstanceId) {
Map<String, Object> params = new HashMap<String, Object>(2);
params.put("processInstanceId", processInstanceId);
return getDbSqlSession().selectList("selectEventLogEntriesByProcessInstanceId", params);
}
@Override
public void deleteEventLogEntry(long logNr) {
getDbSqlSession().getSqlSession().delete("deleteEventLogEntry", logNr);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/EventSubscriptionDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.impl.EventSubscriptionQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.MessageEventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.SignalEventSubscriptionEntity;
/**
* @author Joram Barrez
*/
public interface EventSubscriptionDataManager extends DataManager<EventSubscriptionEntity> {
long findEventSubscriptionCountByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl);
List<EventSubscriptionEntity> findEventSubscriptionsByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl, Page page);
List<MessageEventSubscriptionEntity> findMessageEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName);
List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByEventName(final String eventName, final String tenantId);
List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName);
List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByExecution(final String executionId);
List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByNameAndExecution(final String name, final String executionId);
List<EventSubscriptionEntity> findEventSubscriptionsByExecutionAndType(final String executionId, final String type);
List<EventSubscriptionEntity> findEventSubscriptionsByProcessInstanceAndActivityId(final String processInstanceId, final String activityId, final String type);
List<EventSubscriptionEntity> findEventSubscriptionsByExecution(final String executionId);
List<EventSubscriptionEntity> findEventSubscriptionsByConfiguration(String type, String configuration, String tenantId);
List<EventSubscriptionEntity> findEventSubscriptionsByName(final String type, final String eventName, final String tenantId);
List<EventSubscriptionEntity> findEventSubscriptionsByNameAndExecution(String type, String eventName, String executionId);
MessageEventSubscriptionEntity findMessageStartEventSubscriptionByName(String messageName, String tenantId);
void updateEventSubscriptionTenantId(String oldTenantId, String newTenantId);
void deleteEventSubscriptionsForProcessDefinition(String processDefinitionId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/EventSubscriptionDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.impl.EventSubscriptionQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.CachedEntityMatcher;
import org.activiti.engine.impl.persistence.entity.CompensateEventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.MessageEventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.SignalEventSubscriptionEntity;
import org.activiti.engine.impl.persistence.entity.SuspensionState;
import org.apache.commons.lang3.StringUtils;
/**
* @author Joram Barrez
*/
public class EventSubscriptionDataManagerImpl extends AbstractDataManager<EventSubscriptionEntity> implements EventSubscriptionDataManager {
@SuppressWarnings("unchecked")
private static final List<Class<? extends EventSubscriptionEntity>> ENTITY_SUBCLASSES =
Arrays.asList(MessageEventSubscriptionEntity.class, SignalEventSubscriptionEntity.class, CompensateEventSubscriptionEntity.class);
@Override
public Class<EventSubscriptionEntity> getManagedEntityClass() {
return EventSubscriptionEntity.class;
}
@Override
public List<Class<? extends EventSubscriptionEntity>> getManagedEntitySubClasses() {
return ENTITY_SUBCLASSES;
}
@Override
public long findEventSubscriptionCountByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl) {
final String query = "selectEventSubscriptionCountByQueryCriteria";
return (Long) getDbSqlSession().selectOne(query, eventSubscriptionQueryImpl);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByQueryCriteria(EventSubscriptionQueryImpl eventSubscriptionQueryImpl, Page page) {
final String query = "selectEventSubscriptionByQueryCriteria";
return getDbSqlSession().selectList(query, eventSubscriptionQueryImpl, page);
}
@Override
public List<MessageEventSubscriptionEntity> findMessageEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName) {
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventName", eventName);
return toMessageEventSubscriptionEntityList(getList("selectMessageEventSubscriptionsByProcessInstanceAndEventName", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(MessageEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId);
}
}, true));
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByEventName(final String eventName, final String tenantId) {
final String query = "selectSignalEventSubscriptionsByEventName";
final Map<String, String> params = new HashMap<String, String>();
params.put("eventName", eventName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
List<EventSubscriptionEntity> result = getList(query, params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& (eventSubscriptionEntity.getExecutionId() == null || (eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecution() != null && eventSubscriptionEntity.getExecution().getSuspensionState() == SuspensionState.ACTIVE.getStateCode()) )
&& ( (params.containsKey("tenantId") && tenantId.equals(eventSubscriptionEntity.getTenantId())) || (!params.containsKey("tenantId") && StringUtils.isEmpty(eventSubscriptionEntity.getTenantId())) );
}
}, true);
return toSignalEventSubscriptionEntityList(result);
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByProcessInstanceAndEventName(final String processInstanceId, final String eventName) {
final String query = "selectSignalEventSubscriptionsByProcessInstanceAndEventName";
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventName", eventName);
return toSignalEventSubscriptionEntityList(getList(query, params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId);
}
}, true));
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByExecution(final String executionId) {
return toSignalEventSubscriptionEntityList(getList("selectSignalEventSubscriptionsByExecution", executionId, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true));
}
@Override
public List<SignalEventSubscriptionEntity> findSignalEventSubscriptionsByNameAndExecution(final String name, final String executionId) {
Map<String, String> params = new HashMap<String, String>();
params.put("executionId", executionId);
params.put("eventName", name);
return toSignalEventSubscriptionEntityList(getList("selectSignalEventSubscriptionsByNameAndExecution", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(SignalEventSubscriptionEntity.EVENT_TYPE)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(name);
}
}, true));
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByExecutionAndType(final String executionId, final String type) {
Map<String, String> params = new HashMap<String, String>();
params.put("executionId", executionId);
params.put("eventType", type);
return getList("selectEventSubscriptionsByExecutionAndType", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByProcessInstanceAndActivityId(final String processInstanceId, final String activityId, final String type) {
Map<String, String> params = new HashMap<String, String>();
params.put("processInstanceId", processInstanceId);
params.put("eventType", type);
params.put("activityId", activityId);
return getList("selectEventSubscriptionsByProcessInstanceTypeAndActivity", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getProcessInstanceId() != null && eventSubscriptionEntity.getProcessInstanceId().equals(processInstanceId)
&& eventSubscriptionEntity.getActivityId() != null && eventSubscriptionEntity.getActivityId().equals(activityId);
}
}, true);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByExecution(final String executionId) {
return getList("selectEventSubscriptionsByExecution", executionId, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
return eventSubscriptionEntity.getExecutionId() != null && eventSubscriptionEntity.getExecutionId().equals(executionId);
}
}, true);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByConfiguration(String type, String configuration, String tenantId) {
final String query = "selectEventSubscriptionsByConfiguration";
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("configuration", configuration);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
return getDbSqlSession().selectList(query, params);
}
@Override
public List<EventSubscriptionEntity> findEventSubscriptionsByName(final String type, final String eventName, final String tenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("eventName", eventName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
return getList("selectEventSubscriptionsByName", params, new CachedEntityMatcher<EventSubscriptionEntity>() {
@Override
public boolean isRetained(EventSubscriptionEntity eventSubscriptionEntity) {
if (eventSubscriptionEntity.getEventType() != null && eventSubscriptionEntity.getEventType().equals(type)
&& eventSubscriptionEntity.getEventName() != null && eventSubscriptionEntity.getEventName().equals(eventName)) {
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
return eventSubscriptionEntity.getTenantId() != null && eventSubscriptionEntity.getTenantId().equals(tenantId);
} else {
return ProcessEngineConfiguration.NO_TENANT_ID.equals(eventSubscriptionEntity.getTenantId()) || eventSubscriptionEntity.getTenantId() == null;
}
}
return false;
}
}, true);
}
@Override
@SuppressWarnings("unchecked")
public List<EventSubscriptionEntity> findEventSubscriptionsByNameAndExecution(String type, String eventName, String executionId) {
final String query = "selectEventSubscriptionsByNameAndExecution";
Map<String, String> params = new HashMap<String, String>();
params.put("eventType", type);
params.put("eventName", eventName);
params.put("executionId", executionId);
return getDbSqlSession().selectList(query, params);
}
@Override
public MessageEventSubscriptionEntity findMessageStartEventSubscriptionByName(String messageName, String tenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("eventName", messageName);
if (tenantId != null && !tenantId.equals(ProcessEngineConfiguration.NO_TENANT_ID)) {
params.put("tenantId", tenantId);
}
MessageEventSubscriptionEntity entity = (MessageEventSubscriptionEntity) getDbSqlSession().selectOne("selectMessageStartEventSubscriptionByName", params);
return entity;
}
@Override
public void updateEventSubscriptionTenantId(String oldTenantId, String newTenantId) {
Map<String, String> params = new HashMap<String, String>();
params.put("oldTenantId", oldTenantId);
params.put("newTenantId", newTenantId);
getDbSqlSession().update("updateTenantIdOfEventSubscriptions", params);
}
@Override
public void deleteEventSubscriptionsForProcessDefinition(String processDefinitionId) {
getDbSqlSession().delete("deleteEventSubscriptionsForProcessDefinition", processDefinitionId);
}
protected List<SignalEventSubscriptionEntity> toSignalEventSubscriptionEntityList(List<EventSubscriptionEntity> result) {
List<SignalEventSubscriptionEntity> signalEventSubscriptionEntities = new ArrayList<SignalEventSubscriptionEntity>(result.size());
for (EventSubscriptionEntity eventSubscriptionEntity : result ) {
signalEventSubscriptionEntities.add((SignalEventSubscriptionEntity) eventSubscriptionEntity);
}
return signalEventSubscriptionEntities;
}
protected List<MessageEventSubscriptionEntity> toMessageEventSubscriptionEntityList(List<EventSubscriptionEntity> result) {
List<MessageEventSubscriptionEntity> messageEventSubscriptionEntities = new ArrayList<MessageEventSubscriptionEntity>(result.size());
for (EventSubscriptionEntity eventSubscriptionEntity : result ) {
messageEventSubscriptionEntities.add((MessageEventSubscriptionEntity) eventSubscriptionEntity);
}
return messageEventSubscriptionEntities;
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/ExecutionDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.activiti.engine.impl.ExecutionQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.ProcessInstanceQueryImpl;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
/**
* @author Joram Barrez
*/
public interface ExecutionDataManager extends DataManager<ExecutionEntity> {
ExecutionEntity findSubProcessInstanceBySuperExecutionId(final String superExecutionId);
List<ExecutionEntity> findChildExecutionsByParentExecutionId(final String parentExecutionId);
List<ExecutionEntity> findChildExecutionsByProcessInstanceId(final String processInstanceId);
List<ExecutionEntity> findExecutionsByParentExecutionAndActivityIds(final String parentExecutionId, final Collection<String> activityIds);
long findExecutionCountByQueryCriteria(ExecutionQueryImpl executionQuery);
List<ExecutionEntity> findExecutionsByQueryCriteria(ExecutionQueryImpl executionQuery, Page page);
long findProcessInstanceCountByQueryCriteria(ProcessInstanceQueryImpl executionQuery);
List<ProcessInstance> findProcessInstanceByQueryCriteria(ProcessInstanceQueryImpl executionQuery);
List<ExecutionEntity> findExecutionsByRootProcessInstanceId(String rootProcessInstanceId);
List<ExecutionEntity> findExecutionsByProcessInstanceId(String processInstanceId);
List<ProcessInstance> findProcessInstanceAndVariablesByQueryCriteria(ProcessInstanceQueryImpl executionQuery);
List<ExecutionEntity> findEventScopeExecutionsByActivityId(String activityRef, String parentExecutionId);
Collection<ExecutionEntity> findInactiveExecutionsByActivityId(final String activityId);
Collection<ExecutionEntity> findInactiveExecutionsByProcessInstanceId(final String processInstanceId);
Collection<ExecutionEntity> findInactiveExecutionsByActivityIdAndProcessInstanceId(final String activityId, final String processInstanceId);
List<String> findProcessInstanceIdsByProcessDefinitionId(String processDefinitionId);
List<Execution> findExecutionsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
List<ProcessInstance> findProcessInstanceByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
long findExecutionCountByNativeQuery(Map<String, Object> parameterMap);
void updateExecutionTenantIdForDeployment(String deploymentId, String newTenantId);
void updateProcessInstanceLockTime(String processInstanceId, Date lockDate, Date expirationTime);
void clearProcessInstanceLockTime(String processInstanceId);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/GroupDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import java.util.Map;
import org.activiti.engine.identity.Group;
import org.activiti.engine.impl.GroupQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.GroupEntity;
/**
* @author Joram Barrez
*/
public interface GroupDataManager extends DataManager<GroupEntity> {
List<Group> findGroupByQueryCriteria(GroupQueryImpl query, Page page);
long findGroupCountByQueryCriteria(GroupQueryImpl query);
List<Group> findGroupsByUser(String userId);
List<Group> findGroupsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
long findGroupCountByNativeQuery(Map<String, Object> parameterMap);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/GroupDataManagerImpl.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import java.util.Map;
import org.activiti.engine.identity.Group;
import org.activiti.engine.impl.GroupQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.GroupEntity;
/**
* @author Joram Barrez
*/
public class GroupDataManagerImpl extends AbstractDataManager<GroupEntity> implements GroupDataManager {
@Override
public Class<GroupEntity> getManagedEntityClass() {
return GroupEntity.class;
}
@SuppressWarnings("unchecked")
public List<Group> findGroupByQueryCriteria(GroupQueryImpl query, Page page) {
return getDbSqlSession().selectList("selectGroupByQueryCriteria", query, page);
}
public long findGroupCountByQueryCriteria(GroupQueryImpl query) {
return (Long) getDbSqlSession().selectOne("selectGroupCountByQueryCriteria", query);
}
@SuppressWarnings("unchecked")
public List<Group> findGroupsByUser(String userId) {
return getDbSqlSession().selectList("selectGroupsByUserId", userId);
}
@SuppressWarnings("unchecked")
public List<Group> findGroupsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
return getDbSqlSession().selectListWithRawParameter("selectGroupByNativeQuery", parameterMap, firstResult, maxResults);
}
public long findGroupCountByNativeQuery(Map<String, Object> parameterMap) {
return (Long) getDbSqlSession().selectOne("selectGroupCountByNativeQuery", parameterMap);
}
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/HistoricActivityInstanceDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import java.util.Map;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.impl.HistoricActivityInstanceQueryImpl;
import org.activiti.engine.impl.Page;
import org.activiti.engine.impl.persistence.entity.HistoricActivityInstanceEntity;
/**
* @author Joram Barrez
*/
public interface HistoricActivityInstanceDataManager extends DataManager<HistoricActivityInstanceEntity> {
void deleteHistoricActivityInstancesByProcessInstanceId(String historicProcessInstanceId);
long findHistoricActivityInstanceCountByQueryCriteria(HistoricActivityInstanceQueryImpl historicActivityInstanceQuery);
List<HistoricActivityInstance> findHistoricActivityInstancesByQueryCriteria(HistoricActivityInstanceQueryImpl historicActivityInstanceQuery, Page page);
List<HistoricActivityInstance> findHistoricActivityInstancesByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults);
long findHistoricActivityInstanceCountByNativeQuery(Map<String, Object> parameterMap);
}
modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/data/HistoricIdentityLinkDataManager.java 0 → 100644
浏览文件 @ 240fa4dd
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.persistence.entity.data;
import java.util.List;
import org.activiti.engine.impl.persistence.entity.HistoricIdentityLinkEntity;
/**
* @author Joram Barrez
*/
public interface HistoricIdentityLinkDataManager extends DataManager<HistoricIdentityLinkEntity> {
List<HistoricIdentityLinkEntity> findHistoricIdentityLinksByTaskId(String taskId);
List<HistoricIdentityLinkEntity> findHistoricIdentityLinksByProcessInstanceId(String processInstanceId);
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或