Remove dao query callbacks

pull/618/head
Alex Baker 7 years ago
parent 470d90095a
commit e70686068d

@ -88,7 +88,7 @@ public class GtasksTaskListUpdater {
GtasksMetadata.LIST_ID.eq(listId),
GtasksMetadata.PARENT_TASK.eq(parent)))
.orderBy(Order.asc(Functions.cast(GtasksMetadata.GTASKS_ORDER, "INTEGER")));
metadataDao.query(query, curr -> {
for (Metadata curr : metadataDao.toList(query)) {
if (!alreadyChecked.contains(curr.getTask())) {
curr.setValue(GtasksMetadata.INDENT, indentLevel);
curr.setValue(GtasksMetadata.ORDER, order.getAndIncrement());
@ -98,7 +98,6 @@ public class GtasksTaskListUpdater {
orderAndIndentHelper(listId, order, curr.getTask(), indentLevel + 1, alreadyChecked);
}
}
);
}
void updateParentSiblingMapsFor(GtasksList list) {

@ -179,13 +179,13 @@ public class GtasksSyncService {
startAtCriterion)).
orderBy(order);
metadataDao.query(query, entry -> {
for (Metadata entry : metadataDao.toList(query)) {
long taskId = entry.getValue(Metadata.TASK);
Metadata metadata = metadataDao.getFirstActiveByTaskAndKey(taskId, GtasksMetadata.METADATA_KEY);
if(metadata != null) {
iterator.processTask(taskId, metadata);
}
});
}
}
/**

@ -428,7 +428,7 @@ public class GoogleTaskSyncAdapter extends InjectingAbstractThreadedSyncAdapter
newMetadataValues.add(metadatum.getMergedValues());
}
metadataDao.byTaskAndKey(taskId, metadataKey, item -> {
for (Metadata item : metadataDao.byTaskAndKey(taskId, metadataKey)) {
long id = item.getId();
// clear item id when matching with incoming values
@ -440,7 +440,7 @@ public class GoogleTaskSyncAdapter extends InjectingAbstractThreadedSyncAdapter
// not matched. cut it
metadataDao.delete(id);
}
});
}
// everything that remains shall be written
for(ContentValues values : newMetadataValues) {

@ -55,10 +55,6 @@ public class DatabaseDao<TYPE extends AbstractModel> {
return query(query).toList();
}
public void query(Query query, Callback<TYPE> callback) {
query(query).forEach(callback);
}
public TYPE getFirst(Query query) {
return query(query).first();
}

@ -7,7 +7,6 @@ package com.todoroo.astrid.alarms;
import android.content.ContentValues;
import com.todoroo.andlib.data.Callback;
import com.todoroo.andlib.sql.Criterion;
import com.todoroo.andlib.sql.Join;
import com.todoroo.andlib.sql.Order;
@ -60,14 +59,16 @@ public class AlarmService {
}
final Set<Long> alarms = new LinkedHashSet<>();
getAlarms(taskId, metadata -> alarms.add(metadata.getValue(AlarmFields.TIME) + (newDueDate - oldDueDate)));
for (Metadata metadata : getAlarms(taskId)) {
alarms.add(metadata.getValue(AlarmFields.TIME) + (newDueDate - oldDueDate));
}
if (!alarms.isEmpty()) {
synchronizeAlarms(taskId, alarms);
}
}
public void getAlarms(long taskId, Callback<Metadata> callback) {
metadataDao.query(callback, Query.select(
public List<Metadata> getAlarms(long taskId) {
return metadataDao.toList(Query.select(
Metadata.PROPERTIES).where(MetadataCriteria.byTaskAndwithKey(
taskId, AlarmFields.METADATA_KEY)).orderBy(Order.asc(AlarmFields.TIME)));
}
@ -96,16 +97,16 @@ public class AlarmService {
// --- alarm scheduling
private void getActiveAlarms(Callback<Metadata> callback) {
metadataDao.query(callback, Query.select(Metadata.PROPERTIES).
private List<Metadata> getActiveAlarms() {
return metadataDao.toList(Query.select(Metadata.PROPERTIES).
join(Join.inner(Task.TABLE, Metadata.TASK.eq(Task.ID))).
where(Criterion.and(TaskCriteria.isActive(),
Task.REMINDER_LAST.lt(AlarmFields.TIME),
MetadataCriteria.withKey(AlarmFields.METADATA_KEY))));
}
private void getActiveAlarmsForTask(long taskId, Callback<Metadata> callback) {
metadataDao.query(callback, Query.select(Metadata.PROPERTIES).
private List<Metadata> getActiveAlarmsForTask(long taskId) {
return metadataDao.toList(Query.select(Metadata.PROPERTIES).
join(Join.inner(Task.TABLE, Metadata.TASK.eq(Task.ID))).
where(Criterion.and(TaskCriteria.isActive(),
Task.REMINDER_LAST.lt(AlarmFields.TIME),
@ -116,14 +117,18 @@ public class AlarmService {
* Schedules all alarms
*/
public void scheduleAllAlarms() {
getActiveAlarms(this::scheduleAlarm);
for (Metadata metadata : getActiveAlarms()) {
scheduleAlarm(metadata);
}
}
/**
* Schedules alarms for a single task
*/
private void scheduleAlarms(long taskId) {
getActiveAlarmsForTask(taskId, this::scheduleAlarm);
for (Metadata metadata : getActiveAlarmsForTask(taskId)) {
scheduleAlarm(metadata);
}
}
/**
@ -161,7 +166,7 @@ public class AlarmService {
newMetadataValues.add(values);
}
metadataDao.byTaskAndKey(taskId, AlarmFields.METADATA_KEY, item -> {
for (Metadata item : metadataDao.byTaskAndKey(taskId, AlarmFields.METADATA_KEY)) {
long id = item.getId();
// clear item id when matching with incoming values
@ -180,7 +185,7 @@ public class AlarmService {
metadataDao.delete(id);
dirty[0] = true;
}
});
}
// everything that remains shall be written
for(ContentValues values : newMetadataValues) {

@ -162,7 +162,7 @@ public class TasksXmlExporter {
}
private void serializeTagDatas() {
tagDataDao.allTags(tag -> {
for (TagData tag : tagDataDao.allTags()) {
try {
xml.startTag(null, BackupConstants.TAGDATA_TAG);
serializeModel(tag, TagData.PROPERTIES, TagData.ID);
@ -170,7 +170,7 @@ public class TasksXmlExporter {
} catch(IOException e) {
throw new RuntimeException(e);
}
});
}
}
private void serializeTasks() throws IOException {
@ -214,7 +214,7 @@ public class TasksXmlExporter {
}
private synchronized void serializeMetadata(Task task) {
metadataDao.byTask(task.getId(), metadata -> {
for (Metadata metadata : metadataDao.byTask(task.getId())) {
try {
xml.startTag(null, BackupConstants.METADATA_TAG);
serializeModel(metadata, Metadata.PROPERTIES, Metadata.ID, Metadata.TASK);
@ -222,7 +222,7 @@ public class TasksXmlExporter {
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
/**

@ -5,7 +5,6 @@
*/
package com.todoroo.astrid.dao;
import com.todoroo.andlib.data.Callback;
import com.todoroo.andlib.data.DatabaseDao;
import com.todoroo.andlib.data.Property;
import com.todoroo.andlib.sql.Criterion;
@ -37,12 +36,8 @@ public class MetadataDao {
dao = new DatabaseDao<>(database, Metadata.class);
}
public void query(Callback<Metadata> callback, Query query) {
query(query, callback);
}
public void query(Query query, Callback<Metadata> callback) {
dao.query(query, callback);
public List<Metadata> query(Query query) {
return dao.toList(query);
}
public Metadata getFirst(Query query) {
@ -141,20 +136,9 @@ public class MetadataDao {
return toList(MetadataCriteria.byTask(taskId));
}
public void byTask(long taskId, Callback<Metadata> callback) {
Query query = Query.select(Metadata.PROPERTIES).where(Metadata.TASK.eq(taskId));
dao.query(query, callback);
}
public List<Metadata> byTaskAndKey(long taskId, String key) {
return dao.toList(Query.select(Metadata.PROPERTIES).where(
Criterion.and(Metadata.TASK.eq(taskId), Metadata.KEY.eq(key))));
}
public void byTaskAndKey(long taskId, String key, Callback<Metadata> callback) {
Query query = Query.select(Metadata.PROPERTIES)
.where(Criterion.and(Metadata.TASK.eq(taskId), Metadata.KEY.eq(key)));
dao.query(query, callback);
}
}

@ -16,6 +16,8 @@ import com.todoroo.astrid.data.TagData;
import org.tasks.injection.ApplicationScope;
import java.util.List;
import javax.inject.Inject;
/**
@ -37,12 +39,11 @@ public class TagDataDao {
return dao.getFirst(Query.select(properties).where(TagData.NAME.eqCaseInsensitive(name)));
}
public void allTags(Callback<TagData> callback) {
public List<TagData> allTags() {
// TODO: does this need to be ordered?
Query query = Query.select(TagData.PROPERTIES)
return dao.toList(Query.select(TagData.PROPERTIES)
.where(TagData.DELETION_DATE.eq(0))
.orderBy(Order.asc(TagData.ID));
dao.query(query, callback);
.orderBy(Order.asc(TagData.ID)));
}
public TagData getByUuid(String uuid) {
@ -53,12 +54,11 @@ public class TagDataDao {
return dao.getFirst(Query.select(properties).where(TagData.UUID.eq(uuid)));
}
public void tagDataOrderedByName(Callback<TagData> callback) {
Query query = Query.select(TagData.PROPERTIES).where(Criterion.and(
public List<TagData> tagDataOrderedByName() {
return dao.toList(Query.select(TagData.PROPERTIES).where(Criterion.and(
TagData.DELETION_DATE.eq(0),
TagData.NAME.isNotNull()))
.orderBy(Order.asc(Functions.upper(TagData.NAME)));
dao.query(query, callback);
.orderBy(Order.asc(Functions.upper(TagData.NAME))));
}
public void persist(TagData tagData) {

@ -5,12 +5,13 @@
*/
package com.todoroo.astrid.dao;
import com.todoroo.andlib.data.Callback;
import com.todoroo.andlib.data.Property;
import com.todoroo.andlib.sql.Criterion;
import com.todoroo.andlib.sql.Query;
import com.todoroo.astrid.data.TaskAttachment;
import java.util.List;
import javax.inject.Inject;
public class TaskAttachmentDao {
@ -26,9 +27,8 @@ public class TaskAttachmentDao {
return dao.count(byUuid(taskUuid, TaskAttachment.TASK_UUID).limit(1)) > 0;
}
public void getAttachments(String taskUuid, Callback<TaskAttachment> callback) {
Query query = byUuid(taskUuid, TaskAttachment.PROPERTIES);
dao.query(query, callback);
public List<TaskAttachment> getAttachments(String taskUuid) {
return dao.toList(byUuid(taskUuid, TaskAttachment.PROPERTIES));
}
private static Query byUuid(String taskUuid, Property<?>... properties) {

@ -75,8 +75,8 @@ public class TaskDao {
query(query).forEach(callback);
}
public void selectActive(Criterion criterion, Callback<Task> callback) {
dao.query(Query.select(Task.PROPERTIES).where(Criterion.and(TaskCriteria.isActive(), criterion)), callback);
public List<Task> selectActive(Criterion criterion) {
return dao.toList(Query.select(Task.PROPERTIES).where(Criterion.and(TaskCriteria.isActive(), criterion)));
}
public Task fetch(long id) {

@ -73,10 +73,10 @@ public class FilesControlSet extends TaskEditControlFragment {
}
final List<TaskAttachment> files = new ArrayList<>();
taskAttachmentDao.getAttachments(taskUuid, attachment -> {
for (TaskAttachment attachment : taskAttachmentDao.getAttachments(taskUuid)) {
files.add(attachment);
addAttachment(attachment);
});
}
validateFiles(files);
return view;
}

@ -70,12 +70,12 @@ public final class TagService {
MetadataCriteria.withKey(TaskToTagMetadata.KEY))).
orderBy(order).groupBy(TaskToTagMetadata.TAG_NAME);
final List<TagData> array = new ArrayList<>();
metadataDao.query(query, metadata -> {
for (Metadata metadata : metadataDao.query(query)) {
TagData tag = tagFromUUID(metadata.getValue(TaskToTagMetadata.TAG_UUID));
if (tag != null) {
array.add(tag);
}
});
}
return array.toArray(new TagData[array.size()]);
}
@ -109,9 +109,9 @@ public final class TagService {
MetadataCriteria.byTask(taskId)))
.orderBy(Order.asc(Functions.upper(TaskToTagMetadata.TAG_NAME)));
final ArrayList<String> tagNames = new ArrayList<>();
metadataDao.query(query, entry -> {
for (Metadata entry : metadataDao.query(query)) {
tagNames.add(entry.getValue(TaskToTagMetadata.TAG_NAME));
});
}
return tagNames;
}
@ -120,11 +120,11 @@ public final class TagService {
*/
public List<TagData> getTagList() {
final List<TagData> tagList = new ArrayList<>();
tagDataDao.tagDataOrderedByName(tagData -> {
for (TagData tagData : tagDataDao.tagDataOrderedByName()) {
if (!TextUtils.isEmpty(tagData.getName())) {
tagList.add(tagData);
}
});
}
return tagList;
}

@ -25,6 +25,7 @@ import com.google.common.primitives.Longs;
import com.todoroo.andlib.utility.DateUtilities;
import com.todoroo.astrid.alarms.AlarmFields;
import com.todoroo.astrid.alarms.AlarmService;
import com.todoroo.astrid.data.Metadata;
import com.todoroo.astrid.data.Task;
import org.tasks.R;
@ -140,7 +141,9 @@ public class ReminderControlSet extends TaskEditControlFragment {
private List<Long> currentAlarms() {
final List<Long> alarms = new ArrayList<>();
alarmService.getAlarms(taskId, entry -> alarms.add(entry.getValue(AlarmFields.TIME)));
for (Metadata entry : alarmService.getAlarms(taskId)) {
alarms.add(entry.getValue(AlarmFields.TIME));
}
return alarms;
}

@ -105,7 +105,7 @@ public class GeofenceService {
newMetadataValues.add(values);
}
metadataDao.byTaskAndKey(taskId, GeofenceFields.METADATA_KEY, item -> {
for (Metadata item : metadataDao.byTaskAndKey(taskId, GeofenceFields.METADATA_KEY)) {
long id = item.getId();
// clear item id when matching with incoming values
@ -124,7 +124,7 @@ public class GeofenceService {
metadataDao.delete(id);
dirty[0] = true;
}
});
}
// everything that remains shall be written
for(ContentValues values : newMetadataValues) {

@ -45,9 +45,9 @@ public class BackgroundScheduler extends InjectingJobIntentService {
refreshScheduler.clear();
long now = currentTimeMillis();
taskDao.selectActive(
Criterion.or(Task.HIDE_UNTIL.gt(now), Task.DUE_DATE.gt(now)),
refreshScheduler::scheduleRefresh);
for (Task task : taskDao.selectActive(Criterion.or(Task.HIDE_UNTIL.gt(now), Task.DUE_DATE.gt(now)))) {
refreshScheduler.scheduleRefresh(task);
}
}
@Override

Loading…
Cancel
Save