private void generateFieldClasses(Task task)
throws ParserConfigurationException, SAXException, IOException {
String outputDirectory = task.getOutputBaseDirectory() + "/" + task.getFieldDirectory() + "/";
logInfo(task.getName() + ": generating field classes in " + outputDirectory);
writePackageDocumentation(outputDirectory, "FIX field definitions for " + task.getName());
Document document = getSpecification(task);
List<String> fieldNames = getNames(document.getDocumentElement(), "fields/field");
try {
Transformer transformer = createTransformer(task, "Fields.xsl");
for (String fieldName : fieldNames) {
String outputFile = outputDirectory + fieldName + ".java";
if (!new File(outputFile).exists()) {
logDebug("field: " + fieldName);
Map<String, String> parameters = new HashMap<>();
parameters.put("fieldName", fieldName);
parameters.put("fieldPackage", task.getFieldPackage());
if (task.isDecimalGenerated()) {
parameters.put("decimalType", "java.math.BigDecimal");
parameters.put("decimalConverter", "Decimal");
}
parameters.put(XSLPARAM_SERIAL_UID, SERIAL_UID_STR);
generateCodeFile(task, document, parameters, outputFile, transformer);
}
}
} catch (Exception e) {
logError("error while generating field classes", e);
}
}
@Override
public TaskRunResult run(Task task) {
OperationResult result =
task.getResult().createSubresult(WaitForTasksTaskHandler.class.getName() + ".run");
result.recordInProgress();
LOGGER.info("WaitForTasksTaskHandler run starting; in task " + task.getName());
try {
// todo resolve this brutal hack
taskManagerImpl.pauseTask(task, TaskWaitingReason.OTHER, result);
task.startWaitingForTasksImmediate(result);
} catch (SchemaException e) {
throw new SystemException(
"Couldn't mark task as waiting for prerequisite tasks",
e); // should not occur; will be handled by task runner
} catch (ObjectNotFoundException e) {
throw new SystemException(
"Couldn't mark task as waiting for prerequisite tasks",
e); // should not occur; will be handled by task runner
}
LOGGER.info("WaitForTasksTaskHandler run finishing; in task " + task.getName());
result.computeStatus();
TaskRunResult runResult = new TaskRunResult();
runResult.setOperationResult(result);
runResult.setProgress(task.getProgress()); // not to overwrite task's progress
runResult.setRunResultStatus(TaskRunResultStatus.FINISHED);
return runResult;
}
@Test
public void testGetTasksWithFilter() throws Exception {
List<Task> tasks = taskService.getTasks(TaskService.Filter.ALL);
for (Task task : tasks) {
assertNotNull(task);
assertTrue(task.getId() > 0);
assertNotNull(task.getName());
assertNotNull(task.getDescription());
assertNotNull(task.getTestSteps());
assertNotNull(task.getCreator());
assertNotNull(task.getAssignee());
assertNotNull(task.getStatus());
assertNotNull(task.getPriority());
assertNotNull(task.getType());
}
tasks = taskService.getTasks(TaskService.Filter.CREATOR, "1");
for (Task task : tasks) {
assertNotNull(task);
assertTrue(task.getId() > 0);
assertNotNull(task.getName());
assertNotNull(task.getDescription());
assertNotNull(task.getTestSteps());
assertNotNull(task.getCreator());
assertNotNull(task.getAssignee());
assertNotNull(task.getStatus());
assertNotNull(task.getPriority());
assertNotNull(task.getType());
}
}
private Document getSpecification(Task task)
throws ParserConfigurationException, SAXException, IOException {
Document document = specificationCache.get(task.getName());
if (document == null) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(task.getSpecification());
specificationCache.put(task.getName(), document);
}
return document;
}
public void saveTask(Task task) {
Task oldTask = findTask(task.getName());
if (oldTask == null) {
tasks.add(task);
} else {
for (int i = 0; i < tasks.size(); i++) {
if (StringUtils.equals(tasks.get(i).getName(), task.getName())) {
tasks.set(i, task);
}
}
}
}
private void generateComponentClasses(Task task)
throws ParserConfigurationException, SAXException, IOException,
TransformerFactoryConfigurationError, TransformerException {
logInfo(task.getName() + ": generating component classes");
String outputDirectory =
task.getOutputBaseDirectory() + "/" + task.getMessageDirectory() + "/component/";
Document document = getSpecification(task);
List<String> componentNames = getNames(document.getDocumentElement(), "components/component");
if (componentNames.size() > 0) {
writePackageDocumentation(outputDirectory, "Message component classes");
}
Transformer transformer = createTransformer(task, "MessageSubclass.xsl");
for (String componentName : componentNames) {
logDebug("generating component class: " + componentName);
Map<String, String> parameters = new HashMap<>();
parameters.put("itemName", componentName);
parameters.put("baseClass", "quickfix.MessageComponent");
parameters.put("subpackage", ".component");
parameters.put("fieldPackage", task.getFieldPackage());
parameters.put("messagePackage", task.getMessagePackage());
parameters.put("orderedFields", Boolean.toString(task.isOrderedFields()));
parameters.put(XSLPARAM_SERIAL_UID, SERIAL_UID_STR);
generateCodeFile(
task, document, parameters, outputDirectory + componentName + ".java", transformer);
}
}
@Test
public void createTasks() throws Exception {
List<int[]> selectedCubes = new ArrayList<>();
Statement stmt = f.createPrint(new True(), null);
List<Task> tasks = f.createTasks("blub", 10, stmt, selectedCubes);
assertEquals(1, tasks.size());
assertEquals("blub", tasks.get(0).getName());
assertEquals(10, tasks.get(0).getPriority());
assertEquals(stmt, tasks.get(0).getActivity());
assertEquals(null, tasks.get(0).getSelectedCube());
selectedCubes.addAll(Arrays.asList(new int[] {0, 0, 0}, new int[] {1, 1, 1}));
tasks = f.createTasks("test", 25, stmt, selectedCubes);
assertEquals(2, tasks.size());
for (Task t : tasks) {
assertEquals("test", t.getName());
assertEquals(25, t.getPriority());
assertEquals(stmt, t.getActivity());
assertTrue(
t.getSelectedCube().equals(new Vector(0, 0, 0))
|| t.getSelectedCube().equals(new Vector(1, 1, 1)));
}
}
/*
* Test method for 'fi.helsinki.cs.kohahdus.trainer.Task.setName(String)'
*/
public void testSetName() {
progtask.setName("Tehtävä kutonen");
result = progtask.getName();
expected = "Tehtävä kutonen";
assertEquals(expected, result);
progtask.setName("");
result = progtask.getName();
expected = "";
assertEquals(expected, result);
progtask.setName(null);
result = progtask.getName();
expected = null;
assertEquals(expected, result);
}
@Override
public void updateTask(Task task) {
SQLiteDatabase db = null;
try {
db = DBHelper.getReadableDatabase();
ContentValues taskValues = new ContentValues();
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_NAME, task.getName());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_DATE, task.convertDateString());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_TIME, task.convertTimeString());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_CATEGORY, task.getCategory());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_PRIORITY, task.getPriority());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_LOCATION, task.getLocation());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_STATUS, task.getStatus());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_ASSIGNEE, task.getAssignee());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_FIREBASE_ID, task.getFirebaseId());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_PICTURE, task.getPicture());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_ACCEPT_STATUS, task.getAcceptStatus());
taskValues.put(
TasKingDBNames.TaskEntry.COLUMN_TASK_TIME_STAMP,
new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.US).format(new Date()));
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_MANAGER_ID, task.getManagerUid());
taskValues.put(TasKingDBNames.TaskEntry.COLUMN_TASK_ASSIGNEE_ID, task.getAssigneeUid());
db.update(
TasKingDBNames.TaskEntry.TABLE_NAME,
taskValues,
TasKingDBNames.TaskEntry.COLUMN_TASK_FIREBASE_ID + "=?",
new String[] {task.getFirebaseId()});
} finally {
if (db != null) {
db.close();
}
}
}
@Test
public void testCreateTask() throws Exception {
TaskBuilder builder = taskService.createTask();
builder.creator(user);
builder.project(project);
builder.name(name);
builder.description(desc);
builder.testSteps(teststeps);
builder.type(type);
builder.estimated(8);
builder.priority(priority);
Task task = builder.build();
task.store();
assertNotNull(task);
assertTrue(task.getId() > 0);
assertEquals(name, task.getName());
assertEquals(desc, task.getDescription());
assertEquals(teststeps, task.getTestSteps());
assertEquals(user.getName(), task.getCreator().getName());
assertEquals(user.getName(), task.getAssignee().getName());
assertEquals("New", task.getStatus().getName());
assertEquals(priority, task.getPriority());
assertEquals(type, task.getType());
}
private void generateMessageBaseClass(Task task)
throws ParserConfigurationException, SAXException, IOException,
TransformerFactoryConfigurationError, TransformerException {
logInfo(task.getName() + ": generating message base class");
Map<String, String> parameters = new HashMap<>();
parameters.put(XSLPARAM_SERIAL_UID, SERIAL_UID_STR);
generateClassCode(task, "Message", parameters);
}
private void populateJCombBox() {
String item = "";
for (Task t : this.session.getTasks()) {
this.jComboBoxTask.addItem(t.getName());
for (Period p : t.getPeriods()) {
item =
t.getName()
+ " | "
+ p.getStartDate().getTime()
+ " - "
+ p.getEndDate().getTime()
+ " | "
+ p.getElapsedTime();
this.jComboBoxPeriod.addItem(item);
}
}
}
public Task removeTask(String taskName) {
for (int i = 0; i < tasks.size(); i++) {
Task task = tasks.get(i);
if (StringUtils.equals(task.getName(), taskName)) {
tasks.remove(i);
return task;
}
}
return null;
}
@Test
public void testGetTaskFulltext() throws Exception {
String search = "Third Task";
List<Task> tasks = taskService.getTaskFulltext("\"" + search + "\"");
for (Task task : tasks) {
assertTrue(
task.getName().contains(search)
|| task.getDescription().contains(search)
|| task.getTestSteps().contains(search));
}
}
public void addTask(Task task) {
/*
Adds a new task to the list view and saves its data in the
SharedPreferences file.
*/
adapter.add(task);
keys.add(task.getKey());
SharedPreferences.Editor edit = appData.edit();
edit.putString(task.getKey(), task.getName() + "\n" + task.getDescription());
edit.apply();
}
/**
* @param tasks
* @return
*/
public List<TaskVo> buildTaskVos(List<Task> tasks) {
List<TaskVo> taskRtn = new ArrayList<>();
if (null != tasks && !tasks.isEmpty()) {
// 根据流程的业务ID查询实体并关联
for (Task task : tasks) {
String processInstanceId = task.getProcessInstanceId();
ProcessInstance processInstance =
runtimeService
.createProcessInstanceQuery()
.processInstanceId(processInstanceId)
.active()
.singleResult();
String businessName = (String) task.getTaskLocalVariables().get(WebConstants.BUSINESS_NAME);
String taskId = task.getId();
String businessKey = processInstance.getBusinessKey();
if (StringUtils.isBlank(businessKey)) {
continue;
}
if (StringUtils.isBlank(businessName)) {
businessName = getBusinessName(taskId, businessKey);
}
ProcessDefinition processDefinition =
getProcessDefinition(processInstance.getProcessDefinitionId());
int version = processDefinition.getVersion();
String taskName = task.getName();
String createTime =
DateUtils.SINGLETONE.format(task.getCreateTime(), DateUtils.YYYY_MM_DD_HH_MM_SS);
String assignee = task.getAssignee();
boolean suspended = task.isSuspended();
String processDefinitionId = processInstance.getProcessDefinitionId();
TaskVo taskInfo = new TaskVo();
taskInfo.setProcessInstanceId(processInstanceId);
taskInfo.setBusinessKey(businessKey);
taskInfo.setProcessDefinitionId(processDefinitionId);
taskInfo.setId(taskId);
taskInfo.setName(taskName);
taskInfo.setCreateTime(createTime);
taskInfo.setAssignee(assignee);
taskInfo.setSuspended(suspended);
taskInfo.setVersion(version);
taskInfo.setBusinessName(businessName);
taskRtn.add(taskInfo);
}
}
return taskRtn;
}
@Test
public void testGetTaskByID() throws Exception {
Optional<Task> optTask = taskService.getTaskByID(1);
assertTrue(optTask.isPresent());
Task task = optTask.get();
assertNotNull(task);
assertEquals(1, task.getId());
assertNotNull(task.getName());
assertNotNull(task.getDescription());
assertNotNull(task.getTestSteps());
assertNotNull(task.getCreator());
assertNotNull(task.getAssignee());
assertNotNull(task.getStatus());
assertNotNull(task.getPriority());
assertNotNull(task.getType());
}
/**
* printTimeChart prints a timeline representing when processes are scheduled
*
* @param tasks the processes that have been scheduled
*/
private void printTimeChart(ArrayList<Task> tasks) {
int quanta = 0;
System.out.print("0"); // The beginning of timeline
for (Task task : tasks) {
// Print underscore blanks for idle time
while (quanta++ < task.getStartTime()) {
System.out.print("___"); // 3 for all characters of a process name
}
// Print the process name on the quanta that it runs
quanta = (int) (task.getStartTime() + Math.ceil(task.getRunTime()));
for (int i = 0; i < task.getRunTime(); ++i) {
System.out.print(task.getName());
}
}
System.out.println(); // add new line after time chart
}
@Test
public void testGetTaskByUserCommented() throws Exception {
List<Task> tasks = taskService.getTaskByUserCommented(1);
for (Task task : tasks) {
assertNotNull(task);
assertTrue(task.getId() > 0);
assertNotNull(task.getName());
assertNotNull(task.getDescription());
assertNotNull(task.getTestSteps());
assertNotNull(task.getCreator());
assertNotNull(task.getAssignee());
assertNotNull(task.getStatus());
assertNotNull(task.getPriority());
assertNotNull(task.getType());
}
}
/**
* Returns control when task is complete.
*
* @param json
* @param logger
*/
private String waitForDeploymentCompletion(JSON json, OctopusApi api, Log logger) {
final long WAIT_TIME = 5000;
final double WAIT_RANDOM_SCALER = 100.0;
JSONObject jsonObj = (JSONObject) json;
String id = jsonObj.getString("TaskId");
Task task = null;
String lastState = "Unknown";
try {
task = api.getTask(id);
} catch (IOException ex) {
logger.error("Error getting task: " + ex.getMessage());
return null;
}
logger.info("Task info:");
logger.info("\tId: " + task.getId());
logger.info("\tName: " + task.getName());
logger.info("\tDesc: " + task.getDescription());
logger.info("\tState: " + task.getState());
logger.info("\n\nStarting wait...");
boolean completed = task.getIsCompleted();
while (!completed) {
try {
task = api.getTask(id);
} catch (IOException ex) {
logger.error("Error getting task: " + ex.getMessage());
return null;
}
completed = task.getIsCompleted();
lastState = task.getState();
logger.info("Task state: " + lastState);
if (completed) {
break;
}
try {
Thread.sleep(WAIT_TIME + (long) (Math.random() * WAIT_RANDOM_SCALER));
} catch (InterruptedException ex) {
logger.info("Wait interrupted!");
logger.info(ex.getMessage());
completed = true; // bail out of wait loop
}
}
logger.info("Wait complete!");
return lastState;
}
public Task getTask(String code) {
for (TaskImpl t : tasks) {
if (t.getCode().equals(code)) {
return t;
}
}
Task result = null;
for (Task t : tasks) {
if (t.getCode().startsWith(code) == false) {
continue;
}
if (result == null) {
result = t;
} else {
result = new TaskMerge(result.getCode(), result.getName(), result, t);
}
}
return result;
}
private void getTaskSwitch(TypedCircularMessage message, long ts) {
final Long objTaskId = (Long) getValue(message, 0);
final int taskId = objTaskId.intValue();
Task task = getTaskFromId(objTaskId);
task.setHasExecutedDuringLog(true);
final Object objPrio = getValue(message, 1);
int prio;
if (objPrio != null) {
prio = ((Long) objPrio).intValue();
} else {
prio = -777;
}
FieldValues values = new FieldValues();
client.eventRead(
new TaskSwitchEventInfo(
ts, taskId, lastTaskId, prio, EventFactory.TASK_SWITCH_EVENT_TYPE_ID, values));
lastInterruptPrio = prio;
lastTaskId = taskId;
lastTaskName = task.getName();
}
/**
* Renames a task.
*
* @param node the node that contains the task to rename
* @param name the new name of the task
*/
public void rename(Task node, String name) {
/* don't rename if null name or name hasn't changed */
if (name == null || name.compareTo(node.getName()) == 0) return;
/* store the old task folder and plain name */
File path = this.getNodePath(node);
String plainName = node.getPlainName();
/* rename the task */
node.setName(name);
/* no need to rename, if the plain name hasn't changed */
if (node.getPlainName().compareTo(plainName) == 0) return;
/* rename the folder */
path.renameTo(this.getNodePath(node));
/* update the treeModel, so the node will be repainted in the tree view */
this.treeModel.nodeChanged(node);
}
private void generateClassCode(Task task, String className, Map<String, String> parameters)
throws ParserConfigurationException, SAXException, IOException,
TransformerFactoryConfigurationError, TransformerException {
logDebug("generating " + className + " for " + task.getName());
if (parameters == null) {
parameters = new HashMap<>();
}
parameters.put("messagePackage", task.getMessagePackage());
parameters.put("fieldPackage", task.getFieldPackage());
Document document = getSpecification(task);
generateCodeFile(
task,
document,
parameters,
task.getOutputBaseDirectory()
+ "/"
+ task.getMessageDirectory()
+ "/"
+ className
+ ".java",
createTransformer(task, className + ".xsl"));
}
/** Creates the task element, corressponding to <define name="task"> */
private Element createTaskElement(Document doc, Task task) {
Element taskE = doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.TASK.getXMLName());
// **** attributes *****
// **** common attributes ***
if (task.getOnTaskErrorProperty().isSet()) {
setAttribute(
taskE,
XMLAttributes.COMMON_ON_TASK_ERROR,
task.getOnTaskErrorProperty().getValue().toString(),
true);
}
if (task.getMaxNumberOfExecutionProperty().isSet()) {
setAttribute(
taskE,
XMLAttributes.COMMON_MAX_NUMBER_OF_EXECUTION,
Integer.toString(task.getMaxNumberOfExecution()));
}
setAttribute(taskE, XMLAttributes.COMMON_NAME, task.getName(), true);
if (task.getRestartTaskOnErrorProperty().isSet()) {
setAttribute(
taskE,
XMLAttributes.COMMON_RESTART_TASK_ON_ERROR,
task.getRestartTaskOnError().toString());
}
// *** task attributes ***
if (task.getWallTime() != 0) {
setAttribute(taskE, XMLAttributes.TASK_WALLTIME, formatDate(task.getWallTime()));
}
if (task.isRunAsMe()) {
setAttribute(taskE, XMLAttributes.TASK_RUN_AS_ME, "true");
}
if (task.isPreciousResult()) {
setAttribute(taskE, XMLAttributes.TASK_PRECIOUS_RESULT, "true");
}
if (task.isPreciousLogs()) {
setAttribute(taskE, XMLAttributes.TASK_PRECIOUS_LOGS, "true");
}
// *** elements ****
// <ref name="variables"/>
if (task.getVariables() != null && !task.getVariables().isEmpty()) {
Element variablesE = createTaskVariablesElement(doc, task.getVariables());
taskE.appendChild(variablesE);
}
// <ref name="taskDescription"/>
if (task.getDescription() != null) {
Element descrNode =
createElement(doc, XMLTags.COMMON_DESCRIPTION.getXMLName(), task.getDescription());
taskE.appendChild(descrNode);
}
// <ref name="genericInformation"/>
if ((task.getGenericInformation() != null) && (task.getGenericInformation().size() > 0)) {
Element genericInfoE = createGenericInformation(doc, task.getGenericInformation());
taskE.appendChild(genericInfoE);
}
// <ref name="depends"/>
List<Task> dependencies = task.getDependencesList();
if ((dependencies != null) && (dependencies.size() > 0)) {
Element dependsE =
doc.createElementNS(
Schemas.SCHEMA_LATEST.namespace, XMLTags.TASK_DEPENDENCES.getXMLName());
for (Task dep : dependencies) {
Element dependsTask =
doc.createElementNS(
Schemas.SCHEMA_LATEST.namespace, XMLTags.TASK_DEPENDENCES_TASK.getXMLName());
setAttribute(dependsTask, XMLAttributes.TASK_DEPENDS_REF, dep.getName(), true);
dependsE.appendChild(dependsTask);
}
taskE.appendChild(dependsE);
} // if has dependencies
// <ref name="inputFiles"/>
List<InputSelector> inputFiles = task.getInputFilesList();
if (inputFiles != null) {
Element inputFilesE =
doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.DS_INPUT_FILES.getXMLName());
for (InputSelector inputSelector : inputFiles) {
FileSelector fs = inputSelector.getInputFiles();
Element filesE =
doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.DS_FILES.getXMLName());
// the xml only supports one value for the includes/excludes
// pattern
if (!fs.getIncludes().isEmpty())
setAttribute(filesE, XMLAttributes.DS_INCLUDES, fs.getIncludes().iterator().next(), true);
if (!fs.getExcludes().isEmpty())
setAttribute(filesE, XMLAttributes.DS_EXCLUDES, fs.getExcludes().iterator().next(), true);
if (inputSelector.getMode() != null) {
setAttribute(
filesE, XMLAttributes.DS_ACCESS_MODE, inputSelector.getMode().toString(), true);
}
inputFilesE.appendChild(filesE);
}
taskE.appendChild(inputFilesE);
}
// <ref name="parallel"/>
Element parallelEnvE = createParallelEnvironment(doc, task);
if (parallelEnvE != null) taskE.appendChild(parallelEnvE);
// <ref name="selection"/>
List<SelectionScript> selectionScripts = task.getSelectionScripts();
if (selectionScripts != null && selectionScripts.size() > 0) {
Element selectionE =
doc.createElementNS(
Schemas.SCHEMA_LATEST.namespace, XMLTags.SCRIPT_SELECTION.getXMLName());
for (SelectionScript selectionScript : selectionScripts) {
Element scriptE = createScriptElement(doc, selectionScript);
selectionE.appendChild(scriptE);
}
taskE.appendChild(selectionE);
}
// <ref name="forkEnvironment"/>
if (task.getForkEnvironment() != null) {
Element forkEnvE = createForkEnvironmentElement(doc, task.getForkEnvironment());
taskE.appendChild(forkEnvE);
}
// <ref name="pre"/>
Script preScript = task.getPreScript();
if (preScript != null) {
Element preE =
doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.SCRIPT_PRE.getXMLName());
Element scriptE = createScriptElement(doc, preScript);
preE.appendChild(scriptE);
taskE.appendChild(preE);
}
// <ref name="executable"/>
Element executableE = null;
if (task instanceof JavaTask) {
executableE = createJavaExecutableElement(doc, (JavaTask) task);
} else if (task instanceof NativeTask) {
executableE = createNativeExecutableElement(doc, (NativeTask) task);
} else if (task instanceof ScriptTask) {
executableE = createScriptExecutableElement(doc, (ScriptTask) task);
}
taskE.appendChild(executableE);
// <ref name="flow"/>
Element controlFlowE = createFlowControlElement(doc, task);
if (controlFlowE != null) taskE.appendChild(controlFlowE);
// <ref name="post"/>
Script postScript = task.getPostScript();
if (postScript != null) {
Element postE =
doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.SCRIPT_POST.getXMLName());
Element scriptE = createScriptElement(doc, postScript);
postE.appendChild(scriptE);
taskE.appendChild(postE);
}
// <ref name="cleaning"/>
Script cleanScript = task.getCleaningScript();
if (cleanScript != null) {
Element cleanE =
doc.createElementNS(
Schemas.SCHEMA_LATEST.namespace, XMLTags.SCRIPT_CLEANING.getXMLName());
Element scriptE = createScriptElement(doc, cleanScript);
cleanE.appendChild(scriptE);
taskE.appendChild(cleanE);
}
// <ref name="outputFiles"/>
List<OutputSelector> outputFiles = task.getOutputFilesList();
if (outputFiles != null) {
Element outputFilesE =
doc.createElementNS(
Schemas.SCHEMA_LATEST.namespace, XMLTags.DS_OUTPUT_FILES.getXMLName());
for (OutputSelector outputSelector : outputFiles) {
FileSelector fs = outputSelector.getOutputFiles();
Element filesE =
doc.createElementNS(Schemas.SCHEMA_LATEST.namespace, XMLTags.DS_FILES.getXMLName());
// the xml only supports one value for the includes/excludes
// pattern
if (!fs.getIncludes().isEmpty())
setAttribute(filesE, XMLAttributes.DS_INCLUDES, fs.getIncludes().iterator().next(), true);
if (!fs.getExcludes().isEmpty())
setAttribute(filesE, XMLAttributes.DS_EXCLUDES, fs.getExcludes().iterator().next(), true);
if (outputSelector.getMode() != null) {
setAttribute(
filesE, XMLAttributes.DS_ACCESS_MODE, outputSelector.getMode().toString(), true);
}
outputFilesE.appendChild(filesE);
}
taskE.appendChild(outputFilesE);
}
return taskE;
}
public ArrayList<Machine> AssignTasks()
throws TasksPowerNeedExceedsMachinesPowerException, TaskAssignmentNotPossibleException {
if (getTasksPowerNeed() > getMachinesPower()) {
throw new TasksPowerNeedExceedsMachinesPowerException();
}
int tasksToAssignCount = tasks.size();
Collections.sort(
tasks,
new Comparator<Task>() {
@Override
public int compare(Task o1, Task o2) {
return -o1.get_time_needed().compareTo(o2.get_time_needed());
}
});
Collections.sort(
machines,
new Comparator<Machine>() {
@Override
public int compare(Machine o1, Machine o2) {
return -o1.get_power().compareTo(o2.get_power());
}
});
int machines_count = machines.size();
int current_machine = 0;
while (tasksToAssignCount > 0) {
for (Task taskIt : tasks) {
if (taskIt.dependenciesSatisfied() && !taskIt.isAssigned()) {
int lowestTime = -1;
for (Task depTaskIt : taskIt.getDependencies()) {
int tmp = depTaskIt.getLowestMachineTime();
if (tmp > lowestTime) {
lowestTime = tmp;
}
}
int machines_tested = 0;
boolean found = false;
while (machines_tested < machines_count && !found) {
Machine t = machines.get(current_machine % machines_count);
if (t.getPowerTaken() >= lowestTime) {
if (t.get_power_available() >= taskIt.get_time_needed()) {
found = true;
} else {
current_machine++;
machines_tested++;
}
} else { // sprawdzamy czy mozna fillera zrobic
int fillerSize = lowestTime - t.getPowerTaken();
if (t.get_power_available() >= fillerSize + taskIt.get_time_needed()) {
found = true;
Task filler = new Task(fillerSize, null, "filler");
filler.setFiller(true);
t.addTask(filler);
} else {
current_machine++;
machines_tested++;
}
}
}
if (!found) {
throw new TaskAssignmentNotPossibleException();
}
if (machines_tested < machines_count) {
Machine tmp = machines.get(current_machine % machines_count);
tmp.addTask(taskIt);
System.out.println("Przydzielam zadanie " + taskIt.getName());
taskIt.setAssignedMachine(tmp);
tasksToAssignCount--;
} else {
throw new TaskAssignmentNotPossibleException();
}
current_machine++;
}
}
}
return machines;
}
{
when(gc.getName()).thenReturn("gc");
when(clearCache.getName()).thenReturn("clear-cache");
}
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
String username = (String) session.getAttribute("username");
String curCategId = (String) session.getAttribute("curCategId");
response.setContentType("text/html;charset=UTF-8");
String action = request.getParameter("action");
PrintWriter out = response.getWriter();
System.out.println("Action = " + action);
if (action.equalsIgnoreCase("showCategory")) {
ArrayList<Category> categories = new ArrayList<Category>(joinOp.GetCategByUsername(username));
out.println("<div class='kategori'>");
out.println("<div id='categoryAll' onclick='showTaskList(0);'>All</div>");
out.println("</div>");
for (Category categ : categories) {
out.println("<div class='kategori'>");
out.println(
"<div id='category"
+ categ.getId_category()
+ "'"
+ "onclick='showTaskList("
+ categ.getId_category()
+ ");'>"
+ categ.getName()
+ "</div>");
if (username.equals(categ.getCateg_creator())) {
out.println(
"<div class='removeCategory' id='removeCateg"
+ categ.getId_category()
+ "' onclick='return removeCategory("
+ categ.getId_category()
+ ");'>x</div>");
}
out.println("</div>");
}
} else if (action.equalsIgnoreCase("addCategory")) {
String categName = request.getParameter("name");
String[] authUsers = request.getParameter("authUsers").split(",");
categoryOp.InsertNewCategory(new Category("", categName, username));
String newCategId = categoryOp.FetchIdByName(categName);
caurelationOp.InsertCaurelation(new Caurelation("", newCategId, username));
ucrelationOp.InsertUcrelation(new Ucrelation("", username, newCategId));
if (authUsers.length != 0) {
for (String authUser : authUsers) {
if (userOp.ListAllUsernames().contains(authUser)) {
ucrelationOp.InsertUcrelation(new Ucrelation("", authUser.trim(), newCategId));
caurelationOp.InsertCaurelation(new Caurelation("", newCategId, authUser));
}
}
}
} else if (action.equalsIgnoreCase("removeCategory")) {
String categId = request.getParameter("code");
ArrayList<String> taskIds = new ArrayList<String>(taskOp.FetchIdsByCategId(categId));
for (String taskId : taskIds) {
ttrelationOp.DeleteByTaskId(taskId);
utrelationOp.DeleteByTaskId(taskId);
tarelationOp.DeleteTarelationByTaskId(taskId);
commentOp.DeleteCommentByTaskId(taskId);
taskOp.DeleteById(taskId);
}
ucrelationOp.DeleteByCategId(categId, username);
caurelationOp.DeleteCaurelationByCategId(categId);
categoryOp.DeleteCategoryById(categId);
} else if (action.equalsIgnoreCase("showTaskList")) {
String categId = request.getParameter("code");
session.setAttribute("curCategId", categId);
ArrayList<Task> tasks =
new ArrayList<Task>(joinOp.GetTasksByUsernameAndCategoryId(username, categId));
ArrayList<String> tags;
int i = 0;
for (Task task : tasks) {
i = 0;
out.println("<div class='listTugas'>");
out.println(
"<a class='listname' id='task"
+ task.getId_task()
+ "'"
+ "onclick='showRinci("
+ task.getId_task()
+ ");'>"
+ task.getName()
+ "</a>");
out.println("<div class='listdeadline'>Deadline: " + task.getDeadline() + "</div>");
tags = new ArrayList<String>(joinOp.GetTagNamesByTaskId(task.getId_task()));
out.println("<div class='listtag'>Tag: ");
while (i < tags.size()) {
out.print(tags.get(i));
i++;
if (i < tags.size()) {
out.print(", ");
}
}
out.println("</div>");
out.println("<div class='liststatus' id='statusTask'>");
if (task.getStatus().equals("T")) {
out.println(
"<input type='checkbox' id='checkboxTask"
+ task.getId_task()
+ "' onclick='changeTaskStatus("
+ task.getId_task()
+ ", this.checked);' checked>");
} else if (task.getStatus().equals("F")) {
out.println(
"<input type='checkbox' id='checkboxTask"
+ task.getId_task()
+ "' onclick='changeTaskStatus("
+ task.getId_task()
+ ", this.checked);'>");
}
out.println("Done</div>");
if (username.equals(taskOp.FetchCreatorById(task.getId_task()))) {
out.println(
"<div class='removeTask'><input type='submit' id='removeTaskBtn"
+ task.getId_task()
+ "' onclick='removeTask("
+ curCategId
+ ","
+ task.getId_task()
+ ");' value='Remove Task'/></div>");
}
out.println("</div>");
}
if (caurelationOp.FetchAuthUsersByCategId(categId).contains(username)) {
out.println("<a onclick='showBuat();' class='addTask'>+task</a>");
}
} else if (action.equalsIgnoreCase("showTaskDetail")) {
String taskId = request.getParameter("code");
Task task = taskOp.SelectById(taskId);
out.println("<div id='taskdetail'>");
// NAME
out.println("<div id='taskdetail_name'>" + task.getName() + "</div><br>");
// STATUS
out.println("<br><div>=======================================================</div>");
if (task.getStatus().equalsIgnoreCase("T")) {
out.println(
"<div id='taskdetail_status'><em>Status : </em>Done "
+ "<input type='checkbox' onclick='changeTaskStatus("
+ task.getId_task()
+ ", this.checked);' checked/>"
+ "</div>");
} else {
out.println(
"<div id='taskdetail_status'>Status : Done "
+ "<input type='checkbox' onclick='changeTaskStatus("
+ task.getId_task()
+ ", this.checked);'/>"
+ "</div>");
}
// ATTACHMENT
ArrayList<Attachment> attachments = joinOp.GetAttachmentFromId_task(task.getId_task());
int extensionIdx;
String extension, filename;
out.println("<br><div>=======================================================</div>");
out.println("<div><em>Attachment: </em></div>");
out.println("<div id='taskdetail_attachment'>");
for (Attachment item : attachments) {
extensionIdx = item.getPath().lastIndexOf('.');
if (extensionIdx > 0) {
filename = item.getPath().substring(item.getPath().lastIndexOf('/') + 1);
extension = item.getPath().substring(extensionIdx + 1);
System.out.println(item.getPath() + " has extension " + extension);
// jika gambar
if (extension.equalsIgnoreCase("jpg")
|| extension.equalsIgnoreCase("png")
|| extension.equalsIgnoreCase("gif")) {
System.out.println(filename);
out.println("<img src='" + item.getPath() + "' height=\"100\" width=\"100\"/><br>");
out.println("<a href='" + item.getPath() + "'>" + filename + "</a><br>");
// jika video
} else if (extension.equalsIgnoreCase("mp4")
|| extension.equalsIgnoreCase("webm")
|| extension.equalsIgnoreCase("ogg")) {
out.println("<video width=\"320\" height=\"240\" controls>");
out.println("<source src='" + item.getPath() + "' type='video/" + extension + "'>");
out.println("</video><br>");
out.println("<a href='" + item.getPath() + "'>" + filename + "</a><br>");
} else {
out.println("<a href='" + item.getPath() + "'>" + filename + "</a><br>");
}
}
}
out.println("</div>");
// DEADLINE
out.println("<br><div>=======================================================</div>");
out.println(
"<div id='taskdetail_deadline'><em>Deadline: </em>" + task.getDeadline() + "</div>");
// ASSIGNEE
out.println("<br><div>=======================================================</div>");
ArrayList<String> assignees = utrelationOp.FetchAssigneeByTaskId(task.getId_task());
out.println("<div id='taskdetail_assignee'><em>Assignee: </em>");
int i = 0;
while (i < assignees.size()) {
out.println(
"<a href='profile.jsp?userprofile="
+ assignees.get(i)
+ "'>"
+ assignees.get(i)
+ "</a>");
i++;
if (i < assignees.size()) {
out.print("; ");
}
}
out.println("</div>");
// KOMENTAR
out.println("<br><div>=======================================================</div>");
out.println("<div><em>Comment: </em></div>");
User user;
String[] timesplit;
ArrayList<Comment> comments = commentOp.FetchCommentByTaskId(task.getId_task());
out.println("<div id='ctotal'>" + comments.size() + " comment(s)</div>");
out.println("<div id='taskdetail_comment'>");
out.println("<div id='commentlist'>");
for (Comment item : comments) {
out.println("<div id='comment" + item.getId_comment() + "'>");
user = userOp.SelectUserInfoByUsername(item.getUsername());
timesplit = item.getTimestamp().split(":");
System.out.println("LALALALALA" + timesplit.length);
out.println(
"<img class='cavatar' src='"
+ user.getAvatar()
+ "' style='width:30px; height:30px;'/>");
out.println(
"<div class='ctimestamp'>"
+ timesplit[3]
+ ":"
+ timesplit[4]
+ " - "
+ timesplit[2]
+ "/"
+ timesplit[1]
+ "</div>");
out.println("<div class='ccontent'>" + item.getContent() + "</div>");
if (username.equals(user.getUsername())) {
out.println(
"<input type='button' value='Delete' class='cdelete' onclick='delComment("
+ item.getId_comment()
+ ");'/>");
}
out.println("</div>");
}
out.println("</div>");
out.println("<div id='commentbox'>");
out.println("<textarea id='cbox'></textarea></br>");
out.println("<input type='button' value='Submit' onclick='addComment(" + taskId + ");'/>");
out.println("</div>");
out.println("</div>");
// TAG
out.println("<br><div>=======================================================</div>");
ArrayList<Tag> tags = joinOp.GetTagFromId_task(task.getId_task());
out.println("<div id='taskdetail_tag'><em>Tag: </em>");
i = 0;
while (i < tags.size()) {
out.println(tags.get(i).getName());
i++;
if (i < tags.size()) {
out.print("; ");
}
}
out.println("</div>");
if (utrelationOp.IsTaskEditable(username, taskId)) {
out.println(
"<input type='button' value='Edit task' onclick='editTaskDetail("
+ task.getId_task()
+ ");'/>");
}
out.println("<input type='button' value='Back' onclick='restore2();'/>");
out.println("</div>");
} else if (action.equalsIgnoreCase("editTaskDetail")) {
String taskId = request.getParameter("code");
Task task = taskOp.SelectById(taskId);
out.println("<div id='editdetail'>");
out.println("<form>");
out.println("<big style='font-size: 20pt;'>" + task.getName() + "</big><br/>");
out.println(
"<br/>Deadline: <input type='date' id='editDeadline' name='editDeadline' value='"
+ task.getDeadline()
+ "'><br/>");
out.println(
"<br/><div class='assignee'>Assignee: <input type='text' id='editAssignee'"
+ "name='editAssignee' value='");
ArrayList<String> authUsers =
new ArrayList<String>(utrelationOp.FetchAssigneeByTaskId(taskId));
int i = 0;
while (i < authUsers.size()) {
out.print(authUsers.get(i));
i++;
if (i < authUsers.size()) {
out.print(",");
}
}
out.print(
"' onkeyup=\"multiAutocomp(this, 'getAllUser.jsp');\" onfocusin='multiAutocompClearAll();'></div><br/>");
out.println("<div class='tag'>Tag: <input type='text' id='editTag' name='editTag' value='");
ArrayList<String> tags = new ArrayList<String>(joinOp.GetTagNamesByTaskId(task.getId_task()));
i = 0;
while (i < tags.size()) {
out.print(tags.get(i));
i++;
if (i < tags.size()) {
out.print(",");
}
}
out.print(
"' onkeyup=\"multiAutocomp(this, 'getAllTag.jsp');\" onfocusin='multiAutocompClearAll();'></div><br/>");
out.println("</form><br/>");
if (username.equals(taskOp.FetchCreatorById(task.getId_task()))) {
out.println(
"<input type='button' id='editremove' onclick='removeTask("
+ curCategId
+ ", "
+ task.getId_task()
+ ");' class='button' value='Remove Task'/><br>");
} else if (utrelationOp.FetchAssigneeByTaskId(task.getId_task()).contains(username)) {
out.println(
"<input type='button' id='editremove' onclick='removeReference("
+ curCategId
+ ", "
+ task.getId_task()
+ ");' class='button' value='Remove me from this task'/><br>");
}
out.println(
"<input type='button' id='editsave' onclick='saveTaskDetail("
+ task.getId_task()
+ ");' class='button' value='Save'/>");
out.println(
"<input type='button' id='editback' onclick='restore4();' class='button' value='Back'/>");
out.println("</div>");
} else if (action.equalsIgnoreCase("changeTaskStatus")) {
String taskId = request.getParameter("code");
String newStatus = request.getParameter("chkYesNo");
if (newStatus.equals("0")) {
taskOp.UpdateStatusWithId("F", taskId);
} else if (newStatus.equals("1")) {
taskOp.UpdateStatusWithId("T", taskId);
}
out.println("<div>");
if (newStatus.equals("0")) {
out.println(
"<input type='checkbox' id='checkboxTask"
+ taskId
+ "' "
+ "onclick='changeTaskStatus("
+ taskId
+ ", this.checked);' checked>");
} else if (newStatus.equals("1")) {
out.println(
"<input type='checkbox' id='checkboxTask"
+ taskId
+ "' "
+ "onclick='changeTaskStatus("
+ taskId
+ ", this.checked);'>");
}
out.println("Done</div>");
} else if (action.equalsIgnoreCase("saveTaskDetail")) {
String taskId = request.getParameter("code");
String deadline = request.getParameter("newDeadline");
String[] assignees = request.getParameter("newAssignees").split(",");
String[] tags = request.getParameter("newTags").split(",");
ArrayList<String> oldAssignees =
new ArrayList<String>(utrelationOp.FetchAssigneeByTaskId(taskId));
ArrayList<String> oldTagIds = new ArrayList<String>(joinOp.GetTagsIdByTaskId(taskId));
taskOp.UpdateDeadlineById(deadline, taskId);
for (String oldAssignee : oldAssignees) {
utrelationOp.DeleteByTaskIdAndUsername(taskId, oldAssignee);
}
for (String oldTagId : oldTagIds) {
ttrelationOp.DeleteByTagId(oldTagId);
}
for (String assignee : assignees) {
if (userOp.ListAllUsernames().contains(assignee.trim())) {
utrelationOp.InsertUtrelation(new Utrelation("", taskId, assignee.trim()));
if (ucrelationOp.CheckIfUcrelationExists(assignee.trim(), curCategId) == 0) {
ucrelationOp.InsertUcrelation(new Ucrelation("", assignee.trim(), curCategId));
}
}
}
for (String tag : tags) {
if (tagOp.CheckIfTagExists(tag.trim()) == 0) {
tagOp.InsertTag(tag.trim());
}
ttrelationOp.InsertTtrelation(new Ttrelation("", taskId, tagOp.SelectIdByName(tag.trim())));
}
ArrayList<Task> temp;
for (String oldAssignee : oldAssignees) {
temp = new ArrayList<Task>(joinOp.GetTasksByUsernameAndCategoryId(oldAssignee, curCategId));
if (temp.isEmpty()) {
ucrelationOp.DeleteByCategId(curCategId, oldAssignee);
}
}
for (String oldTagId : oldTagIds) {
if (joinOp.CheckTtrelationByTagId(oldTagId) == 0) {
tagOp.DeleteById(oldTagId);
}
}
} else if (action.equalsIgnoreCase("addTask")) {
String[] assignees = request.getParameter("newTaskAssignee").split(",");
String[] tags = request.getParameter("newTaskTags").split(",");
String name = request.getParameter("newTaskName");
} else if (action.equalsIgnoreCase("removeTask")) {
String taskId = request.getParameter("code");
tarelationOp.DeleteTarelationByTaskId(taskId);
ttrelationOp.DeleteByTaskId(taskId);
commentOp.DeleteCommentByTaskId(taskId);
utrelationOp.DeleteByTaskId(taskId);
taskOp.DeleteById(taskId);
ArrayList<String> allUsers = new ArrayList<String>(userOp.ListAllUsernames());
ArrayList<Task> temp;
for (String user : allUsers) {
if (!user.equals(username)) {
temp = new ArrayList<Task>(joinOp.GetTasksByUsernameAndCategoryId(user, curCategId));
if (temp.isEmpty()) {
ucrelationOp.DeleteByCategId(curCategId, username);
}
}
}
} else if (action.equalsIgnoreCase("removeReference")) {
String taskId = request.getParameter("code");
utrelationOp.DeleteByTaskId(taskId);
ArrayList<Task> temp =
new ArrayList<Task>(joinOp.GetTasksByUsernameAndCategoryId(username, curCategId));
if (temp.isEmpty()) {
ucrelationOp.DeleteByCategId(curCategId, username);
}
} else if (action.equalsIgnoreCase("addComment")) {
String idtask = request.getParameter("it");
String content = request.getParameter("c");
DateFormat dateFormat = new SimpleDateFormat("yyyy:MM:dd:HH:mm");
Date date = new Date();
String timestamp = dateFormat.format(date).toString();
String avatar = userOp.SelectUserInfoByUsername(username).getAvatar();
commentOp.InsertComment(idtask, username, dateFormat.format(date).toString(), content);
String idcomment = commentOp.GetIdByOtherAttributes(idtask, username, content);
String message = avatar + ":" + timestamp + ":" + content + ":" + idcomment;
out.println(message);
} else if (action.equalsIgnoreCase("delComment")) {
String idcomment = request.getParameter("ic");
commentOp.DeleteCommentByCommentId(idcomment);
out.println(idcomment);
} else {
System.out.println("No command existed");
}
out.close();
}
public TaskScreen(Task task) {
super(Manager.NO_VERTICAL_SCROLL | Manager.NO_VERTICAL_SCROLLBAR);
internalManager =
new VerticalFieldManager(Manager.NO_VERTICAL_SCROLL | Manager.NO_VERTICAL_SCROLLBAR);
super.add(internalManager);
internalManager.add(new TitleField(TaskUtils.getPath(task)));
manager = new VerticalFieldManager(Manager.VERTICAL_SCROLL | Manager.VERTICAL_SCROLLBAR);
internalManager.add(manager);
this.task = task;
Font bold = getFont().derive(Font.BOLD);
HeaderLabel name = new HeaderLabel(task.getName());
name.setFont(bold);
RichTextField description =
new RichTextField(task.getDescription()) {
public void paint(Graphics graphics) {
graphics.setColor(0x00777777);
super.paint(graphics);
}
};
add(name);
if (task.getPriority() != Task.NORMAL_PRIORITY) {
BitmapInput priority =
new BitmapInput(
"Priority",
task.getPriority() == Task.LOW_PRIORITY ? "low_priority.png" : "high_priority");
priority.setEditable(false);
priority.setSelected(task.getPriority());
add(priority);
}
String statusRes = "";
switch (task.getStatus()) {
case Task.NOT_STARTED:
statusRes = ("not_started.png");
break;
case Task.IN_PROGRESS:
statusRes = ("progress.png");
break;
case Task.WAITING:
statusRes = ("waiting.png");
break;
case Task.DEFERRED:
statusRes = ("deferred.png");
break;
case Task.COMPLETED:
statusRes = ("completed.png");
break;
}
status = new BitmapInput("Status", statusRes);
status.setEditable(false);
status.setSelected(task.getStatus());
add(status);
percent_complete =
new BitmapInput(
"Percent Complete", task.getPercentComplete() + "% Complete", "percent_complete.png");
percent_complete.setEditable(false);
add(percent_complete);
BitmapInput tags = new BitmapInput("Tags", "tags.png");
tags.setTextQuiet(TaskUtils.getTags(task));
tags.setEditable(false);
add(tags);
if (task.getDescription().length() > 0) add(description);
Font header = getFont().derive(Font.BOLD, getFont().getHeight() - 4);
HeaderLabel l_dr = new HeaderLabel("Due Date");
l_dr.setFont(header);
BitmapInput dueDate = new BitmapInput("Due Date", "soon.png");
if (task.getDateDue() > 0) {
dueDate.setTextQuiet(
"Due date: "
+ new SimpleDateFormat(DateFormat.DATETIME_DEFAULT).formatLocal(task.getDateDue()));
System.out.println("REMINDER: " + task.getDateDue());
} else dueDate.setTextQuiet("No due date set.");
dueDate.setEditable(false);
BitmapInput reminder = new BitmapInput("Reminder", "reminder.png");
if (task.getReminder() > 0) {
reminder.setTextQuiet(
"Reminder: "
+ new SimpleDateFormat(DateFormat.DATETIME_DEFAULT)
.formatLocal(task.getDateDue() - (task.getReminder() * 1000)));
System.out.println("REMINDER: " + task.getReminder());
} else reminder.setTextQuiet("No reminder set.");
reminder.setEditable(false);
add(l_dr);
add(dueDate);
add(reminder);
if (task.getDateDue() > 0) {
BitmapInput viewInCalendar = new BitmapInput("View in Calendar", "today.png");
viewInCalendar.setTask(task);
add(viewInCalendar);
}
HeaderLabel l_notes = new HeaderLabel("Notes");
l_notes.setFont(header);
notes = new NoteManager(task);
add(l_notes);
add(notes);
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("addTask")) {
taskList.add(new Task("new Task"));
/// @todo A new created task should be editable right away.
table.editCellAt(taskList.getRowCount() - 1, 0);
}
if (e.getActionCommand().equals("deleteTask") && (table.getSelectedRow() != -1)) {
taskList.remove(table.getSelectedRow());
}
if (e.getActionCommand().equals("cross") && (table.getSelectedRow() != -1)) {
taskList.get(table.getSelectedRow()).setState(State.crossed);
}
if (e.getActionCommand().equals("dismiss") && (table.getSelectedRow() != -1)) {
taskList.get(table.getSelectedRow()).setState(State.dismissed);
}
if (e.getActionCommand().equals("workedOn") && (table.getSelectedRow() != -1)) {
Task task = taskList.get(table.getSelectedRow());
task.setState(State.crossed);
taskList.add(new Task(task.getName()));
}
// File handling
File file = null;
Writer writer = null;
JAXBContext context;
if (e.getActionCommand().equals("save")) {
Marshaller m = null;
int returnVal = fileChooser.showSaveDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile();
if (!file.getName().endsWith(".xml")) {
/// @TODO Append automaticly .xml
}
try {
context = JAXBContext.newInstance(TaskList.class);
m = context.createMarshaller();
m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
writer = new FileWriter(file);
m.marshal(taskList, writer);
} catch (JAXBException exeption) {
exeption.printStackTrace();
} catch (IOException exeption) {
exeption.printStackTrace();
} finally {
try {
writer.close();
} catch (Exception exeption) {
}
}
}
}
if (e.getActionCommand().equals("open")) {
Unmarshaller um = null;
int returnVal = fileChooser.showOpenDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile();
// if(!file.getName().endsWith(".xml")){
/// @TODO Append automaticly .xml
// }
try {
context = JAXBContext.newInstance(TaskList.class);
um = context.createUnmarshaller();
taskList = (TaskList) um.unmarshal(file);
table.setModel(taskList);
table.getColumnModel().getColumn(0).setCellRenderer(new TaskRenderer());
} catch (JAXBException exeption) {
exeption.printStackTrace();
} finally {
try {
writer.close();
} catch (Exception exeption) {
}
}
}
}
taskList.fireTableDataChanged();
}
