How to use

ProcessorEnactment

in

net.sf.taverna.t2.provenance.lineageservice.utils

    + ProcessorEnactmentTable.finalOutputsDataBindingId
    + ") VALUES(?,?,?,?,?,?,?,?,?,?)");
ps.setString(1, enactment.getProcessEnactmentId());
ps.setString(2, enactment.getWorkflowRunId());
ps.setString(3, enactment.getProcessorId());
ps.setString(4, enactment.getProcessIdentifier());
ps.setString(5, enactment.getIteration());
ps.setString(6, enactment.getParentProcessorEnactmentId());
ps.setTimestamp(7, enactment.getEnactmentStarted());
ps.setTimestamp(8, enactment.getEnactmentEnded());
ps.setString(9, enactment.getInitialInputsDataBindingId());
ps.setString(10, enactment.getFinalOutputsDataBindingId());
ps.executeUpdate();

private ProcessorEnactment readProcessorEnactment(ResultSet resultSet) throws SQLException {
  ProvenanceConnector.ProcessorEnactmentTable ProcEnact = ProvenanceConnector.ProcessorEnactmentTable.ProcessorEnactment;
  Timestamp enactmentStarted = resultSet.getTimestamp(ProcEnact.enactmentStarted.name());
  Timestamp enactmentEnded = resultSet.getTimestamp(ProcEnact.enactmentEnded.name());
  //String pName = resultSet.getString("processorName");
  String finalOutputsDataBindingId = resultSet.getString(ProcEnact.finalOutputsDataBindingId.name());
  String initialInputsDataBindingId = resultSet.getString(ProcEnact.initialInputsDataBindingId.name());
  String iteration = resultSet.getString(ProcEnact.iteration.name());
  String processorId = resultSet.getString("procId");
  String processIdentifier = resultSet.getString(ProcEnact.processIdentifier.name());
  String processEnactmentId = resultSet.getString(ProcEnact.processEnactmentId.name());
  String parentProcessEnactmentId = resultSet.getString(ProcEnact.parentProcessorEnactmentId.name());
  String workflowRunId = resultSet.getString(ProcEnact.workflowRunId.name());
  ProcessorEnactment procEnact = new ProcessorEnactment();
  procEnact.setEnactmentEnded(enactmentEnded);
  procEnact.setEnactmentStarted(enactmentStarted);
  procEnact.setFinalOutputsDataBindingId(finalOutputsDataBindingId);
  procEnact.setInitialInputsDataBindingId(initialInputsDataBindingId);
  procEnact.setIteration(iteration);
  procEnact.setParentProcessorEnactmentId(parentProcessEnactmentId);
  procEnact.setProcessEnactmentId(processEnactmentId);
  procEnact.setProcessIdentifier(processIdentifier);
  procEnact.setProcessorId(processorId);
  procEnact.setWorkflowRunId(workflowRunId);
  return procEnact;
}

@Override
public boolean equals(Object obj) {
  if (this == obj)
    return true;
  if (obj == null)
    return false;
  if (getClass() != obj.getClass())
    return false;
  ServiceInvocation other = (ServiceInvocation) obj;
  if (invocationNumber != other.invocationNumber)
    return false;
  if (processorEnactment == null) {
    if (other.processorEnactment != null)
      return false;
  } else if (!processorEnactment.equals(other.processorEnactment))
    return false;
  return true;
}
@Override

public void updateProcessorEnactment(net.sf.taverna.t2.provenance.lineageservice.utils.ProcessorEnactment enactment) {
  PreparedStatement ps = null;
  Connection connection = null;
  try {
    connection = getConnection();
    ps = connection.prepareStatement("UPDATE "
        + ProcessorEnactmentTable.ProcessorEnactment + " SET "
        + ProcessorEnactmentTable.finalOutputsDataBindingId + "=?, "
        + ProcessorEnactmentTable.enactmentEnded+ "=?"
        + " WHERE " + ProcessorEnactmentTable.processEnactmentId + "=?");
    ps.setString(1, enactment.getFinalOutputsDataBindingId());
    ps.setTimestamp(2, enactment.getEnactmentEnded());
    ps.setString(3, enactment.getProcessEnactmentId());
    ps.executeUpdate();
  } catch (SQLException e) {
    logger.warn("****  insert failed for query ", e);
  } finally {
    if (connection != null) {
      try {
        connection.close();
      } catch (SQLException ex) {
        logger.error("There was an error closing the database connection", ex);
      }
    }
  }
}

  processorEnactment = new ProcessorEnactment();
processorEnactment.setEnactmentStarted(iterationProvenanceItem.getEnactmentStarted());
processorEnactment.setEnactmentEnded(iterationProvenanceItem.getEnactmentEnded());
processorEnactment.setWorkflowRunId(workflowRunId);
processorEnactment.setIteration(itVector);
  ProcessorEnactment parentProcEnact = getWfdp().invocationProcessToProcessEnactment.get(parentProcessId);
  if (parentProcEnact != null) {
    processorEnactment.setParentProcessorEnactmentId(parentProcEnact.getProcessEnactmentId());
processorEnactment.setProcessEnactmentId(iterationProvenanceItem.getIdentifier());
processorEnactment.setProcessIdentifier(processId);
if (processorEnactment.getProcessorId() == null) {
  provenanceProcessor = pq.getProvenanceProcessorByName(currentWorkflowID, procBinding.getProcessorName());
  processorMapById.put(provenanceProcessor.getIdentifier(), provenanceProcessor);
  processorEnactment.setProcessorId(provenanceProcessor.getIdentifier());
} else {
  provenanceProcessor = processorMapById.get(processorEnactment.getProcessorId());
  if (provenanceProcessor == null) {
    provenanceProcessor = pq.getProvenanceProcessorById(processorEnactment.getProcessorId());
    processorMapById.put(provenanceProcessor.getIdentifier(), provenanceProcessor);
if (inputDataEl != null && processorEnactment.getInitialInputsDataBindingId() == null) {
  processorEnactment.setInitialInputsDataBindingId(processDataBindings(inputDataEl, provenanceProcessor));
  processInput(inputDataEl, procBinding, currentWorkflowID);

processorId = processorEnactmentsStack.get(0).getProcessorId();
  enactmentsGotSoFar.add(processorEnactment);
  enactmentIdsGotSoFar.add(processorEnactment
      .getProcessEnactmentId());
      .getParentProcessorEnactmentId();
  if (parentId != null
      && !enactmentIdsGotSoFar.contains(parentId)) {
if (! processorEnactment.getProcessorId().equals(processorId)) {
    .getInitialInputsDataBindingId();
String finalOutputs = processorEnactment
    .getFinalOutputsDataBindingId();

Timestamp started = processorEnactment.getEnactmentStarted();
Timestamp ended = processorEnactment.getEnactmentEnded();
if (started != null) {
  if (procEnactmentTreeNode.getErrorState().equals(ErrorState.INPUT_ERRORS)) {

  .getInitialInputsDataBindingId();
String finalOutputs = processorEnactment
  .getFinalOutputsDataBindingId();

List<Integer> iteration = iterationToIntegerList(processorEnactment.getIteration());
String parentId = processorEnactment.getParentProcessorEnactmentId();
ProcessorEnactment parentProc = null;
List<Integer> parentIteration = null;

public void update(Set<ProcessorEnactment> newEnactments) {
  // First populate the ID map, so we can find parents later
  for (ProcessorEnactment processorEnactment : newEnactments){
    processorEnactmentsById.put(processorEnactment.getProcessEnactmentId(), processorEnactment);				
  }                
  for (ProcessorEnactment processorEnactment : newEnactments){
    addProcessorEnactment(processorEnactment);
  }
  
}

public final void setProcessorEnactment(ProcessorEnactment processorEnactment) {
  setUserObject(processorEnactment);
  setMyIteration(ProcessorEnactmentsTreeModel.iterationToIntegerList(processorEnactment.getIteration()));
}

    .getUserObject();
if (! processorEnactment.getProcessorId().equals(processorId)) {

private List<ProcessorEnactment> getProcessorEnactments(
    String workflowRunId, List<ProcessorEnactment> parentProcessorEnactments,
    List<String> processorPath) {
  List<String> processorEnactmentIds = null;
  if (parentProcessorEnactments != null) {
    processorEnactmentIds = new ArrayList<String>();
    for (ProcessorEnactment processorEnactment : parentProcessorEnactments) {
      String parentId = processorEnactment.getProcessEnactmentId();
      processorEnactmentIds.add(parentId);
    }
  }
  if (processorPath.size() > 1) {
    List<ProcessorEnactment> parentEnactments = getProcessorEnactmentsByProcessorName(workflowRunId,
        processorEnactmentIds, processorPath.get(0));
    List<String> childPath = processorPath.subList(1, processorPath.size());
    return getProcessorEnactments(workflowRunId, parentEnactments, childPath);
  } else if (processorPath.size() == 1) {
    return getProcessorEnactmentsByProcessorName(workflowRunId, processorEnactmentIds, processorPath.get(0));
  } else  {
    return getProcessorEnactmentsByProcessorName(workflowRunId, processorEnactmentIds, null);
  }
}

connection = getConnection();
statement = connection.prepareStatement(query);
statement.setString(1, processorEnactment.getProcessEnactmentId());
ResultSet rs = statement.executeQuery();
if (! rs.next()) {
  logger.warn("Could not find DataflowInvocation for processorEnactmentId=" + processorEnactment.getProcessEnactmentId());
  return null;
  logger.error("Found more than one DataflowInvocation for processorEnactmentId=" + processorEnactment.getProcessEnactmentId());
  return null;

ProcessorEnactment procAct = invocationProcessToProcessEnactment.get(parentProcessId);
if (procAct != null) {
  invocation.setParentProcessorEnactmentId(procAct.getProcessEnactmentId());