//----------------------------BEGIN LICENSE----------------------------
/*
* Willow : the Open Source WorkFlow Project
* Distributable under GNU LGPL license by gun.org
*
* Copyright (C) 2004-2010 huihoo.org
* Copyright (C) 2004-2010 ZosaTapo <dertyang@hotmail.com>
*
* ====================================================================
* Project Homepage : http://www.huihoo.org/willow
* Source Forge : http://sourceforge.net/projects/huihoo
* Mailing list : willow@lists.sourceforge.net
*/
//----------------------------END LICENSE-----------------------------
package org.huihoo.workflow.impl.store.spi;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.huihoo.workflow.WorkflowException;
import org.huihoo.workflow.store.SchemaContext;
import org.huihoo.workflow.store.spi.SpiCaseIdGenerator;
import org.huihoo.workflow.usermodel.WorkflowParticipant;
import org.huihoo.workflow.runtime.WorkflowCaseContext;
import org.huihoo.workflow.runtime.Constants;
import org.huihoo.workflow.runtime.WorkflowCase;
import org.huihoo.workflow.runtime.WorkflowPath;
import org.huihoo.workflow.runtime.WorkflowWork;
import org.huihoo.workflow.xpdl.WorkflowActivity;
import org.huihoo.workflow.xpdl.WorkflowPackage;
import org.huihoo.workflow.xpdl.WorkflowParameter;
import org.huihoo.workflow.xpdl.WorkflowProcess;
import org.huihoo.workflow.xpdl.WorkflowTransition;
import org.huihoo.workflow.xpdl.event.WorkflowActivityEvent;
import org.huihoo.workflow.xpdl.event.WorkflowProcessEvent;
import org.huihoo.workflow.xpdl.util.DateTools;
import org.huihoo.workflow.xpdl.util.TypeDefinition;
import org.huihoo.workflow.impl.usermodel.WorkflowParticipantImpl;
import org.huihoo.workflow.impl.store.util.ContexManager;
import org.huihoo.workflow.impl.runtime.WorkflowCaseImpl;
import org.huihoo.workflow.impl.runtime.WorkflowPathImpl;
import org.huihoo.workflow.impl.runtime.PrimaryKeyImpl;
import org.huihoo.workflow.impl.runtime.SubWorkImpl;
import org.huihoo.workflow.impl.runtime.WorkflowWorkImpl;
import com.zosatapo.commons.store.ConnUtils;
import com.zosatapo.commons.store.Store;
/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window - Preferences - Java - Code Generation - Code and Comments
*/
class InternalCaseDatabase
{
InternalCaseDatabase()
{
}
//------------------------------------------------------------
//
//------------------------------------------------------------
String createCase_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,
WorkflowProcess workflowProcess,
Connection conn,
boolean canRelease,
WorkflowParticipant creator,
Date creationTime,
String primaryKey,
String name,
String description)
throws WorkflowException
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
PreparedStatement pstmt = null;
String caseId = null;
try
{
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
caseId = caseIdGenerator.genWorkflowCaseID(pkgId, processId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ "(vc_packageid,vc_processid,vc_uuid,vc_primarykey,vc_creator,dat_creationTime,int_status,vc_name,vc_description) "
+ "VALUES(?,?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, primaryKey);
pstmt.setString(5, creator.getUUID());
pstmt.setTimestamp(6, DateTools.toSqlTimestamp(creationTime));
pstmt.setInt(7, Constants.CASE_STATUS_CREATED);
pstmt.setString(8, name);
pstmt.setString(9, description);
pstmt.executeUpdate();
createCaseEvent_impl(gCaseDatabaseImpl,workflowProcess,conn,false,pkgId,processId,caseId,creator,new Date(),WorkflowProcessEvent.CASE_CREATE,"");
WorkflowActivity beginActivity = workflowProcess.getBeginActivity();
List outTrans = beginActivity.getOutgoingTransitions();
WorkflowTransition firstTransition = (WorkflowTransition) outTrans.get(0);
WorkflowParticipant operator=creator;
WorkflowActivity firstActivity = firstTransition.getToWorkflowActivity();
String workId =
createWork(gCaseDatabaseImpl,operator,conn, workflowProcess, caseId, firstActivity, creator, creationTime);
createPath(gCaseDatabaseImpl,workflowProcess,operator,conn, caseId, null, workId, WorkflowActivityEvent.WORK_DISPATCH);
createCaseContext(gCaseDatabaseImpl,workflowProcess,operator,conn, caseId);
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return caseId;
}
WorkflowCase findCase_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,String caseId, boolean isPK) throws WorkflowException
{
WorkflowCaseImpl workflowCase = null;
ResultSet jrs = null;
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String strSQL = null;
if (isPK)
{
strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "WHERE vc_packageId=? AND vc_processid=? AND vc_primaryKey=?";
}
else
{
strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "WHERE vc_packageId=? AND vc_processid=? AND vc_uuid=?";
}
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
jrs = pstmt.executeQuery();
if (jrs.next())
{
workflowCase = new WorkflowCaseImpl();
workflowCase.setWorkflowProcess(workflowProcess);
workflowCase.setName(jrs.getString("vc_name"));
workflowCase.setUUID(jrs.getString("vc_uuid"));
workflowCase.setCreationTime(DateTools.toJavaDate(jrs.getTimestamp("dat_creationTime")));
workflowCase.setStatus(jrs.getInt("int_status"));
workflowCase.setCreator(
gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(
jrs.getString("vc_creator")));
workflowCase.setPrimaryKey(new PrimaryKeyImpl(jrs.getString("vc_primaryKey")));
WorkflowCaseContext caseContext =
ContexManager.fetchContext(storeConfig, schemaContext, workflowCase);
workflowCase.setCaseContext(caseContext);
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workflowCase;
}
void updateCase_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, boolean canRelease, WorkflowCase workflowCase)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String strSQL =
"UPDATE "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "SET vc_name=?,"
+ "vc_description=?,"
+ "dat_creationTime=?,"
+ "vc_primaryKey=?,"
+ "vc_creator=?,"
+ "int_status=? "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_uuid=?";
conn = ConnUtils.getConnection(storeConfig);
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, workflowCase.getName());
pstmt.setString(2, workflowCase.getDescription());
pstmt.setTimestamp(3, DateTools.toSqlTimestamp(workflowCase.getCreationTime()));
pstmt.setString(4, workflowCase.getPrimaryKey().getUUID());
pstmt.setString(5, workflowCase.getCreator().getUUID());
pstmt.setInt(6, workflowCase.getStatus());
pstmt.setString(7, packageId);
pstmt.setString(8, processId);
pstmt.setString(9, workflowCase.getUUID());
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
void deleteCase_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, boolean canRelease, WorkflowCase workflowCase)
throws WorkflowException
{
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
PreparedStatement pstmt3 = null;
PreparedStatement pstmt4 = null;
PreparedStatement pstmt5 = null;
PreparedStatement pstmt6 = null;
PreparedStatement pstmt7 = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
if (canRelease)
{
conn.setAutoCommit(false);
}
String strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_uuid=?";
pstmt1 = conn.prepareStatement(strSQL);
pstmt1.setString(1, packageId);
pstmt1.setString(2, processId);
pstmt1.setString(3, workflowCase.getUUID());
pstmt1.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_DATAFIELD)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt2 = conn.prepareStatement(strSQL);
pstmt2.setString(1, packageId);
pstmt2.setString(2, processId);
pstmt2.setString(3, workflowCase.getUUID());
pstmt2.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt3 = conn.prepareStatement(strSQL);
pstmt3.setString(1, packageId);
pstmt3.setString(2, processId);
pstmt3.setString(3, workflowCase.getUUID());
pstmt3.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt4 = conn.prepareStatement(strSQL);
pstmt4.setString(1, packageId);
pstmt4.setString(2, processId);
pstmt4.setString(3, workflowCase.getUUID());
pstmt4.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_EVENT)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt5 = conn.prepareStatement(strSQL);
pstmt5.setString(1, packageId);
pstmt5.setString(2, processId);
pstmt5.setString(3, workflowCase.getUUID());
pstmt5.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK_EVENT)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt6 = conn.prepareStatement(strSQL);
pstmt6.setString(1, packageId);
pstmt6.setString(2, processId);
pstmt6.setString(3, workflowCase.getUUID());
pstmt6.executeUpdate();
strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_ACTIVITY_DISPATCH)
+ " "
+ "WHERE vc_packageId=? "
+ "AND vc_processid=? "
+ "AND vc_caseid=?";
pstmt7 = conn.prepareStatement(strSQL);
pstmt7.setString(1, packageId);
pstmt7.setString(2, processId);
pstmt7.setString(3, workflowCase.getUUID());
pstmt7.executeUpdate();
createCaseEvent_impl(gCaseDatabaseImpl,workflowProcess,conn,false,workflowCase,operator,new Date(),WorkflowProcessEvent.CASE_DELETE,"");
if (canRelease)
{
conn.commit();
}
}
catch (SQLException sqlex)
{
if (canRelease)
{
try
{
conn.rollback();
}
catch (SQLException ex)
{
}
}
throw new WorkflowException(sqlex);
}
finally
{
ConnUtils.cleanupNoThrow(pstmt1);
ConnUtils.cleanupNoThrow(pstmt2);
ConnUtils.cleanupNoThrow(pstmt3);
ConnUtils.cleanupNoThrow(pstmt4);
ConnUtils.cleanupNoThrow(pstmt5);
ConnUtils.cleanupNoThrow(pstmt6);
ConnUtils.cleanupNoThrow(pstmt7);
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn);
}
}
}
void changeCase_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
int caseStatus)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String strSQL =
"UPDATE "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "SET int_status=?"
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_uuid=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setInt(1, caseStatus);
pstmt.setString(2, packageId);
pstmt.setString(3, processId);
pstmt.setString(4, workflowCase.getUUID());
pstmt.executeUpdate();
//FIX ME!!! read operator from LoginContext
int eventType=WorkflowProcessEvent.CASE_OPEN;
switch(caseStatus)
{
case Constants.CASE_STATUS_CREATED:
eventType=WorkflowProcessEvent.CASE_CREATE;
break;
case Constants.CASE_STATUS_RUNNING:
eventType=WorkflowProcessEvent.CASE_RESUME;
break;
case Constants.CASE_STATUS_SUSPENDED:
eventType=WorkflowProcessEvent.CASE_SUSPEND;
break;
case Constants.CASE_STATUS_CANCELED:
eventType=WorkflowProcessEvent.CASE_CANCEL;
break;
case Constants.CASE_STATUS_CLOSED:
eventType=WorkflowProcessEvent.CASE_CLOSE;
break;
}
createCaseEvent_impl(gCaseDatabaseImpl,workflowProcess,conn,false,workflowCase,operator,new Date(),eventType,"");
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
String createWork_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowActivity activity,
WorkflowParticipant performer,
Date arriveTime)
throws WorkflowException
{
PreparedStatement pstmt = null;
String workId = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
workId = caseIdGenerator.genWorkflowWorkID(packageId, processId, caseId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ "(vc_packageid,vc_processid,vc_caseid,vc_owner_processid,vc_activityid,vc_uuid,vc_performer,dat_arriveTime) "
+ "VALUES(?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, activity.getWorkflowProcess().getUUID());
pstmt.setString(5, activity.getUUID());
pstmt.setString(6, workId);
pstmt.setString(7, notNullPerformer(performer).getUUID());
pstmt.setTimestamp(8, DateTools.toSqlTimestamp(arriveTime));
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workId;
}
String createSubWork_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowActivity activity,
WorkflowWork parentWork,
WorkflowParticipant performer,
java.util.Date arriveTime)
throws WorkflowException
{
PreparedStatement pstmt = null;
String workId = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
workId = caseIdGenerator.genWorkflowWorkID(pkgId, processId, caseId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ "(vc_packageid,vc_processid,vc_caseid,vc_owner_processid,vc_activityid,vc_uuid,vc_performer,dat_arriveTime,vc_parent_workid) "
+ "VALUES(?,?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, activity.getWorkflowProcess().getUUID());
pstmt.setString(5, activity.getUUID());
pstmt.setString(6, workId);
pstmt.setString(7, notNullPerformer(performer).getUUID());
pstmt.setTimestamp(8, DateTools.toSqlTimestamp(arriveTime));
pstmt.setString(9, parentWork.getUUID());
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workId;
}
void updateWork_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, boolean canRelease, WorkflowWork workflowWork)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowCase workflowCase = workflowWork.getWorkflowCase();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String workId = workflowWork.getUUID();
String strSQL =
"UPDATE "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "SET vc_performer=?,"
+ "dat_arriveTime=?,"
+ "dat_acceptTime=?,"
+ "dat_dispatchTime=?, "
+ "vc_entityId=? "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseid=?"
+ " "
+ "AND vc_uuid=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, notNullPerformer(workflowWork.getPerformer()).getUUID());
pstmt.setTimestamp(2, DateTools.toSqlTimestamp(workflowWork.getArriveTime()));
pstmt.setTimestamp(3, DateTools.toSqlTimestamp(workflowWork.getAcceptTime()));
pstmt.setTimestamp(4, DateTools.toSqlTimestamp(workflowWork.getDispatchTime()));
pstmt.setString(5, workflowWork.getEntityID());
pstmt.setString(6, packageId);
pstmt.setString(7, processId);
pstmt.setString(8, caseId);
pstmt.setString(9, workId);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
void deleteWork_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, boolean canRelease, WorkflowWork workflowWork)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowCase workflowCase = workflowWork.getWorkflowCase();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String workId = workflowWork.getUUID();
String strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseid=?"
+ " "
+ "AND vc_uuid=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, workId);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
WorkflowWork findWork_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowCase workflowCase, String workId) throws WorkflowException
{
WorkflowWorkImpl workflowWork = null;
PreparedStatement pstmt = null;
ResultSet jrs = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String packageId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseId=?"
+ " "
+ "AND vc_uuId=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, workId);
jrs = pstmt.executeQuery();
String parent_workId = null;
String vc_performer = null;
String vc_activityId = null;
String vc_owner_processId = null;
WorkflowProcess ownerProcess = null;
if (jrs.next())
{
parent_workId = jrs.getString("vc_parent_workId");
vc_performer = jrs.getString("vc_performer");
vc_activityId = jrs.getString("vc_activityId");
vc_owner_processId=jrs.getString("vc_owner_processId");
if (parent_workId == null)
{
workflowWork = new WorkflowWorkImpl();
workflowWork.setWorkflowCase(workflowCase);
workflowWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowWork.setDispatchTime(DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
}
else
{
SubWorkImpl workflowSubWork = new SubWorkImpl();
workflowSubWork.setWorkflowCase(workflowCase);
workflowSubWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowSubWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowSubWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowSubWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowSubWork.setDispatchTime(
DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
workflowSubWork.setParentWorkflowWork(findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowCase, parent_workId));
workflowWork = workflowSubWork;
}
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workflowWork;
}
String createPath_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowWork fromWork,
WorkflowWork toWork,
String batchNo,
int eventType)
throws WorkflowException
{
PreparedStatement pstmt = null;
String pathId = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String transitionId=null;
String owner_processId=null;
WorkflowActivity fromActivity=(fromWork!=null)?fromWork.getWorkflowActivity():null;
WorkflowActivity toActivity=(toWork!=null)?toWork.getWorkflowActivity():null;
if(fromActivity!=null && toActivity!=null)
{
WorkflowProcess owner_process=fromActivity.getWorkflowProcess();
owner_processId=owner_process.getUUID();
transitionId=owner_process.findWorkflowTransition(fromActivity,toActivity).getUUID();
}
pathId = caseIdGenerator.genWorkflowPathID(pkgId, processId, caseId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ "(vc_packageid,vc_processid,vc_caseId,vc_uuid,vc_from,vc_to,vc_batchNo,int_eventType,vc_owner_processid,vc_transitionId) "
+ "VALUES(?,?,?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, pathId);
pstmt.setString(5, (fromWork == null) ? null : fromWork.getUUID());
pstmt.setString(6, (toWork == null) ? null : toWork.getUUID());
pstmt.setString(7, batchNo);
pstmt.setInt(8, eventType);
pstmt.setString(9, owner_processId);
pstmt.setString(10, transitionId);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return pathId;
}
WorkflowPath findPath_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowCase workflowCase, String pathId) throws WorkflowException
{
WorkflowPathImpl workflowPath = null;
ResultSet jrs = null;
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String packageId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseId=?"
+ " "
+ "AND vc_uuid=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, pathId);
jrs = pstmt.executeQuery();
if (jrs.next())
{
workflowPath = new WorkflowPathImpl();
workflowPath.setUUID(jrs.getString("vc_uuid"));
workflowPath.setBacthNo(jrs.getString("vc_batchNo"));
workflowPath.setEventType(jrs.getInt("int_eventType"));
workflowPath.setFromWorkflowWork(findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowCase, jrs.getString("vc_from")));
workflowPath.setToWorkflowWork(findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowCase, jrs.getString("vc_to")));
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workflowPath;
}
void deletePath_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, boolean canRelease, WorkflowPath workflowPath)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowCase workflowCase = workflowPath.getFromWorkflowWork().getWorkflowCase();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"DELETE FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseId=?"
+ " "
+ "AND vc_uuid=?";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, workflowPath.getUUID());
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
void createCaseEvent_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,
Connection conn,
boolean canRelease,
String packageId,
String processId,
String caseId,
WorkflowParticipant operator,
Date opTime,
int eventType,
String description)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_EVENT)
+ "(vc_packageid,vc_processid,vc_caseid,int_type,vc_operator,dat_opTime,vc_description) "
+ "VALUES(?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setInt(4, eventType);
pstmt.setString(5, operator.getUUID());
pstmt.setTimestamp(6, DateTools.toSqlTimestamp(opTime));
pstmt.setString(7, description);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
void createCaseEvent_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowParticipant operator,
Date opTime,
int eventType,
String description)
throws WorkflowException
{
PreparedStatement pstmt = null;
String caseId = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
caseId = workflowCase.getUUID();
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_EVENT)
+ "(vc_packageid,vc_processid,vc_caseid,int_type,vc_operator,dat_opTime,vc_description) "
+ "VALUES(?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setInt(4, eventType);
pstmt.setString(5, operator.getUUID());
pstmt.setTimestamp(6, DateTools.toSqlTimestamp(opTime));
pstmt.setString(7, description);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
public void createWorkEvent_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,
Connection conn,
boolean canRelease,
WorkflowWork workflowWork,
WorkflowParticipant operator,
Date opTime,
int eventType,
String description)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowCase workflowCase = workflowWork.getWorkflowCase();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String workId = workflowWork.getUUID();
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK_EVENT)
+ "(vc_packageid,vc_processid,vc_caseid,int_type,vc_operator,dat_opTime,vc_workid,vc_description) "
+ "VALUES(?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setInt(4, eventType);
pstmt.setString(5, notNullPerformer(operator).getUUID());
pstmt.setTimestamp(6, DateTools.toSqlTimestamp(opTime));
pstmt.setString(7, workId);
pstmt.setString(8, description);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
void createCaseParameter_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowParameter parameter)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_DATAFIELD)
+ "(vc_packageid,vc_processid,vc_caseid,vc_uuid,vc_type,vc_value) "
+ "VALUES(?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, parameter.getUUID());
pstmt.setString(5, TypeDefinition.javaToXPDL(parameter.getType()));
pstmt.setString(6, valueOf(parameter.getValue()));
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
public void updateCaseParameter_impl(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
boolean canRelease,
WorkflowCase workflowCase,
WorkflowParameter parameter)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String paramId = parameter.getUUID();
String strSQL =
"UPDATE "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_DATAFIELD)
+ " "
+ "SET vc_value=? "
+ "WHERE vc_packageId='"
+ packageId
+ "' "
+ "AND vc_processid='"
+ processId
+ "' "
+ "AND vc_caseid='"
+ caseId
+ "' "
+ "AND vc_uuid='"
+ paramId
+ "'";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, valueOf(parameter.getValue()));
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
String valueOf(Object obj)
{
return (obj == null) ? "" : obj.toString();
}
String createWork(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowParticipant operator,
Connection conn,
WorkflowProcess workflowProcess,
String caseId,
WorkflowActivity activity,
WorkflowParticipant performer,
Date arriveTime)
throws WorkflowException
{
PreparedStatement pstmt = null;
String workId = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
workId = caseIdGenerator.genWorkflowWorkID(pkgId, processId, caseId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ "(vc_packageid,vc_processid,vc_caseid,vc_owner_processid,vc_activityid,vc_uuid,vc_performer,dat_arriveTime,dat_acceptTime) "
+ "VALUES(?,?,?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, activity.getWorkflowProcess().getUUID());
pstmt.setString(5, activity.getUUID());
pstmt.setString(6, workId);
pstmt.setString(7, notNullPerformer(performer).getUUID());
pstmt.setTimestamp(8, DateTools.toSqlTimestamp(arriveTime));
pstmt.setTimestamp(9, DateTools.toSqlTimestamp(arriveTime));
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
sqlex.printStackTrace();
throw new WorkflowException(sqlex);
}
finally
{
ConnUtils.cleanupNoThrow(pstmt);
}
return workId;
}
void createPath(
SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,
Connection conn,
String caseId,
String fromWorkId,
String toWorkId,
int eventType)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
String pkgId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String pathId = caseIdGenerator.genWorkflowPathID(pkgId, processId, caseId);
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ "(vc_packageid,vc_processid,vc_caseId,vc_uuid,vc_from,vc_to,int_eventType) "
+ "VALUES(?,?,?,?,?,?,?)";
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, pathId);
pstmt.setString(5, fromWorkId);
pstmt.setString(6, toWorkId);
pstmt.setInt(7, eventType);
pstmt.executeUpdate();
}
catch (SQLException sqlex)
{
sqlex.printStackTrace();
throw new WorkflowException(sqlex);
}
finally
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
void createCaseContext(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn, String caseId)
throws WorkflowException
{
PreparedStatement pstmt = null;
try
{
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String pkgId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String strSQL =
"INSERT INTO "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE_DATAFIELD)
+ "(vc_packageid,vc_processid,vc_caseid,vc_uuid,vc_type,vc_value) "
+ "VALUES(?,?,?,?,?,?)";
List paramList = workflowPackage.getWorkflowParameters();
int sizeParam = paramList.size();
if (sizeParam > 0)
{
pstmt = conn.prepareStatement(strSQL);
for (int i = 0; i < sizeParam; ++i)
{
WorkflowParameter parameter = (WorkflowParameter) paramList.get(i);
pstmt.setString(1, pkgId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, parameter.getUUID());
pstmt.setString(5,TypeDefinition.javaToXPDL(parameter.getType()));
pstmt.setString(6, valueOf(parameter.getValue()));
pstmt.addBatch();
}
pstmt.executeBatch();
}
}
catch (SQLException sqlex)
{
sqlex.printStackTrace();
throw new WorkflowException(sqlex);
}
finally
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
public List getCaseList_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowParticipant creator) throws WorkflowException
{
WorkflowCaseImpl workflowCase = null;
ResultSet jrs = null;
PreparedStatement pstmt = null;
ArrayList caseList = new ArrayList();
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
String packageId = workflowProcess.getWorkflowPackage().getUUID();
String processId = workflowProcess.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_CASE)
+ " "
+ "WHERE vc_packageId=? AND vc_processid=? AND vc_creator=?";;
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, creator.getUUID());
jrs = pstmt.executeQuery();
while (jrs.next())
{
workflowCase = new WorkflowCaseImpl();
workflowCase.setName(jrs.getString("vc_name"));
workflowCase.setUUID(jrs.getString("vc_uuid"));
workflowCase.setCreationTime(DateTools.toJavaDate(jrs.getTimestamp("dat_creationTime")));
workflowCase.setStatus(jrs.getInt("int_status"));
workflowCase.setCreator(
gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(jrs.getString("vc_creator")));
workflowCase.setPrimaryKey(new PrimaryKeyImpl(jrs.getString("vc_primaryKey")));
WorkflowCaseContext caseContext =
ContexManager.fetchContext(storeConfig, schemaContext, workflowCase);
workflowCase.setCaseContext(caseContext);
caseList.add(workflowCase);
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return caseList;
}
public List getWorkList_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowParticipant performer, int itemStatus) throws WorkflowException
{
ArrayList workList = new ArrayList();
WorkflowWorkImpl workflowWork = null;
PreparedStatement pstmt = null;
ResultSet jrs = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String packageId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_performer=?";
switch (itemStatus)
{
case Constants.WORK_STATUS_ARRIVED :
strSQL += " AND (dat_arriveTime IS NOT NULL) AND (dat_acceptTime IS NULL) ";
break;
case Constants.WORK_STATUS_ACCEPTED :
strSQL += " AND (dat_acceptTime IS NOT NULL) AND (dat_dispatchTime IS NULL) ";
break;
case Constants.WORK_STATUS_DISPATCHED :
strSQL += " AND (dat_dispatchTime IS NOT NULL)";
break;
default :
throw new WorkflowException("Unkown workflowWork status : " + itemStatus);
//break;
}
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, notNullPerformer(performer).getUUID());
jrs = pstmt.executeQuery();
String parent_workId = null;
String vc_performer = null;
String vc_caseId = null;
String vc_activityId = null;
String vc_owner_processId = null;
WorkflowProcess ownerProcess = null;
while (jrs.next())
{
parent_workId = jrs.getString("vc_parent_workId");
vc_performer = jrs.getString("vc_performer");
vc_activityId = jrs.getString("vc_activityId");
vc_owner_processId = jrs.getString("vc_owner_processId");
vc_caseId = jrs.getString("vc_caseId");
if (parent_workId == null)
{
workflowWork = new WorkflowWorkImpl();
workflowWork.setWorkflowCase(findCase_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,vc_caseId, false));
workflowWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowWork.setDispatchTime(DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
workflowWork.setPerformer(
gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(
vc_performer));
}
else
{
SubWorkImpl workflowSubWork = new SubWorkImpl();
workflowSubWork.setWorkflowCase(findCase_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,vc_caseId, false));
workflowSubWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowSubWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowSubWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowSubWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowSubWork.setDispatchTime(
DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
workflowWork.setPerformer(
gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(
vc_performer));
workflowSubWork.setParentWorkflowWork(
findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowSubWork.getWorkflowCase(), parent_workId));
workflowWork = workflowSubWork;
}
workList.add(workflowWork);
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workList;
}
public List getWorkList_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowCase workflowCase, WorkflowParticipant performer, int itemStatus)
throws WorkflowException
{
ArrayList workList = new ArrayList();
WorkflowWorkImpl workflowWork = null;
PreparedStatement pstmt = null;
ResultSet jrs = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String packageId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_WORK)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseid=?"
+ " "
+ "AND vc_performer=?";
switch (itemStatus)
{
case Constants.WORK_STATUS_ARRIVED :
strSQL += " AND (dat_arriveTime IS NOT NULL) AND (dat_acceptTime IS NULL) ";
break;
case Constants.WORK_STATUS_ACCEPTED :
strSQL += " AND (dat_acceptTime IS NOT NULL) AND (dat_dispatchTime IS NULL) ";
break;
case Constants.WORK_STATUS_DISPATCHED :
strSQL += " AND (dat_dispatchTime IS NOT NULL)";
break;
default :
throw new WorkflowException("Unkown workflowWork status : " + itemStatus);
//break;
}
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, notNullPerformer(performer).getUUID());
jrs = pstmt.executeQuery();
String parent_processId = null;
String parent_workId = null;
String vc_performer = null;
String vc_activityId = null;
String vc_owner_processId = null;
WorkflowProcess ownerProcess = null;
while (jrs.next())
{
parent_workId = jrs.getString("vc_parent_workId");
vc_performer = jrs.getString("vc_performer");
vc_activityId = jrs.getString("vc_activityId");
vc_owner_processId = jrs.getString("vc_owner_processId");
if (parent_workId == null)
{
workflowWork = new WorkflowWorkImpl();
workflowWork.setWorkflowCase(workflowCase);
workflowWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowWork.setDispatchTime(DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
workflowWork.setPerformer(
gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(vc_performer));
}
else
{
SubWorkImpl workflowSubWork = new SubWorkImpl();
workflowSubWork.setWorkflowCase(workflowCase);
workflowSubWork.setUUID(jrs.getString("vc_uuid"));
ownerProcess = workflowPackage.findWorkflowProcess(vc_owner_processId);
workflowSubWork.setWorkflowActivity(ownerProcess.findWorkflowActivity(vc_activityId));
workflowSubWork.setArriveTime(DateTools.toJavaDate(jrs.getTimestamp("dat_arriveTime")));
workflowSubWork.setAcceptTime(DateTools.toJavaDate(jrs.getTimestamp("dat_acceptTime")));
workflowSubWork.setDispatchTime(
DateTools.toJavaDate(jrs.getTimestamp("dat_dispatchTime")));
workflowWork.setPerformer(gCaseDatabaseImpl.getWorkflowService().getUserDatabase().findParticipant(vc_performer));
workflowSubWork.setParentWorkflowWork(findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowCase, parent_workId));
workflowWork = workflowSubWork;
}
workList.add(workflowWork);
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return workList;
}
public List getPathList_impl(SpiCaseDatabaseImpl gCaseDatabaseImpl,WorkflowProcess workflowProcess,WorkflowParticipant operator,Connection conn,boolean canRelease,WorkflowWork workflowWork, boolean isInPath)
throws WorkflowException
{
ArrayList pathList = new ArrayList();
WorkflowPathImpl workflowPath = null;
PreparedStatement pstmt = null;
ResultSet jrs = null;
try
{
SpiCaseIdGenerator caseIdGenerator=gCaseDatabaseImpl.getCaseIdGenerator();
SchemaContext schemaContext=gCaseDatabaseImpl.getSchemaContext();
Store storeConfig= gCaseDatabaseImpl.getStore();
WorkflowCase workflowCase = workflowWork.getWorkflowCase();
WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
String packageId = workflowPackage.getUUID();
String processId = workflowProcess.getUUID();
String caseId = workflowCase.getUUID();
String strSQL =
"SELECT * FROM "
+ schemaContext.getTableName(SchemaContext.SCHEMA_PATH)
+ " "
+ "WHERE vc_packageId=?"
+ " "
+ "AND vc_processid=?"
+ " "
+ "AND vc_caseId=?"
+ " ";
if (isInPath)
{
strSQL += " AND vc_to=?";
}
else
{
strSQL += " AND vc_from=?";
}
pstmt = conn.prepareStatement(strSQL);
pstmt.setString(1, packageId);
pstmt.setString(2, processId);
pstmt.setString(3, caseId);
pstmt.setString(4, workflowWork.getUUID());
jrs = pstmt.executeQuery();
while (jrs.next())
{
workflowPath = new WorkflowPathImpl();
workflowPath.setUUID(jrs.getString("vc_uuid"));
workflowPath.setBacthNo(jrs.getString("vc_batchNo"));
workflowPath.setEventType(jrs.getInt("int_eventType"));
workflowPath.setFromWorkflowWork(
findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowWork.getWorkflowCase(), jrs.getString("vc_from")));
workflowPath.setToWorkflowWork(
findWork_impl(gCaseDatabaseImpl,workflowProcess,operator,conn,false,workflowWork.getWorkflowCase(), jrs.getString("vc_to")));
}
}
catch (SQLException sqlex)
{
throw new WorkflowException(sqlex);
}
finally
{
if (canRelease)
{
ConnUtils.cleanupNoThrow(conn, pstmt);
}
else
{
ConnUtils.cleanupNoThrow(pstmt);
}
}
return pathList;
}
private static WorkflowParticipant notNullPerformer(WorkflowParticipant workflowUser)
{
if(workflowUser==null)
{
workflowUser=WorkflowParticipantImpl.NULL_PARTICIPANT;
}
return workflowUser;
}
}