/**
* Copyright 2010 JBoss Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jbpm.task;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.jbpm.task.utils.CollectionUtils;
@Entity
@Table(name = "JBPM_TASK")
public class Task implements Externalizable {
/**
* WSHT uses a name for the unique identifier, for now we use a generated ID
* which is also the key, which can be mapped to the name or a unique name
* field added later.
*/
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
/**
* While WSHT says this is an expression, it always resolves to an integer,
* so resolve before setting default value is 0.
*/
private int priority;
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "Task_Names_Id", nullable = true)
private List<I18NText> names = Collections.emptyList();
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "Task_Subjects_Id", nullable = true)
private List<I18NText> subjects = Collections.emptyList();
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "Task_Descriptions_Id", nullable = true)
private List<I18NText> descriptions = Collections.emptyList();
@Embedded
private PeopleAssignments peopleAssignments;
@Embedded
private Delegation delegation;
@Embedded
private TaskData taskData;
@Embedded
private Deadlines deadlines;
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "Task_Id", nullable = true)
private List<SubTasksStrategy> subTaskStrategies = Collections.emptyList();
public Task() {
}
public void writeExternal(final ObjectOutput out) throws IOException {
out.writeLong(id);
out.writeInt(priority);
CollectionUtils.writeI18NTextList(names, out);
CollectionUtils.writeI18NTextList(subjects, out);
CollectionUtils.writeI18NTextList(descriptions, out);
if (peopleAssignments != null) {
out.writeBoolean(true);
peopleAssignments.writeExternal(out);
} else {
out.writeBoolean(false);
}
if (delegation != null) {
out.writeBoolean(true);
delegation.writeExternal(out);
} else {
out.writeBoolean(false);
}
if (taskData != null) {
out.writeBoolean(true);
taskData.writeExternal(out);
} else {
out.writeBoolean(false);
}
if (deadlines != null) {
out.writeBoolean(true);
deadlines.writeExternal(out);
} else {
out.writeBoolean(false);
}
out.writeInt(subTaskStrategies.size());
for (final SubTasksStrategy strategy : subTaskStrategies) {
out.writeUTF(strategy.getName());
strategy.writeExternal(out);
}
}
public void readExternal(final ObjectInput in) throws IOException,
ClassNotFoundException {
id = in.readLong();
priority = in.readInt();
names = CollectionUtils.readI18NTextList(in);
subjects = CollectionUtils.readI18NTextList(in);
descriptions = CollectionUtils.readI18NTextList(in);
if (in.readBoolean()) {
peopleAssignments = new PeopleAssignments();
peopleAssignments.readExternal(in);
}
if (in.readBoolean()) {
delegation = new Delegation();
delegation.readExternal(in);
}
if (in.readBoolean()) {
taskData = new TaskData();
taskData.readExternal(in);
}
if (in.readBoolean()) {
deadlines = new Deadlines();
deadlines.readExternal(in);
}
final int size = in.readInt();
final List<SubTasksStrategy> list = new ArrayList<SubTasksStrategy>(
size);
for (int i = 0; i < size; i++) {
final String name = in.readUTF();
final SubTasksStrategy strategy = SubTasksStrategyFactory
.newStrategy(name);
strategy.readExternal(in);
list.add(strategy);
}
subTaskStrategies = list;
}
public Long getId() {
return id;
}
public void setId(final long id) {
this.id = id;
}
public int getPriority() {
return priority;
}
public void setPriority(final int priority) {
this.priority = priority;
}
public List<I18NText> getNames() {
return names;
}
public void setNames(final List<I18NText> names) {
this.names = names;
}
public List<I18NText> getSubjects() {
return subjects;
}
public void setSubjects(final List<I18NText> subjects) {
this.subjects = subjects;
}
public List<I18NText> getDescriptions() {
return descriptions;
}
public void setDescriptions(final List<I18NText> descriptions) {
this.descriptions = descriptions;
}
public PeopleAssignments getPeopleAssignments() {
return peopleAssignments;
}
public void setPeopleAssignments(final PeopleAssignments peopleAssignments) {
this.peopleAssignments = peopleAssignments;
}
public Delegation getDelegation() {
return delegation;
}
public void setDelegation(final Delegation delegation) {
this.delegation = delegation;
}
public TaskData getTaskData() {
return taskData;
}
public void setTaskData(final TaskData taskData) {
this.taskData = taskData;
}
public Deadlines getDeadlines() {
return deadlines;
}
public void setDeadlines(final Deadlines deadlines) {
this.deadlines = deadlines;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + priority;
result = prime * result + CollectionUtils.hashCode(descriptions);
result = prime * result + CollectionUtils.hashCode(names);
result = prime * result + CollectionUtils.hashCode(subjects);
result = prime
* result
+ ((peopleAssignments == null) ? 0 : peopleAssignments
.hashCode());
result = prime * result
+ ((delegation == null) ? 0 : delegation.hashCode());
result = prime * result
+ ((taskData == null) ? 0 : taskData.hashCode());
result = prime * result
+ ((deadlines == null) ? 0 : deadlines.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Task)) {
return false;
}
final Task other = (Task) obj;
if (deadlines == null) {
if (other.deadlines != null) {
}
} else if (!deadlines.equals(other.deadlines)) {
return false;
}
if (delegation == null) {
if (other.delegation != null) {
return false;
}
} else if (!delegation.equals(other.delegation)) {
return false;
}
if (peopleAssignments == null) {
if (other.peopleAssignments != null) {
return false;
}
} else if (!peopleAssignments.equals(other.peopleAssignments)) {
return false;
}
if (priority != other.priority) {
return false;
}
if (taskData == null) {
if (other.taskData != null) {
return false;
}
} else if (!taskData.equals(other.taskData)) {
return false;
}
return (CollectionUtils.equals(descriptions, other.descriptions)
&& CollectionUtils.equals(names, other.names) && CollectionUtils
.equals(subjects, other.subjects));
}
/**
* @return the subTaskStrategies
*/
public List<SubTasksStrategy> getSubTaskStrategies() {
return subTaskStrategies;
}
/**
* @param subTaskStrategies
* the subTaskStrategies to set
*/
public void setSubTaskStrategies(
final List<SubTasksStrategy> subTaskStrategies) {
this.subTaskStrategies = subTaskStrategies;
}
}