archive
/
tasks
mirror of https://github.com/tasks/tasks
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

First pass at writing the rearrangling logic

Browse Source
pull/14/head
Tim Su 15 years ago
parent 1b30dab9ee
commit d7d87f84ee
4 changed files with 179 additions and 236 deletions
Show Stats Download Patch File Download Diff File

3
astrid/plugin-src/com/todoroo/astrid/gtasks/GtasksListActivity.java
Unescape Escape View File

@ -54,7 +54,8 @@ public class GtasksListActivity extends DraggableTaskListActivity {
@Override @Override
public void drop(int from, int to) { public void drop(int from, int to) {
long targetTaskId = taskAdapter.getItemId(from); long targetTaskId = taskAdapter.getItemId(from);
gtasksTaskListUpdater.move(listId, targetTaskId, to - from); long destinationTaskId = taskAdapter.getItemId(to);
gtasksTaskListUpdater.moveTo(listId, targetTaskId, destinationTaskId);
loadTaskListContent(true); loadTaskListContent(true);
} }
}; };

61
astrid/plugin-src/com/todoroo/astrid/gtasks/GtasksOrderAction.java
Unescape Escape View File

@ -1,61 +0,0 @@
package com.todoroo.astrid.gtasks;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.todoroo.andlib.service.Autowired;
import com.todoroo.andlib.service.ContextManager;
import com.todoroo.andlib.service.DependencyInjectionService;
import com.todoroo.astrid.api.AstridApiConstants;
import com.todoroo.astrid.data.Metadata;
import com.todoroo.astrid.utility.Flags;
/**
* Context Menu actions for changing the order of a task
* @author Tim Su <tim@todoroo.com>
*
*/
abstract public class GtasksOrderAction extends BroadcastReceiver {
@Autowired private GtasksMetadataService gtasksMetadataService;
@Autowired private GtasksTaskListUpdater gtasksTaskListUpdater;
abstract int getDelta();
@Override
public void onReceive(Context context, Intent intent) {
ContextManager.setContext(context);
DependencyInjectionService.getInstance().inject(this);
long taskId = intent.getLongExtra(AstridApiConstants.EXTRAS_TASK_ID, -1);
if(taskId == -1)
return;
Metadata metadata = gtasksMetadataService.getTaskMetadata(taskId);
if(metadata == null)
return;
metadata = gtasksMetadataService.getTaskMetadata(taskId);
String listId = metadata.getValue(GtasksMetadata.LIST_ID);
gtasksTaskListUpdater.move(listId, taskId, getDelta());
gtasksTaskListUpdater.correctMetadataForList(listId);
Flags.set(Flags.REFRESH);
}
public static class GtasksMoveUpAction extends GtasksOrderAction {
@Override
public int getDelta() {
return -1;
}
}
public static class GtasksMoveDownAction extends GtasksOrderAction {
@Override
public int getDelta() {
return 1;
}
}
}

213
astrid/plugin-src/com/todoroo/astrid/gtasks/GtasksTaskListUpdater.java
Unescape Escape View File

@ -1,9 +1,10 @@
package com.todoroo.astrid.gtasks; package com.todoroo.astrid.gtasks;
import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import android.text.TextUtils; import android.text.TextUtils;
@ -36,22 +37,7 @@ public class GtasksTaskListUpdater {
DependencyInjectionService.getInstance().inject(this); DependencyInjectionService.getInstance().inject(this);
} }
// --- used during normal ui operations // --- task indenting
public void debugPrint(String listId) {
StoreObject list = gtasksListService.getList(listId);
if(list == GtasksListService.LIST_NOT_FOUND_OBJECT)
return;
iterateThroughList(list, new ListIterator() {
public void processTask(long taskId, Metadata metadata) {
System.err.format("%d: %d, indent:%d, parent:%d\n", taskId, //$NON-NLS-1$
metadata.getValue(GtasksMetadata.ORDER),
metadata.getValue(GtasksMetadata.INDENT),
metadata.getValue(GtasksMetadata.PARENT_TASK));
}
});
}
/** /**
* Indent a task and all its children * Indent a task and all its children
@ -106,142 +92,117 @@ public class GtasksTaskListUpdater {
}); });
} }
// --- task moving
private static class Node {
public long taskId;
public Node parent;
public ArrayList<Node> children = new ArrayList<Node>();
public Node(long taskId, Node parent) {
this.taskId = taskId;
this.parent = parent;
}
}
/** /**
* Move a task and all its children. * Move a task and all its children to the position right above
* <p> * taskIdToMoveto. Will change the indent level to match taskIdToMoveTo.
* if moving up and first task in list or moving down and last,
* indents to same as task that we swapped with.
*
* @param delta # of positions to move
* *
* @param newTaskId task we will move above. if -1, moves to end of list
*/ */
public void move(String listId, final long targetTaskId, final int delta) { public void moveTo(String listId, final long targetTaskId, final long moveBeforeTaskId) {
StoreObject list = gtasksListService.getList(listId); StoreObject list = gtasksListService.getList(listId);
if(list == GtasksListService.LIST_NOT_FOUND_OBJECT) if(list == GtasksListService.LIST_NOT_FOUND_OBJECT)
return; return;
long taskToSwap = -1; Node root = buildTreeModel(list);
if(delta == -1) { Node target = findNode(root, targetTaskId);
// use sibling / parent map to figure out prior task
updateParentSiblingMapsFor(list); target.parent.children.remove(target);
if(siblings.containsKey(targetTaskId) && siblings.get(targetTaskId) != -1L)
taskToSwap = siblings.get(targetTaskId); if(moveBeforeTaskId == -1) {
else if(parents.containsKey(targetTaskId) && parents.get(targetTaskId) != -1L) root.children.add(target);
taskToSwap = parents.get(targetTaskId);
} else { } else {
// walk through to find the next task Node sibling = findNode(root, moveBeforeTaskId);
Filter filter = GtasksFilterExposer.filterFromList(list); int index = sibling.parent.children.indexOf(sibling);
TodorooCursor<Task> cursor = PluginServices.getTaskService().fetchFiltered(filter.sqlQuery, null, Task.ID); sibling.parent.children.add(index, sibling);
try {
int targetIndent = -1;
for(cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
long taskId = cursor.getLong(0);
if(targetIndent != -1) {
Metadata metadata = gtasksMetadataService.getTaskMetadata(taskId);
if(metadata.getValue(GtasksMetadata.INDENT) <= targetIndent) {
taskToSwap = taskId;
break;
}
} else if(taskId == targetTaskId) {
Metadata metadata = gtasksMetadataService.getTaskMetadata(taskId);
targetIndent = metadata.getValue(GtasksMetadata.INDENT);
}
}
} finally {
cursor.close();
}
} }
if(taskToSwap == -1L) traverseTreeAndWriteValues(root, new AtomicInteger(0), 0, new Task());
return; }
if(delta == -1) { private void traverseTreeAndWriteValues(Node node, AtomicInteger order, int indent, Task taskContainer) {
moveUp(list, targetTaskId, taskToSwap); if(node.taskId != -1) {
} else { Metadata metadata = gtasksMetadataService.getTaskMetadata(node.taskId);
// adjust indent of target task to task to swap metadata.setValue(GtasksMetadata.ORDER, order.getAndIncrement());
Metadata targetTask = gtasksMetadataService.getTaskMetadata(targetTaskId); metadata.setValue(GtasksMetadata.INDENT, indent);
Metadata nextTask = gtasksMetadataService.getTaskMetadata(taskToSwap); if(PluginServices.getMetadataService().save(metadata))
int targetIndent = targetTask.getValue(GtasksMetadata.INDENT); updateModifiedDate(taskContainer, node.taskId);
int nextIndent = nextTask.getValue(GtasksMetadata.INDENT); }
if(targetIndent != nextIndent)
indent(listId, targetTaskId, nextIndent - targetIndent); for(Node child : node.children) {
moveUp(list, taskToSwap, targetTaskId); traverseTreeAndWriteValues(child, order, indent + 1, taskContainer);
} }
} }
private void moveUp(StoreObject list, final long targetTaskId, final long priorTaskId) { private Node findNode(Node node, long taskId) {
final AtomicInteger priorTaskOrder = new AtomicInteger(-1); if(node.taskId == taskId)
final AtomicInteger priorTaskIndent = new AtomicInteger(-1); return node;
final AtomicInteger targetTaskOrder = new AtomicInteger(0); for(Node child : node.children) {
final AtomicInteger targetTaskIndent = new AtomicInteger(-1); Node found = findNode(child, taskId);
final AtomicInteger tasksToMove = new AtomicInteger(1); if(found != null)
final AtomicBoolean finished = new AtomicBoolean(false); return found;
}
return null;
}
private Node buildTreeModel(StoreObject list) {
final Node root = new Node(-1, null);
final AtomicInteger previoustIndent = new AtomicInteger(0);
final AtomicReference<Node> currentNode = new AtomicReference<Node>(root);
// step 1. calculate tasks to move
iterateThroughList(list, new ListIterator() { iterateThroughList(list, new ListIterator() {
@Override @Override
public void processTask(long taskId, Metadata metadata) { public void processTask(long taskId, Metadata metadata) {
if(finished.get() && priorTaskOrder.get() != -1) int indent = metadata.getValue(GtasksMetadata.INDENT);
return;
int previousIndentValue = previoustIndent.get();
if(taskId == priorTaskId) { if(indent == previousIndentValue) { // sibling
priorTaskIndent.set(metadata.getValue(GtasksMetadata.INDENT)); Node parent = currentNode.get().parent;
priorTaskOrder.set(metadata.getValue(GtasksMetadata.ORDER)); currentNode.set(new Node(taskId, parent));
} else if(targetTaskId == taskId) { parent.children.add(currentNode.get());
targetTaskIndent.set(metadata.getValue(GtasksMetadata.INDENT)); } else if(indent > previousIndentValue) { // child
targetTaskOrder.set(metadata.getValue(GtasksMetadata.ORDER)); Node parent = currentNode.get();
} else if(targetTaskIndent.get() > -1) { currentNode.set(new Node(taskId, parent));
// found first task that is not beneath target parent.children.add(currentNode.get());
if(metadata.getValue(GtasksMetadata.INDENT) <= targetTaskIndent.get()) } else { // in a different tree
finished.set(true); Node node = currentNode.get().parent;
else for(int i = indent; i < previousIndentValue; i++)
tasksToMove.incrementAndGet(); node = node.parent;
currentNode.set(new Node(taskId, node));
node.children.add(currentNode.get());
} }
} }
}); });
return root;
}
final AtomicBoolean priorFound = new AtomicBoolean(false); // --- utility
final AtomicBoolean targetFound = new AtomicBoolean(false);
final Task taskContainer = new Task(); public void debugPrint(String listId) {
finished.set(false); StoreObject list = gtasksListService.getList(listId);
if(list == GtasksListService.LIST_NOT_FOUND_OBJECT)
return;
// step 2. swap the order of prior and our tasks
iterateThroughList(list, new ListIterator() { iterateThroughList(list, new ListIterator() {
@Override
public void processTask(long taskId, Metadata metadata) { public void processTask(long taskId, Metadata metadata) {
if(finished.get()) System.err.format("%d: %d, indent:%d, parent:%d\n", taskId, //$NON-NLS-1$
return; metadata.getValue(GtasksMetadata.ORDER),
metadata.getValue(GtasksMetadata.INDENT),
if(targetTaskId == taskId) metadata.getValue(GtasksMetadata.PARENT_TASK));
targetFound.set(true);
else if(taskId == priorTaskId)
priorFound.set(true);
if(targetFound.get()) {
if(targetTaskId != taskId && metadata.getValue(GtasksMetadata.INDENT) <= targetTaskIndent.get())
finished.set(true);
else {
int newOrder = metadata.getValue(GtasksMetadata.ORDER) -
targetTaskOrder.get() + priorTaskOrder.get();
int newIndent = metadata.getValue(GtasksMetadata.INDENT) -
targetTaskIndent.get() + priorTaskIndent.get();
metadata.setValue(GtasksMetadata.ORDER, newOrder);
metadata.setValue(GtasksMetadata.INDENT, newIndent);
PluginServices.getMetadataService().save(metadata);
updateModifiedDate(taskContainer, taskId);
}
} else if(priorFound.get()) {
int newOrder = metadata.getValue(GtasksMetadata.ORDER) +
tasksToMove.get();
metadata.setValue(GtasksMetadata.ORDER, newOrder);
PluginServices.getMetadataService().save(metadata);
updateModifiedDate(taskContainer, taskId);
}
} }
}); });
} }
private void updateModifiedDate(Task taskContainer, long taskId) { private void updateModifiedDate(Task taskContainer, long taskId) {

138
tests/src/com/todoroo/astrid/gtasks/GtasksOrderActionTest.java → tests/src/com/todoroo/astrid/gtasks/GtasksTaskMovingTest.java
Unescape Escape View File

@ -1,47 +1,43 @@
package com.todoroo.astrid.gtasks; package com.todoroo.astrid.gtasks;
import android.content.BroadcastReceiver;
import android.content.Intent;
import com.todoroo.andlib.service.Autowired; import com.todoroo.andlib.service.Autowired;
import com.todoroo.astrid.api.AstridApiConstants;
import com.todoroo.astrid.core.PluginServices; import com.todoroo.astrid.core.PluginServices;
import com.todoroo.astrid.data.Metadata; import com.todoroo.astrid.data.Metadata;
import com.todoroo.astrid.data.Task; import com.todoroo.astrid.data.Task;
import com.todoroo.astrid.gtasks.GtasksOrderAction.GtasksMoveDownAction;
import com.todoroo.astrid.gtasks.GtasksOrderAction.GtasksMoveUpAction;
import com.todoroo.astrid.test.DatabaseTestCase; import com.todoroo.astrid.test.DatabaseTestCase;
import com.todoroo.gtasks.GoogleTaskListInfo; import com.todoroo.gtasks.GoogleTaskListInfo;
public class GtasksOrderActionTest extends DatabaseTestCase { public class GtasksTaskMovingTest extends DatabaseTestCase {
@Autowired private GtasksListService gtasksListService; @Autowired private GtasksListService gtasksListService;
@Autowired private GtasksMetadataService gtasksMetadataService; @Autowired private GtasksMetadataService gtasksMetadataService;
@Autowired private GtasksTaskListUpdater gtasksTaskListUpdater;
private Task A, B, C, D, E, F; private Task A, B, C, D, E, F;
public void testMoveUpFromListTop() { /* Starting State:
givenTasksABCDEF(); *
* A
whenTrigger(A, new GtasksMoveUpAction()); * B
* C
thenExpectMetadataIndentAndOrder(A, 0, 0); * D
thenExpectMetadataIndentAndOrder(B, 1, 1); * E
} * F
*/
public void testMoveDownFromListBottom() { public void testMoveDownFromListBottom() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(F, new GtasksMoveDownAction()); whenTriggerMove(F, null);
thenExpectMetadataIndentAndOrder(E, 4, 0); thenExpectMetadataIndentAndOrder(E, 4, 0);
thenExpectMetadataIndentAndOrder(F, 5, 0); thenExpectMetadataIndentAndOrder(F, 5, 0);
} }
public void testMoveDownSimple() { public void testMoveDownToListbottom() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(E, new GtasksMoveDownAction()); whenTriggerMove(E, null);
thenExpectMetadataIndentAndOrder(E, 5, 0); thenExpectMetadataIndentAndOrder(E, 5, 0);
thenExpectMetadataIndentAndOrder(F, 4, 00); thenExpectMetadataIndentAndOrder(F, 4, 00);
@ -50,7 +46,7 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
public void testMoveUpSimple() { public void testMoveUpSimple() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(F, new GtasksMoveUpAction()); whenTriggerMove(F, E);
thenExpectMetadataIndentAndOrder(E, 5, 0); thenExpectMetadataIndentAndOrder(E, 5, 0);
thenExpectMetadataIndentAndOrder(F, 4, 00); thenExpectMetadataIndentAndOrder(F, 4, 00);
@ -59,7 +55,7 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
public void testMoveWithSubtasks() { public void testMoveWithSubtasks() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(C, new GtasksMoveUpAction()); whenTriggerMove(C, B);
/* /*
* A * A
@ -72,44 +68,39 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
thenExpectMetadataIndentAndOrder(B, 3, 1); thenExpectMetadataIndentAndOrder(B, 3, 1);
thenExpectMetadataIndentAndOrder(C, 1, 1); thenExpectMetadataIndentAndOrder(C, 1, 1);
thenExpectMetadataIndentAndOrder(D, 2, 2); thenExpectMetadataIndentAndOrder(D, 2, 2);
whenTrigger(C, new GtasksMoveDownAction());
thenExpectOriginalIndentAndOrder();
} }
public void testMoveThroughSubtasks() { public void testMoveThroughSubtasks() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(B, new GtasksMoveDownAction()); whenTriggerMove(B, E);
/* /*
* A * A
* C * C
* D * D
* B * B
* E
*/ */
thenExpectMetadataIndentAndOrder(A, 0, 0); thenExpectMetadataIndentAndOrder(A, 0, 0);
thenExpectMetadataIndentAndOrder(B, 3, 1); thenExpectMetadataIndentAndOrder(B, 3, 0);
thenExpectMetadataIndentAndOrder(C, 1, 1); thenExpectMetadataIndentAndOrder(C, 1, 1);
thenExpectMetadataIndentAndOrder(D, 2, 2); thenExpectMetadataIndentAndOrder(D, 2, 2);
whenTrigger(B, new GtasksMoveUpAction());
thenExpectOriginalIndentAndOrder();
} }
public void testMoveUpAboveParent() { public void testMoveUpAboveParent() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(B, new GtasksMoveUpAction()); whenTriggerMove(B, A);
/* /*
* B * B
* A * A
* C * C
* D * D
* E
* F
*/ */
thenExpectMetadataIndentAndOrder(A, 1, 0); thenExpectMetadataIndentAndOrder(A, 1, 0);
@ -117,10 +108,10 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
thenExpectMetadataIndentAndOrder(C, 2, 1); thenExpectMetadataIndentAndOrder(C, 2, 1);
} }
public void testMoveDownFromChildren() { public void testMoveDownWithChildren() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(C, new GtasksMoveDownAction()); whenTriggerMove(C, F);
/* /*
* A * A
@ -128,6 +119,7 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
* E * E
* C * C
* D * D
* F
*/ */
thenExpectMetadataIndentAndOrder(A, 0, 0); thenExpectMetadataIndentAndOrder(A, 0, 0);
@ -140,7 +132,7 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
public void testMoveDownIndentingTwice() { public void testMoveDownIndentingTwice() {
givenTasksABCDEF(); givenTasksABCDEF();
whenTrigger(D, new GtasksMoveDownAction()); whenTriggerMove(D, F);
/* /*
* A * A
@ -157,13 +149,72 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
thenExpectMetadataIndentAndOrder(E, 3, 0); thenExpectMetadataIndentAndOrder(E, 3, 0);
} }
public void testMoveUpMultiple() {
givenTasksABCDEF();
whenTriggerMove(C, A);
/*
* C
* D
* A
* B
*/
thenExpectMetadataIndentAndOrder(A, 2, 0);
thenExpectMetadataIndentAndOrder(B, 3, 1);
thenExpectMetadataIndentAndOrder(C, 0, 0);
thenExpectMetadataIndentAndOrder(D, 1, 1);
}
public void testMoveUpIntoSublist() {
givenTasksABCDEF();
whenTriggerMove(F, D);
/*
* A
* B
* C
* F
* D
*/
thenExpectMetadataIndentAndOrder(A, 0, 0);
thenExpectMetadataIndentAndOrder(B, 1, 1);
thenExpectMetadataIndentAndOrder(C, 2, 1);
thenExpectMetadataIndentAndOrder(D, 4, 2);
thenExpectMetadataIndentAndOrder(E, 5, 0);
thenExpectMetadataIndentAndOrder(F, 3, 2);
}
public void testMoveDownMultiple() {
givenTasksABCDEF();
whenTriggerMove(B, F);
/*
* A
* C
* D
* E
* B
*/
thenExpectMetadataIndentAndOrder(A, 0, 0);
thenExpectMetadataIndentAndOrder(B, 4, 0);
thenExpectMetadataIndentAndOrder(C, 1, 1);
thenExpectMetadataIndentAndOrder(D, 2, 2);
thenExpectMetadataIndentAndOrder(E, 3, 0);
thenExpectMetadataIndentAndOrder(F, 5, 0);
}
// --- helpers // --- helpers
private void whenTrigger(Task task, BroadcastReceiver action) { /** moveTo = null => move to end */
Intent intent = new Intent(AstridApiConstants.ACTION_TASK_CONTEXT_MENU); private void whenTriggerMove(Task target, Task moveTo) {
intent.putExtra(AstridApiConstants.EXTRAS_TASK_ID, task.getId()); gtasksTaskListUpdater.moveTo("1", target.getId(), moveTo == null ? -1 : moveTo.getId());
action.onReceive(getContext(), intent);
} }
private void thenExpectMetadataIndentAndOrder(Task task, int order, int indent) { private void thenExpectMetadataIndentAndOrder(Task task, int order, int indent) {
@ -173,15 +224,6 @@ public class GtasksOrderActionTest extends DatabaseTestCase {
assertEquals("indentation", indent, (int)metadata.getValue(GtasksMetadata.INDENT)); assertEquals("indentation", indent, (int)metadata.getValue(GtasksMetadata.INDENT));
} }
private void thenExpectOriginalIndentAndOrder() {
thenExpectMetadataIndentAndOrder(A, 0, 0);
thenExpectMetadataIndentAndOrder(B, 1, 1);
thenExpectMetadataIndentAndOrder(C, 2, 1);
thenExpectMetadataIndentAndOrder(D, 3, 2);
thenExpectMetadataIndentAndOrder(E, 4, 0);
thenExpectMetadataIndentAndOrder(F, 5, 0);
}
@Override @Override
protected void setUp() throws Exception { protected void setUp() throws Exception {
super.setUp(); super.setUp();
Write Preview
Loading…
Cancel
Save