org.ow2.bonita.persistence.db.AbstractDbQuerier Maven / Gradle / Ivy
/**
* Copyright (C) 2006 Bull S. A. S.
* Bull, Rue Jean Jaures, B.P.68, 78340, Les Clayes-sous-Bois
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation
* version 2.1 of the License.
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301, USA.
**/
package org.ow2.bonita.persistence.db;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.ow2.bonita.facade.def.majorElement.ActivityDefinition;
import org.ow2.bonita.facade.def.majorElement.PackageDefinition;
import org.ow2.bonita.facade.def.majorElement.PackageFullDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessFullDefinition;
import org.ow2.bonita.facade.runtime.ActivityBody;
import org.ow2.bonita.facade.runtime.ActivityFullInstance;
import org.ow2.bonita.facade.runtime.ActivityState;
import org.ow2.bonita.facade.runtime.ProcessFullInstance;
import org.ow2.bonita.facade.runtime.TaskInstance;
import org.ow2.bonita.facade.uuid.ActivityDefinitionUUID;
import org.ow2.bonita.facade.uuid.ActivityInstanceUUID;
import org.ow2.bonita.facade.uuid.PackageDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
import org.ow2.bonita.facade.uuid.TaskUUID;
import org.ow2.bonita.persistence.QuerierDbSession;
import org.ow2.bonita.persistence.QuerierUtil;
import org.ow2.bonita.services.Querier;
import org.ow2.bonita.util.EnvTool;
import org.ow2.bonita.util.Misc;
public class AbstractDbQuerier implements Querier {
private String persistenceServiceName;
protected DbQuerierBuffer buffer;
public AbstractDbQuerier(String persistenceServiceName, DbQuerierBuffer buffer) {
super();
this.persistenceServiceName = persistenceServiceName;
this.buffer = buffer;
}
protected QuerierDbSession getQuerierDbSession() {
return EnvTool.getQuerierDbSession(persistenceServiceName);
}
public ActivityDefinition getActivity(ActivityDefinitionUUID activityDefinitionUUID) {
Misc.checkArgsNotNull(activityDefinitionUUID);
for (PackageFullDefinition pack : buffer.getPackages().values()) {
Collection processes = pack.getProcesses();
if (processes != null) {
for (ProcessFullDefinition process : processes) {
Set activities = process.getActivities();
if (activities != null) {
for (ActivityDefinition activity : activities) {
if (activity.getUUID().equals(activityDefinitionUUID)) {
return activity;
}
}
}
}
}
}
ActivityDefinition dbAD = getQuerierDbSession().getActivityDefinition(activityDefinitionUUID);
if (dbAD == null || buffer.isPackageRemoved(dbAD.getPackageDefinitionUUID())) {
return null;
}
return dbAD;
}
public ActivityFullInstance getActivityInstance(
ProcessInstanceUUID instanceUUID, String activityId, String iterationId,
String activityInstanceId) {
Misc.checkArgsNotNull(instanceUUID, activityId, iterationId, activityInstanceId);
if (buffer.isInstanceRemoved(instanceUUID)) {
return null;
}
ProcessFullInstance processFullInstance = buffer.getInstance(instanceUUID);
if (processFullInstance != null) {
return processFullInstance.getActivity(activityId, iterationId, activityInstanceId);
}
return getQuerierDbSession().getActivityInstance(instanceUUID, activityId, iterationId, activityInstanceId);
}
public ActivityFullInstance getActivityInstance(
ActivityInstanceUUID activityInstanceUUID) {
Misc.checkArgsNotNull(activityInstanceUUID);
for (ProcessFullInstance instance : buffer.getInstances().values()) {
Set> activities = instance.getActivities();
if (activities != null) {
for (ActivityFullInstance activity : activities) {
if (activity.getUUID().equals(activityInstanceUUID)) {
return activity;
}
}
}
}
ActivityFullInstance aFI =
getQuerierDbSession().getActivityInstance(activityInstanceUUID);
if (aFI == null || buffer.isInstanceRemoved(aFI.getProcessInstanceUUID())) {
return null;
}
return aFI;
}
public Set> getActivityInstances(
ProcessInstanceUUID instanceUUID) {
Misc.checkArgsNotNull(instanceUUID);
if (buffer.isInstanceRemoved(instanceUUID)) {
return new HashSet>();
}
Set> activityInstances = null;
ProcessFullInstance processFullInstance = buffer.getInstance(instanceUUID);
if (processFullInstance != null) {
return processFullInstance.getActivities();
}
activityInstances = getQuerierDbSession().getActivityInstances(instanceUUID);
if (activityInstances != null) {
return activityInstances;
}
return new HashSet>();
}
public PackageFullDefinition getPackage(PackageDefinitionUUID packageUUID) {
Misc.checkArgsNotNull(packageUUID);
if (buffer.isPackageRemoved(packageUUID)) {
return null;
}
PackageFullDefinition pack = buffer.getPackage(packageUUID);
if (pack != null) {
return pack;
}
pack = getQuerierDbSession().getPackage(packageUUID);
if (pack != null) {
buffer.addPackage(pack);
}
return pack;
}
public PackageFullDefinition getPackage(String packageId, String version) {
Misc.checkArgsNotNull(packageId, version);
for (PackageFullDefinition pack : buffer.getPackages().values()) {
if (pack.getPackageId().equals(packageId) && pack.getVersion().equals(version)) {
return pack;
}
}
PackageFullDefinition pack = getQuerierDbSession().getPackage(packageId, version);
if (pack == null || buffer.isPackageRemoved(pack.getUUID())) {
return null;
}
return pack;
}
public ProcessFullDefinition getPackageProcess(
PackageDefinitionUUID packageUUID, String processId) {
Misc.checkArgsNotNull(packageUUID, processId);
if (buffer.isPackageRemoved(packageUUID)) {
return null;
}
PackageFullDefinition packageDef = buffer.getPackage(packageUUID);
if (packageDef != null) {
Set processes = packageDef.getProcesses();
for (ProcessFullDefinition process : processes) {
if (process.getProcessId().equals(processId)) {
return process;
}
}
}
return getQuerierDbSession().getPackageProcess(packageUUID, processId);
}
public Set getPackageProcesses(
PackageDefinitionUUID packageUUID) {
Misc.checkArgsNotNull(packageUUID);
if (buffer.isPackageRemoved(packageUUID)) {
return null;
}
PackageFullDefinition packageDef = buffer.getPackage(packageUUID);
if (packageDef != null) {
return packageDef.getProcesses();
}
return getQuerierDbSession().getPackageProcesses(packageUUID);
}
public Set getPackages() {
Set dbPackages = getQuerierDbSession().getPackages();
for (PackageFullDefinition pack : dbPackages) {
if (!buffer.containsPackage(pack.getUUID()) && !buffer.isPackageRemoved(pack.getUUID())) {
buffer.addPackage(pack);
}
}
return buffer.getPackagesSet();
}
public Set getPackages(String packageId) {
Misc.checkArgsNotNull(packageId);
Set dbPackages = getQuerierDbSession().getPackages(packageId);
for (PackageFullDefinition pack : dbPackages) {
if (!buffer.containsPackage(pack.getUUID()) && !buffer.isPackageRemoved(pack.getUUID())) {
buffer.addPackage(pack);
}
}
Set packages = new HashSet();
for (PackageFullDefinition pack : buffer.getPackages().values()) {
if (pack.getPackageId().equals(packageId)) {
packages.add(pack);
}
}
return packages;
}
public Set getPackages(PackageDefinition.PackageState packageState) {
Misc.checkArgsNotNull(packageState);
Set dbPackages = getQuerierDbSession().getPackages(packageState);
for (PackageFullDefinition pack : dbPackages) {
if (!buffer.containsPackage(pack.getUUID()) && !buffer.isPackageRemoved(pack.getUUID())) {
buffer.addPackage(pack);
}
}
Set packages = new HashSet();
for (PackageFullDefinition pack : buffer.getPackages().values()) {
if (PackageDefinition.PackageState.DEPLOYED.equals(packageState) && pack.getUndeployedBy() == null) {
packages.add(pack);
} else if (PackageDefinition.PackageState.UNDEPLOYED.equals(packageState)) {
packages.add(pack);
}
}
return packages;
}
public Set getPackages(String packageId,
PackageDefinition.PackageState packageState) {
Misc.checkArgsNotNull(packageId, packageState);
Set dbPackages = getQuerierDbSession().getPackages(packageId, packageState);
for (PackageFullDefinition pack : dbPackages) {
if (!buffer.containsPackage(pack.getUUID()) && !buffer.isPackageRemoved(pack.getUUID())) {
buffer.addPackage(pack);
}
}
Set packages = new HashSet();
for (PackageFullDefinition pack : buffer.getPackages().values()) {
if (pack.getPackageId().equals(packageId)) {
if (PackageDefinition.PackageState.DEPLOYED.equals(packageState) && pack.getUndeployedBy() == null) {
packages.add(pack);
} else if (PackageDefinition.PackageState.UNDEPLOYED.equals(packageState)) {
packages.add(pack);
}
}
}
return packages;
}
public ProcessFullInstance getProcessInstance(ProcessInstanceUUID instanceUUID) {
Misc.checkArgsNotNull(instanceUUID);
if (buffer.isInstanceRemoved(instanceUUID)) {
return null;
}
ProcessFullInstance processFullInstance = buffer.getInstance(instanceUUID);
if (processFullInstance != null) {
return processFullInstance;
}
processFullInstance = getQuerierDbSession().getProcessInstance(instanceUUID);
if (processFullInstance != null) {
buffer.addInstance(processFullInstance);
}
return processFullInstance;
}
public Set getProcessInstances() {
Set dbInstances = getQuerierDbSession().getProcessInstances();
for (ProcessFullInstance instance : dbInstances) {
if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
buffer.addInstance(instance);
}
}
return buffer.getInstancesSet();
}
public Set getProcessInstances(
ProcessDefinitionUUID processUUID) {
Misc.checkArgsNotNull(processUUID);
Set dbInstances = getQuerierDbSession().getProcessInstances(processUUID);
for (ProcessFullInstance instance : dbInstances) {
if (!buffer.containsInstance(instance.getUUID()) && !buffer.isInstanceRemoved(instance.getUUID())) {
buffer.addInstance(instance);
}
}
Set instances = new HashSet();
for (ProcessFullInstance instance : buffer.getInstances().values()) {
if (instance.getProcessDefinitionUUID().equals(processUUID)) {
instances.add(instance);
}
}
return instances;
}
public Set getProcesses(String processId, String version) {
Misc.checkArgsNotNull(processId, version);
Set processes = getQuerierDbSession().getProcesses(processId, version);
return mergeBuffer(processes);
}
public ProcessFullDefinition getProcess(String packageId, String processId, String version) {
Misc.checkArgsNotNull(packageId, processId, version);
for (PackageFullDefinition pack : buffer.getPackages(packageId).values()) {
Set processes = pack.getProcesses();
if (processes != null && !processes.isEmpty()) {
for (ProcessFullDefinition process : processes) {
if (process.getProcessId().equals(processId) && process.getVersion().equals(version)) {
return process;
}
}
}
}
ProcessFullDefinition process = getQuerierDbSession().getProcess(packageId, processId, version);
if (process == null || buffer.isPackageRemoved(process.getPackageDefinitionUUID())) {
return null;
}
return process;
}
public ProcessFullDefinition getProcess(ProcessDefinitionUUID processUUID) {
Misc.checkArgsNotNull(processUUID);
for (PackageFullDefinition pack : buffer.getPackages().values()) {
Set processes = pack.getProcesses();
if (processes != null && !processes.isEmpty()) {
for (ProcessFullDefinition process : processes) {
if (process.getUUID().equals(processUUID)) {
return process;
}
}
}
}
ProcessFullDefinition process = getQuerierDbSession().getProcess(processUUID);
if (process == null || buffer.isPackageRemoved(process.getPackageDefinitionUUID())) {
return null;
}
return process;
}
public Set getProcesses() {
Set processes = getQuerierDbSession().getProcesses();
return mergeBuffer(processes);
}
public Set getProcesses(String processId) {
Misc.checkArgsNotNull(processId);
Set processes = getQuerierDbSession().getProcesses(processId);
return mergeBuffer(processes);
}
public Set getProcesses(ProcessDefinition.ProcessState processState) {
Misc.checkArgsNotNull(processState);
Set processes = getQuerierDbSession().getProcesses(processState);
return mergeBuffer(processes);
}
public Set getProcesses(String processId,
ProcessDefinition.ProcessState processState) {
Misc.checkArgsNotNull(processId, processState);
Set processes = getQuerierDbSession().getProcesses(processId, processState);
return mergeBuffer(processes);
}
public Set getPackageProcesses(String packageId, String processId) {
Misc.checkArgsNotNull(packageId, processId);
Set processes = getQuerierDbSession().getProcesses(packageId, processId);
return mergeBuffer(processes);
}
public Set getProcesses(String packageId,
String processId, ProcessDefinition.ProcessState processState) {
Misc.checkArgsNotNull(packageId, processId, processState);
Set processes = getQuerierDbSession().getProcesses(packageId, processId, processState);
return mergeBuffer(processes);
}
@SuppressWarnings("unchecked")
public ActivityFullInstance getTaskInstance(TaskUUID taskUUID) {
Misc.checkArgsNotNull(taskUUID);
for (ProcessFullInstance instance : buffer.getInstances().values()) {
Set> activities = instance.getActivities();
if (activities != null) {
for (ActivityFullInstance< ? > activity : activities) {
if (activity.getBody() != null && activity.getBody().getUUID().equals(taskUUID)) {
return (ActivityFullInstance) activity;
}
}
}
}
ActivityFullInstance aFI =
getQuerierDbSession().getTaskInstance(taskUUID);
if (aFI == null || buffer.isInstanceRemoved(aFI.getProcessInstanceUUID())) {
return null;
}
return aFI;
}
@SuppressWarnings("unchecked")
public Set> getTaskInstances(
ProcessInstanceUUID instanceUUID) {
Misc.checkArgsNotNull(instanceUUID);
if (buffer.isInstanceRemoved(instanceUUID)) {
return new HashSet>();
}
Set>taskActivities = new HashSet>();
ProcessFullInstance instance = buffer.getInstance(instanceUUID);
if (instance != null) {
Set> activities = instance.getActivities();
if (activities != null) {
for (ActivityFullInstance< ? > activity : activities) {
if (activity.getBody() != null && activity.getBody() instanceof TaskInstance) {
taskActivities.add((ActivityFullInstance) activity);
}
}
}
return taskActivities;
}
return getQuerierDbSession().getTaskInstances(instanceUUID);
}
public Set> getUserInstanceTasks(
String userId, ProcessInstanceUUID instanceUUID, ActivityState taskState) {
Misc.checkArgsNotNull(userId, instanceUUID, taskState);
if (buffer.isInstanceRemoved(instanceUUID)) {
return new HashSet>();
}
Set> taskActivities = new HashSet>();
ProcessFullInstance instance = buffer.getInstance(instanceUUID);
if (instance != null) {
taskActivities.addAll(QuerierUtil.getUserTasks(instance.getActivities(), userId, taskState));
return taskActivities;
}
return getQuerierDbSession().getUserInstanceTasks(userId, instanceUUID, taskState);
}
public Set> getUserTasks(String userId,
ActivityState taskState) {
Misc.checkArgsNotNull(userId, taskState);
Set> bufferTaskActivities =
new HashSet>();
for (ProcessFullInstance instance : buffer.getInstances().values()) {
bufferTaskActivities.addAll(QuerierUtil.getUserTasks(instance.getActivities(), userId, taskState));
}
Map> taskActivities =
new HashMap>();
for (ActivityFullInstance taskActivity : bufferTaskActivities) {
taskActivities.put(taskActivity.getUUID(), taskActivity);
}
Set> dbTaskActivities = getQuerierDbSession().getUserTasks(userId, taskState);
if (dbTaskActivities != null) {
for (ActivityFullInstance activity : dbTaskActivities) {
if (!buffer.isInstanceRemoved(activity.getProcessInstanceUUID()) && !taskActivities.containsKey(activity.getUUID())) {
taskActivities.put(activity.getUUID(), activity);
}
}
}
Set> result = new HashSet>();
result.addAll(taskActivities.values());
return result;
}
/*
*SPECIFIC
*/
public Set getDependentPackages(PackageDefinitionUUID packageUUID) {
Misc.checkArgsNotNull(packageUUID);
Set uuidDeps = new HashSet();
Set deps = getQuerierDbSession().getDependentPackages(packageUUID);
if (deps != null) {
for (PackageFullDefinition pack : deps) {
uuidDeps.add(pack.getUUID());
if (buffer.isPackageRemoved(pack.getUUID())) {
deps.remove(pack);
}
}
}
if (deps == null) {
deps = new HashSet();
}
for (PackageFullDefinition pack : buffer.getPackages().values()) {
boolean isDep = !pack.getPackageDefinitionUUID().equals(packageUUID)
&& pack.getPackageDependencies() != null && pack.getPackageDependencies().contains(packageUUID);
if (isDep && !uuidDeps.contains(pack.getUUID())) {
uuidDeps.add(pack.getUUID());
deps.add(pack);
}
}
return deps;
}
public PackageFullDefinition getLastDeployedPackage(String packageId, PackageDefinition.PackageState packageState) {
Misc.checkArgsNotNull(packageId);
PackageFullDefinition last = getQuerierDbSession().getLastDeployedPackage(packageId, packageState);
for (PackageFullDefinition pack : buffer.getPackages().values()) {
boolean match = false;
if (pack.getPackageId().equals(packageId)) {
if (PackageDefinition.PackageState.DEPLOYED.equals(packageState) && pack.getUndeployedBy() == null) {
match = true;
} else if (PackageDefinition.PackageState.UNDEPLOYED.equals(packageState)) {
match = true;
}
}
if (match && (last == null || pack.getDeployedDate().after(last.getDeployedDate()))) {
last = pack;
}
}
return last;
}
public ProcessFullDefinition getLastDeployedProcess(
String packageId, String processId, ProcessDefinition.ProcessState processState) {
Misc.checkArgsNotNull(packageId, processId, processState);
ProcessFullDefinition lastProcess = getQuerierDbSession().getLastDeployedProcess(packageId, processId, processState);
if (lastProcess == null || buffer.isPackageRemoved(lastProcess.getPackageDefinitionUUID())) {
return null;
}
return lastProcess;
}
private Set mergeBuffer(Set processes) {
if (processes == null) {
return new HashSet();
}
for (ProcessFullDefinition process : processes) {
if (buffer.isPackageRemoved(process.getPackageDefinitionUUID())) {
processes.remove(process);
}
}
return processes;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy