/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.hise.runtime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.wsdl.Operation;
import javax.wsdl.Part;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hise.dao.GenericHumanRole;
import org.apache.hise.dao.HISEDao;
import org.apache.hise.dao.Job;
import org.apache.hise.dao.Message;
import org.apache.hise.dao.TaskOrgEntity;
import org.apache.hise.dao.Task.Status;
import org.apache.hise.dao.TaskOrgEntity.OrgEntityType;
import org.apache.hise.engine.HISEEngineImpl;
import org.apache.hise.lang.TaskDefinition;
import org.apache.hise.lang.xsd.htd.TGrouplist;
import org.apache.hise.lang.xsd.htd.TOrganizationalEntity;
import org.apache.hise.lang.xsd.htd.TUserlist;
import org.apache.hise.utils.DOMUtils;
import org.apache.hise.utils.XmlUtils;
import org.apache.ws.commons.schema.utils.NamespaceMap;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* Holds task instance information. Provides task business operations.
*
* @author Kamil Eisenbart
* @author Witek Wołejszo
* @author Mateusz Lipczyński
* @author Warren Crossing
*/
public class Task {
private final Log __log = LogFactory.getLog(Task.class);
private HISEEngineImpl hiseEngine;
private org.apache.hise.dao.Task taskDto;
private TaskDefinition taskDefinition;
private TaskEvaluator taskEvaluator;
private List<TaskStateListener> taskStateListeners;
private Job currentJob;
private Date currentEventDateTime = Calendar.getInstance().getTime();
private String currentUser;
private DeadlineController deadlineController;
protected Task() {}
public Job getCurrentJob() {
return currentJob;
}
public void setCurrentJob(Job currentJob) {
this.currentJob = currentJob;
}
public Date getCurrentEventDateTime() {
return currentEventDateTime;
}
public void setCurrentEventDateTime(Date currentEventDateTime) {
this.currentEventDateTime = currentEventDateTime;
}
public String getCurrentUser() {
return currentUser;
}
/**
* TODO throw an exception if current user is not TASK_ADMINISTRATOR
* @param currentUser
*/
public void setCurrentUser(String currentUser) {
this.currentUser = currentUser;
}
public HISEEngineImpl getHiseEngine() {
return hiseEngine;
}
private Task(HISEEngineImpl engine, boolean notification) {
Validate.notNull(engine);
this.hiseEngine = engine;
taskStateListeners = new ArrayList<TaskStateListener>();
if (!notification) {
taskStateListeners.add(new TaskLifecycle(this));
deadlineController = new DeadlineController(this);
taskStateListeners.add(deadlineController);
}
taskEvaluator = new TaskEvaluator(this);
}
public org.apache.hise.dao.Task getTaskDto() {
return taskDto;
}
public void setTaskDto(org.apache.hise.dao.Task taskDto) {
this.taskDto = taskDto;
}
public TaskEvaluator getTaskEvaluator() {
return taskEvaluator;
}
public void setTaskEvaluator(TaskEvaluator taskEvaluator) {
this.taskEvaluator = taskEvaluator;
}
public static Task load(HISEEngineImpl engine, Long id) {
HISEDao dao = engine.getHiseDao();
org.apache.hise.dao.Task dto = dao.find(org.apache.hise.dao.Task.class, id);
Task t = new Task(engine, dto.isNotification());
t.taskDto = dto;
t.taskDefinition = engine.getTaskDefinition(t.taskDto.getTaskDefinitionName());
return t;
}
private void tryNominateOwner() throws HiseIllegalStateException {
{
int poSize = 0;
TaskOrgEntity selected = null;
for (TaskOrgEntity e : taskDto.getPeopleAssignments()) {
if (e.getGenericHumanRole() == GenericHumanRole.POTENTIALOWNERS) {
poSize ++;
if (e.getType() == TaskOrgEntity.OrgEntityType.USER) {
selected = e;
}
}
}
if (poSize == 1 && selected != null) {
//Nominate a single potential owner
setActualOwner(selected.getName());
}
}
}
public static Task create(HISEEngineImpl engine, TaskDefinition taskDefinition, String createdBy, Node requestXml, Node requestHeader) {
Task t = new Task(engine, false);
Validate.notNull(taskDefinition);
Validate.isTrue(!taskDefinition.isNotification());
Map<String, Node> inputParts = findInputParts(taskDefinition, requestXml);
t.taskDefinition = taskDefinition;
org.apache.hise.dao.Task taskDto = new org.apache.hise.dao.Task();
taskDto.setTaskDefinitionKey(taskDefinition.getTaskName().toString());
taskDto.setCreatedBy(createdBy);
taskDto.setStatus(null);
for(String partName: inputParts.keySet()) {
taskDto.getInput().put(partName, new Message(partName, DOMUtils.domToString(inputParts.get(partName))));
}
taskDto.getInput().put("requestHeader", new Message("requestHeader", DOMUtils.domToString(requestHeader)));
taskDto.setCreatedOn(new Date());
taskDto.setActivationTime(new Date());
taskDto.setEscalated(false);
taskDto.setNotification(false);
engine.getHiseDao().persist(taskDto);
t.taskDto = taskDto;
try {
t.setStatus(Status.CREATED);
} catch (HiseIllegalStateException e) {
throw new IllegalStateException(e);
}
taskDto.setPeopleAssignments(t.getTaskEvaluator().evaluatePeopleAssignments());
try {
t.setStatus(Status.READY);
} catch (HiseIllegalStateException e) {
throw new IllegalStateException(e);
}
try {
t.tryNominateOwner();
} catch (HiseIllegalStateException e) {
t.__log.warn("Could not nominate owner.");
}
return t;
// recalculatePresentationParameters();
//
// //retrieveExistingAssignees check if group or people with the same name exist
// //and retrieves existing entities
// taskDto.setPotentialOwners(hiseEngine.assigneeDao.saveNotExistingAssignees(taskDefinition.evaluateHumanRoleAssignees(GenericHumanRole.POTENTIAL_OWNERS, this)));
// taskDto.setBusinessAdministrators(hiseEngine.assigneeDao.saveNotExistingAssignees(taskDefinition.evaluateHumanRoleAssignees(GenericHumanRole.BUSINESS_ADMINISTRATORS, this)));
// taskDto.setExcludedOwners(hiseEngine.assigneeDao.saveNotExistingAssignees(taskDefinition.evaluateHumanRoleAssignees(GenericHumanRole.EXCLUDED_OWNERS, this)));
// taskDto.setNotificationRecipients(hiseEngine.assigneeDao.saveNotExistingAssignees(taskDefinition.evaluateHumanRoleAssignees(GenericHumanRole.NOTIFICATION_RECIPIENTS, this)));
// taskDto.setTaskStakeholders(hiseEngine.assigneeDao.saveNotExistingAssignees(taskDefinition.evaluateHumanRoleAssignees(GenericHumanRole.TASK_STAKEHOLDERS, this)));
//
// //TODO test
// if (this.taskStakeholders.isEmpty()) {
// __log.error("No task stakeholders. Wrong configuration. Cannot create task.");
// throw new HTConfigurationException("No task stakeholders. Wrong configuration. Cannot create task.", null);
// }
//
// this.addOperationComment(Operations.CREATE);
//
// this.createdBy = createdBy;
// this.createdOn = new Date();
// this.activationTime = new Date();
// this.escalated = false;
// this.notification = false;
// this.setStatus(Status.CREATED);
//
// Person nominatedPerson = this.nominateActualOwner(this.potentialOwners);
// if (nominatedPerson != null) {
//
// this.actualOwner = nominatedPerson;
// this.addOperationComment(Operations.NOMINATE, nominatedPerson);
// this.setStatus(Status.RESERVED);
//
// } else if (!this.potentialOwners.isEmpty()) {
//
// this.setStatus(Status.READY);
//
// }
//
// recalculatePresentationParameters();
//
// recalculatePriority();
}
static Map<String, Node> findInputParts(TaskDefinition taskDefinition, Node requestXml) {
Map<String, Node> inputParts = new HashMap<String, Node>();
Operation operation = taskDefinition.getPortType().getOperation(taskDefinition.getTaskInterface().getOperation(), null, null);
if(operation == null) {
LogFactory.getLog(Task.class).error("Operation: " + taskDefinition.getTaskInterface().getOperation() + " not found in port type definition.");
return inputParts;
}
Map<String, Part> partsMap = operation.getInput().getMessage().getParts();
Node messagePart = null;
for (Part part : partsMap.values()) {
String name = part.getName();
QName element = part.getElementName();
QName type = part.getTypeName();
Element root = (Element) requestXml;
XPath xPath = XPathFactory.newInstance().newXPath();
try {
if (element != null) {
Map namespaceMap = new HashMap(1);
namespaceMap.put("prefix", element.getNamespaceURI());
NamespaceContext nc = new NamespaceMap(namespaceMap);
xPath.setNamespaceContext(nc);
messagePart = (Node) xPath.evaluate("prefix:" + element.getLocalPart(), root, XPathConstants.NODE);
} else if (type != null) {
messagePart = (Node) xPath.evaluate("child::*/" + part.getName(), root, XPathConstants.NODE);
}
} catch (XPathExpressionException ex) {
LogFactory.getLog(Task.class).error("Can not get message part.", ex);
}
inputParts.put(name, messagePart);
}
return inputParts;
}
public static Task createNotification(HISEEngineImpl engine, TaskDefinition taskDefinition, String createdBy, Node requestXml, Node requestHeader) {
Validate.notNull(taskDefinition);
Validate.isTrue(taskDefinition.isNotification());
Task t = new Task(engine, true);
t.taskDefinition = taskDefinition;
Map<String, Node> inputParts = findInputParts(taskDefinition, requestXml);
org.apache.hise.dao.Task taskDto = new org.apache.hise.dao.Task();
taskDto.setTaskDefinitionKey(taskDefinition.getTaskName().toString());
taskDto.setCreatedBy(createdBy);
taskDto.setStatus(null);
for(String partName: inputParts.keySet()) {
taskDto.getInput().put(partName, new Message(partName, DOMUtils.domToString(inputParts.get(partName))));
}
taskDto.getInput().put("requestHeader", new Message("requestHeader", DOMUtils.domToString(requestHeader)));
taskDto.setCreatedOn(new Date());
taskDto.setActivationTime(new Date());
taskDto.setEscalated(false);
taskDto.setNotification(true);
engine.getHiseDao().persist(taskDto);
t.taskDto = taskDto;
try {
t.setStatus(Status.CREATED);
} catch (HiseIllegalStateException e) {
throw new IllegalStateException(e);
}
taskDto.setPeopleAssignments(t.getTaskEvaluator().evaluatePeopleAssignments());
try {
t.setStatus(Status.READY);
} catch (HiseIllegalStateException e) {
throw new IllegalStateException(e);
}
engine.getHiseDao().persist(taskDto);
return t;
}
public void setActualOwner(String user) throws HiseIllegalStateException {
setStatus(Status.RESERVED);
taskDto.setActualOwner(user);
}
public void setOutput(Node requestXml) {
__log.debug("setting task output to: " + requestXml);
this.taskDto.getOutput().put("request", new Message("request", DOMUtils.domToString(requestXml)));
}
public TaskDefinition getTaskDefinition() {
return taskDefinition;
}
// /**
// * If there is only one person in the given list, it
// * returns this person. Otherwise, it returns null.
// *
// * @param assignees list of assignees that can contain persons and groups
// * @return the only person in the list, otherwise null
// */
// protected final Person nominateActualOwner(Set<Assignee> assignees) {
//
// Validate.notNull(assignees);
//
// Person result = null;
// int count = 0;
// for (Assignee assignee : assignees) {
// if (assignee instanceof Person) {
// if (count++ > 0) {
// break;
// }
// result = (Person)assignee;
// }
// }
//
// return (count == 1) ? result : null;
// }
//
// /**
// * Returns task's name in a required language.
// *
// * @param lang subject language according ISO, e.g. en-US, pl, de-DE
// * @return name
// */
// public String getName(String lang) {
// Validate.notNull(lang);
// return this.getTaskDefinition().getName(lang);
// }
//
// public QName getTaskName() {
// return this.getTaskDefinition().getTaskName();
// }
//
// /**
// * Returns a formatted task subject in a required language.
// *
// * @param lang subject language according ISO, e.g. en-US, pl, de-DE
// * @return subject
// */
// public String getSubject(String lang) {
// Validate.notNull(lang);
// return this.getTaskDefinition().getSubject(lang, this);
// }
//
// /**
// * Returns a formatted task description in a required language and form.
// *
// * @param lang The description language according ISO, e.g. en-US, pl, de-DE
// * @param contentType The content type, text/plain for plain text or text/html for HTML-formatted text.
// * @return description
// */
// public String getDescription(String lang, String contentType) {
// Validate.notNull(lang);
// Validate.notNull(contentType);
// return this.getTaskDefinition().getDescription(lang, contentType, this);
// }
//
// /**
// * Recalculates priority. To be called after object creation or input message update.
// */
// private void recalculatePriority() {
// __log.info("Recalculating priority.");
// this.priority = this.getTaskDefinition().getPriority(this);
// }
//
// /**
// * Recalculates presentation parameter values. To be called after object creation or
// * input message update.
// */
// private void recalculatePresentationParameters() {
//
// __log.info("Recalculating presentation parameters.");
//
// Map<String, Object> pp = this.getTaskDefinition().getTaskPresentationParameters(this);
//
// //replace all calculated
// for (Entry<String, Object> entry : pp.entrySet()) {
//
// PresentationParameter p = this.presentationParameters.get(entry.getKey());
//
// if (p != null) {
//
// p.setValue(entry.getValue() == null ? null : entry.getValue());
//
// } else {
//
// p = new PresentationParameter();
// p.setTask(this);
// p.setName(entry.getKey());
// //TODO test
// p.setValue(entry.getValue() == null ? null : entry.getValue());
//
// this.presentationParameters.put(p.getName(), p);
// }
// }
//
// //remove obsolete from presentationParameters
// Set<String> allKeys = this.presentationParameters.keySet();
// for (String key : allKeys) {
// if (!pp.containsKey(key)) {
// allKeys.remove(key);
// }
// }
// }
//
// /**
// * Adds an attachment to the task.
// *
// * @param attachment a new attachment to add
// */
// public void addAttachment(Attachment attachment) {
// Validate.notNull(attachment);
// this.attachments.add(attachment);
// //TODO addComment
// }
//
public void setStatus(Status newStatus) throws HiseIllegalStateException {
for (TaskStateListener l : taskStateListeners) {
l.stateChanged(taskDto.getStatus(), newStatus);
}
taskDto.setStatus(newStatus);
}
// /***************************************************************
// * Task operations *
// ***************************************************************/
//
// /**
// * Sets Task status. Task status is changed indirectly by operations on tasks. Status
// * change operation comment is added. If new status is SUSPENDED and transition is
// * valid, current status is remembered in {@link Task#statusBeforeSuspend}.
// *
// * @param status The new {@link Status}.
// * @throws HTIllegalStateException thrown when impossible transition is forced by the caller.
// */
// private void setStatus(Status status) throws HTIllegalStateException {
//
// Validate.notNull(status);
//
// boolean isOk = false;
//
// // check if change is valid for current state
// if (this.status != null) {
//
// switch (this.status) {
//
// case CREATED:
// if (status == Status.READY || status == Status.RESERVED) {
// isOk = true;
// }
//
// break;
//
// case READY:
// if (status == Status.RESERVED || status == Status.IN_PROGRESS ||
// status == Status.READY || status == Status.SUSPENDED) {
// isOk = true;
// }
//
// break;
//
// case RESERVED:
// if (status == Status.IN_PROGRESS || status == Status.READY ||
// status == Status.SUSPENDED || status == Status.RESERVED) {
// isOk = true;
// }
//
// break;
//
// case IN_PROGRESS:
// if (status == Status.COMPLETED || status == Status.FAILED ||
// status == Status.RESERVED || status == Status.READY ||
// status == Status.SUSPENDED) {
// isOk = true;
// }
//
// break;
//
// default:
// break;
//
// }
//
// if (isOk) {
//
// __log.debug("Changing Task status : " + this + " status from: " + this.status + " to: " + status);
//
// if (status.equals(Status.SUSPENDED)) {
// this.statusBeforeSuspend = this.status;
// } else {
// Validate.isTrue(this.statusBeforeSuspend == null);
// }
//
// this.addOperationComment(Operations.STATUS, status);
// Status oldStatus = this.status;
// this.status = status;
//
// for (TaskStateListener l : taskStateListeners) {
// l.stateChanged(this, oldStatus, status);
// }
//
// } else {
//
// __log.error("Changing Task status: " + this + " status from: " + this.status + " to: " + status + " is not allowed.");
// throw new org.apache.hise.lang.faults.HTIllegalStateException("Changing Task's: " + this + " status from: " + this.status + " to: " + status
// + " is not allowed, or task is SUSPENDED", status);
// }
//
// } else {
//
// //TODO check allowed first statuses
// __log.debug("Changing Task status: " + this + " status from: NULL to: " + status);
// this.addOperationComment(Operations.STATUS, status);
// this.status = status;
//
// for (TaskStateListener l : taskStateListeners) {
// l.stateChanged(this, null, status);
// }
// }
// }
//
/**
* Claims task. Task in READY status can be claimed by people from potential owners group not listed in excluded owners.
*
* @throws HiseIllegalStateException Thrown when task is in illegal state for claim i.e. not READY.
* @throws HiseIllegalAccessException Thrown when task is in illegal state for claim i.e. not READY or person cannot
* become actual owner i.e. not potential owner or excluded.
*/
public void claim() throws HiseIllegalStateException, HiseIllegalAccessException {
if (taskDto.getActualOwner() != null) {
throw new HiseIllegalStateException("Actual owner already set " + taskDto.getActualOwner());
}
if (!taskDto.getStatus().equals(org.apache.hise.dao.Task.Status.READY)) {
throw new HiseIllegalStateException("Task not claimable. Not READY." + taskDto.getStatus());
}
// check if the task can be claimed by person
if (isCurrentUserInPotentialOwners()) {
throw new HiseIllegalAccessException("User: " + currentUser + " is not a potential owner.");
}
// //TODO test
// // check if the person is excluded from potential owners
// if ((this.getExcludedOwners() != null && this.getExcludedOwners().contains(person))) {
// throw new HTIllegalAccessException("Person is excluded from potential owners.", person.getName());
// }
taskDto.setActualOwner(currentUser);
// taskDto.addOperationComment(Operations.CLAIM, person);
setStatus(Status.RESERVED);
}
/**
* TODO implement
*/
private boolean isCurrentUserInPotentialOwners() {
return true;
}
public void start() throws HiseIllegalStateException {
setStatus(Status.IN_PROGRESS);
}
public void stop() throws HiseIllegalStateException {
setStatus(Status.RESERVED);
}
public void release() throws HiseIllegalStateException {
setStatus(Status.READY);
}
/**
* Suspends the task.
* @throws HiseIllegalStateException
*/
public void suspend() throws HiseIllegalStateException {
setStatus(Status.SUSPENDED);
}
public void suspendUntil(Date when) throws HiseIllegalStateException {
Validate.notNull(when);
setStatus(Status.SUSPENDED);
Job job = hiseEngine.getHiseScheduler().createJob(when, "suspendUntil", taskDto);
taskDto.setSuspendUntil(job);
}
public void suspendUntilJobAction() throws HiseIllegalStateException {
taskDto.setSuspendUntil(null);
resume();
}
public void deadlineJobAction() throws HiseIllegalStateException {
taskDto.getDeadlines().remove(getCurrentJob());
deadlineController.deadlineCrossed(getCurrentJob());
}
public void resume() throws HiseIllegalStateException {
setStatus(taskDto.getStatusBeforeSuspend());
}
public void fail() throws HiseIllegalStateException {
setStatus(Status.FAILED);
sendResponse();
}
/**
* TODO Execution of the task finished successfully. If no output data is set the operation returns illegalArgumentFault.
*/
public void complete() throws HiseIllegalStateException {
setStatus(Status.COMPLETED);
sendResponse();
}
/**
* FIXME is outcome a reponse?
*/
private void sendResponse() {
try {
Node response = taskEvaluator.evaluateOutcome(taskDto.getStatus() == Status.COMPLETED);
hiseEngine.sendResponse(getTaskDefinition().getTaskName(),
response,
taskEvaluator.createEprFromHeader(DOMUtils.parse(taskDto.getInput().get("requestHeader").getMessage()).getDocumentElement()));
} catch (Exception e) {
throw new RuntimeException("Sending response failed", e);
}
}
private void releaseOwner() throws HiseIllegalStateException {
setStatus(Status.READY);
taskDto.setActualOwner(null);
}
public void forward(TOrganizationalEntity target) throws HiseIllegalStateException {
Set<TaskOrgEntity> e = new HashSet<TaskOrgEntity>();
for (String user : XmlUtils.notNull(target.getUsers(), new TUserlist()).getUser()) {
TaskOrgEntity x = new TaskOrgEntity();
x.setGenericHumanRole(GenericHumanRole.POTENTIALOWNERS);
x.setName(user);
x.setType(OrgEntityType.USER);
x.setTask(taskDto);
e.add(x);
}
for (String group : XmlUtils.notNull(target.getGroups(), new TGrouplist()).getGroup()) {
TaskOrgEntity x = new TaskOrgEntity();
x.setGenericHumanRole(GenericHumanRole.POTENTIALOWNERS);
x.setName(group);
x.setType(OrgEntityType.GROUP);
x.setTask(taskDto);
e.add(x);
}
forward(e);
}
public void forward(Set<TaskOrgEntity> targets) throws HiseIllegalStateException {
__log.debug("forwarding to " + targets);
releaseOwner();
for (TaskOrgEntity x : taskDto.getPeopleAssignments()) {
x.setTask(null);
hiseEngine.getHiseDao().remove(x);
}
taskDto.getPeopleAssignments().clear();
taskDto.getPeopleAssignments().addAll(targets);
tryNominateOwner();
}
//
// /**
// * Releases the Task.
// * @param person The person that is releasing the Task.
// * @throws HTIllegalAccessException The person is not authorised to perform release operation.
// * @throws HTIllegalStateException Task cannot be released.
// * @see HumanTaskServices.releaseTask
// */
// public void release(Person person) throws HTIllegalAccessException, HTIllegalStateException {
//
// Validate.notNull(person);
// Validate.notNull(person.getId());
//
// //TODO test
// if (this.actualOwner == null) {
// throw new HTIllegalAccessException("Task without actual owner cannot be released.");
// }
//
// //TODO test
// if (!this.actualOwner.equals(person) && !this.getBusinessAdministrators().contains(person)) {
// throw new HTIllegalAccessException("Calling person is neither the task's actual owner not business administrator");
// }
//
// this.actualOwner = null;
// this.addOperationComment(Operations.RELEASE, person);
// this.setStatus(Status.READY);
// }
//
// /**
// * Starts task.
// * @see HumanTaskServices#startTask(Long, String)
// * @param person
// * @throws HTIllegalStateException
// * @throws HTIllegalAccessException
// */
// public void start(Person person) throws HTIllegalStateException, HTIllegalAccessException {
//
// Validate.notNull(person);
// Validate.notNull(person.getId());
//
// //only potential owner can start the task
// if (!this.getPotentialOwners().contains(person)) {
// throw new HTIllegalAccessException("This person is not permited to start the task.", person.toString());
// }
//
// //ready
// if (this.getStatus().equals(Status.READY)) {
//
// //TODO can ready contain actual owner??? validate
// this.claim(person);
// this.addOperationComment(Operations.START, person);
// this.setStatus(Status.IN_PROGRESS);
//
// } else if (this.getStatus().equals(Status.RESERVED)) {
//
// org.apache.commons.lang.Validate.notNull(this.getActualOwner());
// if (this.getActualOwner().equals(person)) {
//
// this.addOperationComment(Operations.START, person);
// this.setStatus(Status.IN_PROGRESS);
//
// } else {
//
// throw new HTIllegalAccessException("This person is not permited to start the task. Task is RESERVED.", person.toString());
//
// }
//
// } else {
//
// throw new HTIllegalStateException("Only READY or RESERVED tasks can be started.", this.getStatus());
//
// }
// }
//
// /**
// * Delegates the task.
// * @see HumanTaskServices#delegateTask(Long, String, String)
// * @param person
// * @param delegatee
// * @throws HTIllegalAccessException
// * @throws HTIllegalStateException
// * @throws HTRecipientNotAllowedException
// */
// public void delegate(Person person, Person delegatee) throws HTIllegalAccessException, HTIllegalStateException, HTRecipientNotAllowedException {
//
// Validate.notNull(person);
// Validate.notNull(person.getId());
// Validate.notNull(delegatee);
// Validate.notNull(delegatee.getId());
//
// this.checkCanDelegate(person, delegatee);
//
// this.addOperationComment(Operations.DELEGATE, person, delegatee);
// this.actualOwner = delegatee;
//
// if (!this.status.equals(Status.RESERVED)) {
// this.setStatus(Status.RESERVED);
// }
// }
//
// /**
// * Checks if the task can be delegated. Throws exception if it can't.
// * @param person
// * @param delegatee
// * @throws HTIllegalAccessException
// * @throws HTRecipientNotAllowedException
// * @throws HTIllegalStateException
// */
// public void checkCanDelegate(Person person, Person delegatee) throws HTIllegalAccessException, HTRecipientNotAllowedException, HTIllegalStateException {
//
// Validate.notNull(person);
// Validate.notNull(person.getId());
// Validate.notNull(delegatee);
// Validate.notNull(delegatee.getId());
//
// if (!(this.potentialOwners.contains(person) || this.businessAdministrators.contains(person) || person.equals(this.actualOwner))) {
// throw new HTIllegalAccessException("Person delegating the task is not a: potential owner, bussiness administrator, actual owner.");
// }
//
// if (!this.getPotentialOwners().contains(delegatee)) {
// throw new HTRecipientNotAllowedException("Task can be delegated only to potential owners.");
// }
//
// if (!Arrays.asList(Status.READY, Status.RESERVED, Status.IN_PROGRESS).contains(this.status)) {
// throw new HTIllegalStateException("Only READY, RESERVED, IN_PROGRESS tasks can ne delegated.", this.status);
// }
// }
//
// /**
// * Completes the task. Can be performed by actual owner only.
// *
// * @param person Person completing the task
// * @param responseXml Xml message sent in response
// * @throws HTIllegalStateException Task's current state does not allow completion.
// * @throws HTIllegalArgumentException If no output data is set the operation fails.
// * @throws HTIllegalAccessException Passed person is not task's actual owner.
// */
// public void complete(Person person, String responseXml) throws HTIllegalStateException, HTIllegalArgumentException, HTIllegalAccessException {
//
// if (responseXml == null) {
// throw new HTIllegalArgumentException("Task must be completed with a response.");
// }
//
// if (!person.equals(this.actualOwner)) {
// throw new HTIllegalAccessException("Task can be completed only by actual owner.");
// }
//
// this.addOperationComment(Operations.COMPLETE, person);
//
// this.setStatus(Status.COMPLETED);
//
// //presentation parameters can depend on output message
// this.recalculatePresentationParameters();
// }
//
// /**
// * Fails the task. Actual owner completes the execution of the task raising a fault. Method
// * updates task's status and fault information.
// *
// * @param person
// * @param fault
// * @throws HTIllegalAccessException
// * @throws HTIllegalStateException
// */
// public void fail(Person person, Fault fault) throws HTIllegalAccessException, HTIllegalStateException {
//
// if (!person.equals(this.actualOwner)) {
// throw new HTIllegalAccessException("Task can be failed only by actual owner.");
// }
//
// //TODO check if task interface defines fault
//
// this.fault = fault;
//
// this.addOperationComment(Operations.FAIL, person);
//
// this.setStatus(Status.FAILED);
// }
//
// /**
// * Changes tasks priority. Must be actual owner or business administrator.
// * @param person
// * @param priority
// * @throws HTIllegalAccessException
// */
// public void changePriority(Person person, int priority) throws HTIllegalAccessException {
//
// if (!person.equals(this.actualOwner) && !this.businessAdministrators.contains(person)) {
// throw new HTIllegalAccessException("Task priority can be changed by actual owner or business administrator only.");
// }
//
// this.setPriority(priority);
//
// //TODO log operation?
// }
//
//
// /***************************************************************
// * Getters & Setters *
// ***************************************************************/
//
// public void setId(Long id) {
// this.id = id;
// }
//
// public Long getId() {
// return this.id;
// }
//
// public Status getStatus() {
// return this.status;
// }
//
// public List<Attachment> getAttachments() {
// return this.attachments;
// }
//
// public Date getSuspentionTime() {
// return (this.suspensionTime == null) ? null : (Date) this.suspensionTime.clone();
// }
//
// public Assignee getActualOwner() {
// return this.actualOwner;
// }
//
// public Integer getPriority() {
// return this.priority;
// }
//
// public void setPriority(Integer priority) {
// this.priority = priority;
// }
//
// public String getCreatedBy() {
// return this.createdBy;
// }
//
// public Date getActivationTime() {
// return this.activationTime;
// }
//
// public Date getExpirationTime() {
// return (this.expirationTime == null) ? null : (Date) this.expirationTime.clone();
// }
//
// public boolean isSkippable() {
// return this.skippable;
// }
//
// public boolean isEscalated() {
// return this.escalated;
// }
//
// public QName getTaskDefinitionKey() {
// return QName.valueOf(this.taskDefinitionKey);
// }
//
// public Set<Assignee> getPotentialOwners() {
// return this.potentialOwners;
// }
//
// public Set<Assignee> getExcludedOwners() {
// return this.excludedOwners;
// }
//
// public Set<Assignee> getTaskStakeholders() {
// return this.taskStakeholders;
// }
//
// public Set<Assignee> getBusinessAdministrators() {
// return this.businessAdministrators;
// }
//
// public Set<Assignee> getNotificationRecipients() {
// return this.notificationRecipients;
// }
//
// public Date getCreatedOn() {
// return this.createdOn == null ? null : (Date)this.createdOn.clone();
// }
//
// public Map<String, Message> getInput() {
// return this.input;
// }
//
// public Map<String, Message> getOutput() {
// return this.output;
// }
//
// public void setFault(Fault fault) {
// this.fault = fault;
// }
//
// public Fault getFault() {
// return this.fault;
// }
//
// /***************************************************************
// * Infrastructure methods. *
// ***************************************************************/
//
// /**
// * Adds a comment related to operation taking place.
// * @param operation performed operation
// * @param people people involved, starting with person invoking the operation
// */
// public void addOperationComment(Operations operation, Person ... people) {
//
// Validate.notNull(operation);
//
// String content = null;
//
// switch (operation) {
// case CREATE:
// content = "Created.";
// break;
// case START:
// content = "Started by " + people[0];
// break;
// case CLAIM:
// content = "Claimed by " + people[0];
// break;
// case DELEGATE:
// content = "Delegated by " + people[0] + " to " + people[1];
// break;
// case NOMINATE:
// content = "Nominated to " + people[0];
// break;
// case RELEASE:
// content = "Released by " + people[0];
// break;
// case COMPLETE:
// content = "Completed by " + people[0];
// break;
// case FAIL:
// content = "Failed by " + people[0];
// break;
// default:
// break;
// }
//
// if (content != null) {
// this.comments.add(new Comment(content, this));
// }
// }
//
// /**
// * Adds a comment related to operation taking place.
// * @param operation performed operation
// * @param people people involved, starting with person invoking the operation
// */
// public void addOperationComment(Operations operation, Status status) {
//
// Validate.notNull(operation);
//
// String content = null;
//
// switch (operation) {
// case STATUS:
// content = "Status changed to " + status;
// break;
// default:
// break;
// }
//
// if (content != null) {
// this.comments.add(new Comment(content, this));
// }
// }
//
//
// private class TaskInnerXmlUtils extends TaskXmlUtils {
//
// public TaskInnerXmlUtils(NamespaceContext namespaceContext) {
// super(namespaceContext, input, output);
// }
// }
//
// /**
// * Evaluates xpath using task's input and output messages.
// * @param xPathString XPath expression.
// * @param returnType Return type.
// * @return evaluated value
// */
// public Object evaluateXPath(String xPathString, QName returnType) {
// return new TaskInnerXmlUtils(new TaskNamespaceContext()).evaluateXPath(xPathString, returnType);
// }
//
// /**
// * {@inheritDoc}
// */
// private class TaskNamespaceContext implements NamespaceContext {
//
// /**
// * {@inheritDoc}
// */
// public String getNamespaceURI(String prefix) {
//
// if (prefix == null) {
//
// throw new NullPointerException("Null prefix");
//
// } else if ("htd".equals(prefix)) {
//
// return "http://www.example.org/WS-HT";
//
// } else if ("xml".equals(prefix)) {
//
// return XMLConstants.XML_NS_URI;
//
// } else {
//
// String namespaceURI = getTaskDefinition().getNamespaceURI(prefix);
// if (namespaceURI != null) {
// return namespaceURI;
// }
// }
//
// return XMLConstants.NULL_NS_URI;
// }
//
// /**
// * {@inheritDoc}
// */
// public String getPrefix(String namespaceURI) {
// // TODO ???
// throw new NullPointerException("???");
// }
//
// /**
// * {@inheritDoc}
// */
// public Iterator getPrefixes(String namespaceURI) {
// // ???
// throw new NullPointerException("???");
// }
// }
// /**
// * Returns presentation parameter values.
// * @return the presentation parameter values
// */
// public Map<String, Object> getPresentationParameterValues() {
// Map<String, Object> result = new HashMap<String, Object>();
// for (Map.Entry<String, PresentationParameter> pp : taskDto.getPresentationParameters().entrySet()) {
// result.put(pp.getKey(), pp.getValue().getValue());
// }
// return result;
// }
public void remove() {
Validate.isTrue(taskDto.isNotification());
hiseEngine.getHiseDao().remove(taskDto);
}
public Node getInput(String part) {
return DOMUtils.parse(taskDto.getInput().get(part).getMessage()).getDocumentElement();
}
public Node getOutput(String part) {
return DOMUtils.parse(taskDto.getOutput().get(part).getMessage()).getDocumentElement();
}
}