/**
* Build inbox filter
*
* @return
*/
public static Filter buildInboxFilter(Resources r) {
Filter inbox =
new Filter(
r.getString(R.string.BFE_Active),
r.getString(R.string.BFE_Active),
new QueryTemplate()
.where(
Criterion.and(
TaskCriteria.activeVisibleMine(),
Criterion.not(
Task.ID.in(
Query.select(Metadata.TASK)
.from(Metadata.TABLE)
.where(
Criterion.and(
MetadataCriteria.withKey(TaskToTagMetadata.KEY),
TaskToTagMetadata.TAG_NAME.like(
"x_%", "x"))))))), // $NON-NLS-1$ //$NON-NLS-2$
null);
int themeFlags = ThemeService.getFilterThemeFlags();
inbox.listingIcon =
((BitmapDrawable)
r.getDrawable(ThemeService.getDrawable(R.drawable.filter_inbox, themeFlags)))
.getBitmap();
return inbox;
}
private synchronized void pushUpdated(GtasksInvoker invoker, SyncResultCallback callback) {
TodorooCursor<Task> queued =
taskService.query(
Query.select(Task.PROPERTIES)
.join(
Join.left(
Metadata.TABLE,
Criterion.and(
MetadataCriteria.withKey(GtasksMetadata.METADATA_KEY),
Task.ID.eq(Metadata.TASK))))
.where(
Criterion.or(
Task.MODIFICATION_DATE.gt(GtasksMetadata.LAST_SYNC),
Criterion.and(
Task.USER_ID.neq(Task.USER_ID_SELF), GtasksMetadata.ID.isNotNull()),
Metadata.KEY.isNull())));
callback.incrementMax(queued.getCount() * 10);
try {
Task task = new Task();
for (queued.moveToFirst(); !queued.isAfterLast(); queued.moveToNext()) {
task.readFromCursor(queued);
try {
gtasksSyncService.pushTaskOnSave(task, task.getMergedValues(), invoker, false);
} catch (GoogleTasksException e) {
handler.handleException("gtasks-sync-io", e, e.getType()); // $NON-NLS-1$
} catch (IOException e) {
handler.handleException("gtasks-sync-io", e, e.toString()); // $NON-NLS-1$
} finally {
callback.incrementProgress(10);
}
}
} finally {
queued.close();
}
}
public void tagDataOrderedByName(Callback<TagData> callback) {
query(
callback,
Query.select(TagData.PROPERTIES)
.where(Criterion.and(TagData.DELETION_DATE.eq(0), TagData.NAME.isNotNull()))
.orderBy(Order.asc(Functions.upper(TagData.NAME))));
}
/**
* Return alarms for the given task. PLEASE CLOSE THE CURSOR!
*
* @param taskId
*/
public TodorooCursor<Metadata> getAlarms(long taskId) {
return PluginServices.getMetadataService()
.query(
Query.select(Metadata.PROPERTIES)
.where(MetadataCriteria.byTaskAndwithKey(taskId, AlarmFields.METADATA_KEY))
.orderBy(Order.asc(AlarmFields.TIME)));
}
public boolean memberOfTagData(String email, String tagId, String memberId) {
Criterion criterion;
if (!RemoteModel.isUuidEmpty(memberId) && !TextUtils.isEmpty(email)) {
criterion =
Criterion.or(
TagMemberMetadata.USER_UUID.eq(email), TagMemberMetadata.USER_UUID.eq(memberId));
} else if (!RemoteModel.isUuidEmpty(memberId)) {
criterion = TagMemberMetadata.USER_UUID.eq(memberId);
} else if (!TextUtils.isEmpty(email)) {
criterion = TagMemberMetadata.USER_UUID.eq(email);
} else {
return false;
}
TodorooCursor<TagMetadata> count =
query(
Query.select(TagMetadata.ID)
.where(
Criterion.and(
TagMetadataCriteria.withKey(TagMemberMetadata.KEY),
TagMetadata.TAG_UUID.eq(tagId),
criterion)));
try {
return count.getCount() > 0;
} finally {
//
}
}
public TaskListMetadata fetchByTagId(String tagUuid, Property<?>... properties) {
return getFirst(
Query.select(properties)
.where(
Criterion.or(
TaskListMetadata.TAG_UUID.eq(tagUuid), TaskListMetadata.FILTER.eq(tagUuid))));
}
/** Move data from alert table into metadata table. */
private void migrateAlarmsToMetadata() {
Context context = ContextManager.getContext();
if (!checkIfDatabaseExists(context, AlarmDatabase.NAME)) return;
AlarmDatabase alarmsDatabase = new AlarmDatabase();
DatabaseDao<TransitionalAlarm> dao =
new DatabaseDao<TransitionalAlarm>(TransitionalAlarm.class, alarmsDatabase);
TodorooCursor<TransitionalAlarm> cursor = dao.query(Query.select(TransitionalAlarm.PROPERTIES));
try {
if (cursor.getCount() == 0) return;
Metadata metadata = new Metadata();
metadata.setValue(Metadata.KEY, AlarmFields.METADATA_KEY);
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
long task = cursor.get(TransitionalAlarm.TASK);
long time = cursor.get(TransitionalAlarm.TIME);
metadata.setValue(Metadata.TASK, task);
metadata.setValue(AlarmFields.TIME, time);
metadata.setValue(AlarmFields.TYPE, AlarmFields.TYPE_SINGLE);
metadataDao.createNew(metadata);
metadata.clearValue(Metadata.ID);
}
} finally {
cursor.close();
alarmsDatabase.close();
}
}
private synchronized void synchronizeListHelper(
StoreObject list,
GtasksInvoker invoker,
boolean manual,
SyncExceptionHandler errorHandler,
SyncResultCallback callback) {
String listId = list.getValue(GtasksList.REMOTE_ID);
long lastSyncDate;
if (!manual && list.containsNonNullValue(GtasksList.LAST_SYNC)) {
lastSyncDate = list.getValue(GtasksList.LAST_SYNC);
} else {
lastSyncDate = 0;
}
boolean includeDeletedAndHidden = lastSyncDate != 0;
try {
Tasks taskList =
invoker.getAllGtasksFromListId(
listId, includeDeletedAndHidden, includeDeletedAndHidden, lastSyncDate);
List<com.google.api.services.tasks.model.Task> tasks = taskList.getItems();
if (tasks != null) {
callback.incrementMax(tasks.size() * 10);
HashSet<Long> localIds = new HashSet<Long>(tasks.size());
for (com.google.api.services.tasks.model.Task t : tasks) {
GtasksTaskContainer container = parseRemoteTask(t, listId);
gtasksMetadataService.findLocalMatch(container);
container.gtaskMetadata.setValue(
GtasksMetadata.GTASKS_ORDER, Long.parseLong(t.getPosition()));
container.gtaskMetadata.setValue(
GtasksMetadata.PARENT_TASK, gtasksMetadataService.localIdForGtasksId(t.getParent()));
container.gtaskMetadata.setValue(GtasksMetadata.LAST_SYNC, DateUtilities.now() + 1000L);
write(container);
localIds.add(container.task.getId());
callback.incrementProgress(10);
}
list.setValue(GtasksList.LAST_SYNC, DateUtilities.now());
storeObjectDao.persist(list);
if (lastSyncDate == 0) {
Long[] localIdArray = localIds.toArray(new Long[localIds.size()]);
Criterion delete =
Criterion.and(
Metadata.KEY.eq(GtasksMetadata.METADATA_KEY),
GtasksMetadata.LIST_ID.eq(listId),
Criterion.not(Metadata.TASK.in(localIdArray)));
taskService.deleteWhere(
Task.ID.in(Query.select(Metadata.TASK).from(Metadata.TABLE).where(delete)));
metadataService.deleteWhere(delete);
}
gtasksTaskListUpdater.correctOrderAndIndentForList(listId);
}
} catch (GoogleTasksException e) {
if (errorHandler != null)
errorHandler.handleException("gtasks-sync-io", e, e.getType()); // $NON-NLS-1$
} catch (IOException e) {
if (errorHandler != null)
errorHandler.handleException("gtasks-sync-io", e, e.toString()); // $NON-NLS-1$
}
}
public void allTags(Callback<TagData> callback) {
// TODO: does this need to be ordered?
query(
callback,
Query.select(TagData.PROPERTIES)
.where(TagData.DELETION_DATE.eq(0))
.orderBy(Order.asc(TagData.ID)));
}
private Filter[] buildSavedFilters(Context context, Resources r) {
int themeFlags = ThemeService.getFilterThemeFlags();
StoreObjectDao dao = PluginServices.getStoreObjectDao();
TodorooCursor<StoreObject> cursor =
dao.query(
Query.select(StoreObject.PROPERTIES)
.where(StoreObject.TYPE.eq(SavedFilter.TYPE))
.orderBy(Order.asc(SavedFilter.NAME)));
try {
ArrayList<Filter> list = new ArrayList<>();
// stock filters
if (Preferences.getBoolean(R.string.p_show_recently_modified_filter, true)) {
Filter recent =
new Filter(
r.getString(R.string.BFE_Recent),
r.getString(R.string.BFE_Recent),
new QueryTemplate()
.where(TaskCriteria.ownedByMe())
.orderBy(Order.desc(Task.MODIFICATION_DATE))
.limit(15),
null);
recent.listingIcon =
((BitmapDrawable)
r.getDrawable(ThemeService.getDrawable(R.drawable.filter_pencil, themeFlags)))
.getBitmap();
list.add(recent);
}
if (cursor != null) {
StoreObject savedFilter = new StoreObject();
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
savedFilter.readFromCursor(cursor);
Filter f = SavedFilter.load(savedFilter);
Intent deleteIntent = new Intent(context, DeleteActivity.class);
deleteIntent.putExtra(TOKEN_FILTER_ID, savedFilter.getId());
deleteIntent.putExtra(TOKEN_FILTER_NAME, f.title);
f.contextMenuLabels = new String[] {context.getString(R.string.BFE_Saved_delete)};
f.contextMenuIntents = new Intent[] {deleteIntent};
f.listingIcon =
((BitmapDrawable)
r.getDrawable(
ThemeService.getDrawable(R.drawable.filter_sliders, themeFlags)))
.getBitmap();
list.add(f);
}
}
return list.toArray(new Filter[list.size()]);
} finally {
if (cursor != null) {
cursor.close();
}
}
}
/**
* Gets a listing of all tasks that are active &
*
* @param properties
* @return todoroo cursor. PLEASE CLOSE THIS CURSOR!
*/
private TodorooCursor<Task> getTasksWithReminders(Property<?>... properties) {
return taskDao.query(
Query.select(properties)
.where(
Criterion.and(
TaskCriteria.isActive(),
TaskCriteria.ownedByMe(),
Criterion.or(Task.REMINDER_FLAGS.gt(0), Task.REMINDER_PERIOD.gt(0)))));
}
/** Fetch all metadata that are unattached to the task */
public TodorooCursor<Metadata> fetchDangling(Property<?>... properties) {
Query sql =
Query.select(properties)
.from(Metadata.TABLE)
.join(Join.left(Task.TABLE, Metadata.TASK.eq(Task.ID)))
.where(Task.TITLE.isNull());
Cursor cursor = database.rawQuery(sql.toString(), null);
return new TodorooCursor<Metadata>(cursor, properties);
}
private int countTasks(Filter filter) {
String queryTemplate = PermaSql.replacePlaceholders(filter.getSqlQuery());
TodorooCursor<Task> cursor =
taskDao.query(Query.select(Task.ID).withQueryTemplate(queryTemplate));
try {
return cursor.getCount();
} finally {
cursor.close();
}
}
/**
* Gets a listing of all alarms that are active
*
* @param properties
* @return todoroo cursor. PLEASE CLOSE THIS CURSOR!
*/
private TodorooCursor<Metadata> getActiveAlarms() {
return PluginServices.getMetadataService()
.query(
Query.select(AlarmFields.TIME)
.join(Join.inner(Task.TABLE, Metadata.TASK.eq(Task.ID)))
.where(
Criterion.and(
TaskCriteria.isActive(),
MetadataCriteria.withKey(AlarmFields.METADATA_KEY))));
}
/** Recalculate all sizes */
void updateList() {
int max = 0, last = -1;
StringBuilder sql =
new StringBuilder(Query.select(new CountProperty()).from(Task.TABLE).toString())
.append(" WHERE ");
for (int i = 0; i < adapter.getCount(); i++) {
CriterionInstance instance = adapter.getItem(i);
String value = instance.getValueFromCriterion();
if (value == null && instance.criterion.sql != null && instance.criterion.sql.contains("?")) {
value = "";
}
switch (instance.type) {
case CriterionInstance.TYPE_ADD:
sql.append("OR ");
break;
case CriterionInstance.TYPE_SUBTRACT:
sql.append("AND NOT ");
break;
case CriterionInstance.TYPE_INTERSECT:
sql.append("AND ");
break;
case CriterionInstance.TYPE_UNIVERSE:
}
// special code for all tasks universe
if (instance.criterion.sql == null) {
sql.append(TaskCriteria.activeAndVisible()).append(' ');
} else {
String subSql = instance.criterion.sql.replace("?", UnaryCriterion.sanitize(value));
subSql = PermaSql.replacePlaceholders(subSql);
sql.append(Task.ID).append(" IN (").append(subSql).append(") ");
}
Cursor cursor = database.rawQuery(sql.toString());
try {
cursor.moveToNext();
instance.start = last == -1 ? cursor.getInt(0) : last;
instance.end = cursor.getInt(0);
last = instance.end;
max = Math.max(max, last);
} finally {
cursor.close();
}
}
for (int i = 0; i < adapter.getCount(); i++) {
CriterionInstance instance = adapter.getItem(i);
instance.max = max;
}
adapter.notifyDataSetInvalidated();
}
private static void setShowFriendsView() {
// Show friends view if necessary
boolean showFriends = false;
TodorooCursor<User> users = PluginServices.getUserDao().query(Query.select(User.ID).limit(1));
try {
showFriends = users.getCount() > 0;
} finally {
users.close();
}
Preferences.setBoolean(R.string.p_show_friends_view, showFriends);
}
/**
* Get the local id
*
* @param uuid
* @return
*/
public long localIdFromUuid(String uuid) {
TodorooCursor<RTYPE> cursor =
query(Query.select(AbstractModel.ID_PROPERTY).where(RemoteModel.UUID_PROPERTY.eq(uuid)));
try {
if (cursor.getCount() == 0) return AbstractModel.NO_ID;
cursor.moveToFirst();
return cursor.get(AbstractModel.ID_PROPERTY);
} finally {
cursor.close();
}
}
private void addTags(ArrayList<FilterListItem> list) {
HashSet<String> tagNames = new HashSet<String>();
// active tags
Tag[] myTags =
tagService.getGroupedTags(
TagService.GROUPED_TAGS_BY_SIZE,
Criterion.and(TaskCriteria.ownedByMe(), TaskCriteria.activeAndVisible()));
for (Tag tag : myTags) tagNames.add(tag.tag);
if (myTags.length > 0) list.add(filterFromTags(myTags, R.string.tag_FEx_category_mine));
// find all tag data not in active tag list
TodorooCursor<TagData> cursor =
tagDataService.query(
Query.select(TagData.NAME, TagData.TASK_COUNT, TagData.REMOTE_ID)
.where(TagData.DELETION_DATE.eq(0)));
ArrayList<Tag> notListed = new ArrayList<Tag>();
try {
ArrayList<Tag> sharedTags = new ArrayList<Tag>();
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
String tagName = cursor.get(TagData.NAME);
if (tagNames.contains(tagName)) continue;
Tag tag = new Tag(tagName, cursor.get(TagData.TASK_COUNT), cursor.get(TagData.REMOTE_ID));
if (tag.count > 0) sharedTags.add(tag);
else notListed.add(tag);
tagNames.add(tagName);
}
if (sharedTags.size() > 0)
list.add(
filterFromTags(
sharedTags.toArray(new Tag[sharedTags.size()]), R.string.tag_FEx_category_shared));
} finally {
cursor.close();
}
// find inactive tags, intersect tag list
Tag[] inactiveTags =
tagService.getGroupedTags(
TagService.GROUPED_TAGS_BY_ALPHA,
Criterion.and(
TaskCriteria.notDeleted(), Criterion.not(TaskCriteria.activeAndVisible())));
for (Tag tag : inactiveTags) {
if (!tagNames.contains(tag.tag) && !TextUtils.isEmpty(tag.tag)) {
notListed.add(tag);
tag.count = 0;
}
}
if (notListed.size() > 0)
list.add(
filterFromTags(
notListed.toArray(new Tag[notListed.size()]), R.string.tag_FEx_category_inactive));
}
public boolean tagHasMembers(String uuid) {
TodorooCursor<TagMetadata> metadata =
query(
Query.select(TagMetadata.ID)
.where(
Criterion.and(
TagMetadataCriteria.byTagAndWithKey(uuid, TagMemberMetadata.KEY),
TagMetadata.DELETION_DATE.eq(0))));
try {
return metadata.getCount() > 0;
} finally {
metadata.close();
}
}
private void checkForMissingColumns() {
// For some reason these properties are missing for some users.
// Make them exist!
try {
TodorooCursor<Task> tasks = taskService.query(Query.select(Task.UUID, Task.USER_ID).limit(1));
try {
System.err.println(tasks.getCount());
} finally {
tasks.close();
}
} catch (SQLiteException e) {
database.tryAddColumn(Task.TABLE, Task.UUID, "'0'"); // $NON-NLS-1$
database.tryAddColumn(Task.TABLE, Task.USER_ID, "0"); // $NON-NLS-1$
}
}
/** Clean up tasks. Typically called on startup */
public void deleteTasksWithEmptyTitles() {
TodorooCursor<Task> cursor =
taskDao.query(Query.select(Task.ID).where(TaskDao.TaskCriteria.hasNoTitle()));
try {
if (cursor.getCount() == 0) {
return;
}
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
long id = cursor.getLong(0);
taskDao.delete(id);
}
} finally {
cursor.close();
}
}
private <T extends RemoteModel, OE extends OutstandingEntry<T>>
void constructChangesHappenedFromOutstandingTable(
Class<T> modelClass, RemoteModelDao<T> modelDao, OutstandingEntryDao<OE> oustandingDao) {
TodorooCursor<OE> outstanding =
oustandingDao.query(
Query.select(OutstandingEntry.ENTITY_ID_PROPERTY)
.groupBy(OutstandingEntry.ENTITY_ID_PROPERTY));
try {
for (outstanding.moveToFirst(); !outstanding.isAfterLast(); outstanding.moveToNext()) {
Long id = outstanding.get(OutstandingEntry.ENTITY_ID_PROPERTY);
enqueueMessage(new ChangesHappened<T, OE>(id, modelClass, modelDao, oustandingDao), null);
}
} finally {
outstanding.close();
}
}
private synchronized void serializeMetadata(Task task) throws IOException {
TodorooCursor<Metadata> cursor =
metadataService.query(
Query.select(Metadata.PROPERTIES).where(MetadataCriteria.byTask(task.getId())));
try {
Metadata metadata = new Metadata();
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
metadata.readFromCursor(cursor);
xml.startTag(null, BackupConstants.METADATA_TAG);
serializeModel(metadata, Metadata.PROPERTIES, Metadata.ID, Metadata.TASK);
xml.endTag(null, BackupConstants.METADATA_TAG);
}
} finally {
cursor.close();
}
}
private static void setShowFeaturedLists() {
// Show featured lists if necessary
boolean showFeaturedLists = false;
TodorooCursor<TagData> featLists =
PluginServices.getTagDataService()
.query(
Query.select(TagData.ID)
.where(Functions.bitwiseAnd(TagData.FLAGS, TagData.FLAG_FEATURED).gt(0))
.limit(1));
try {
showFeaturedLists = featLists.getCount() > 0;
} finally {
featLists.close();
}
Preferences.setBoolean(
FeaturedListFilterExposer.PREF_SHOULD_SHOW_FEATURED_LISTS, showFeaturedLists);
}
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
synchronized (this) {
if (dataLoaded) return;
dataLoaded = true;
}
String tag = getIntent().getStringExtra(EXTRA_TAG_NAME);
long remoteId = getIntent().getLongExtra(EXTRA_TAG_REMOTE_ID, 0);
if (tag == null && remoteId == 0) return;
TodorooCursor<TagData> cursor =
tagDataService.query(
Query.select(TagData.PROPERTIES)
.where(
Criterion.or(
TagData.NAME.eq(tag),
Criterion.and(TagData.REMOTE_ID.gt(0), TagData.REMOTE_ID.eq(remoteId)))));
try {
tagData = new TagData();
if (cursor.getCount() == 0) {
tagData.setValue(TagData.NAME, tag);
tagData.setValue(TagData.REMOTE_ID, remoteId);
tagDataService.save(tagData);
} else {
cursor.moveToFirst();
tagData.readFromCursor(cursor);
}
} finally {
cursor.close();
}
String fetchKey = LAST_FETCH_KEY + tagData.getId();
long lastFetchDate = Preferences.getLong(fetchKey, 0);
if (DateUtilities.now() > lastFetchDate + 300000L) {
refreshData(false, false);
Preferences.setLong(fetchKey, DateUtilities.now());
}
setUpUpdateList();
setUpMemberPage();
}
private void constructChangesHappenedForTaskListMetadata(
TaskListMetadataDao dao, TaskListMetadataOutstandingDao outstandingDao) {
TodorooCursor<TaskListMetadataOutstanding> outstanding =
outstandingDao.query(
Query.select(OutstandingEntry.ENTITY_ID_PROPERTY)
.groupBy(OutstandingEntry.ENTITY_ID_PROPERTY));
try {
for (outstanding.moveToFirst(); !outstanding.isAfterLast(); outstanding.moveToNext()) {
Long id = outstanding.get(OutstandingEntry.ENTITY_ID_PROPERTY);
ActFmSyncWaitingPool.getInstance()
.enqueueMessage(
new TaskListMetadataChangesHappened(
id, TaskListMetadata.class, dao, outstandingDao));
}
} finally {
outstanding.close();
}
}
/**
* Cursor with the following columns
*
* <ol>
* <li>task title, string
* <li>task importance color, int android RGB color
* <li>task due date (was: preferred due date), long millis since epoch
* <li>task due date (was: absolute due date), long millis since epoch
* <li>task importance, integer from 0 to 3 (0 => most important)
* <li>task id, long
* <li>task tags, string tags separated by |
* </ol>
*
* @return cursor as described above
*/
public Cursor getTasks() {
MatrixCursor ret = new MatrixCursor(TASK_FIELD_LIST);
TodorooCursor<Task> cursor =
taskService.query(
Query.select(Task.ID, Task.TITLE, Task.IMPORTANCE, Task.DUE_DATE)
.where(Criterion.and(TaskCriteria.isActive(), TaskCriteria.isVisible()))
.orderBy(SortHelper.defaultTaskOrder())
.limit(MAX_NUMBER_OF_TASKS));
try {
int[] importanceColors = Task.getImportanceColors(ctx.getResources());
Task task = new Task();
for (int i = 0; i < cursor.getCount(); i++) {
cursor.moveToNext();
task.readFromCursor(cursor);
StringBuilder taskTags = new StringBuilder();
TodorooCursor<Metadata> tagCursor = TagService.getInstance().getTags(task.getId());
try {
for (tagCursor.moveToFirst(); !tagCursor.isAfterLast(); tagCursor.moveToNext())
taskTags.append(tagCursor.get(TagService.TAG)).append(TAG_SEPARATOR);
} finally {
tagCursor.close();
}
Object[] values = new Object[7];
values[0] = task.getValue(Task.TITLE);
values[1] = importanceColors[task.getValue(Task.IMPORTANCE)];
values[2] = task.getValue(Task.DUE_DATE);
values[3] = task.getValue(Task.DUE_DATE);
values[4] = task.getValue(Task.IMPORTANCE);
values[5] = task.getId();
values[6] = taskTags.toString();
ret.addRow(values);
}
} finally {
cursor.close();
}
return ret;
}
/**
* Synchronize metadata for given task id. Deletes rows in database that are not identical to
* those in the metadata list, creates rows that have no match.
*
* @param taskId id of task to perform synchronization on
* @param metadata list of new metadata items to save
* @param metadataCriteria criteria to load data for comparison from metadata
*/
public void synchronizeMetadata(
long taskId, ArrayList<Metadata> metadata, Criterion metadataCriteria) {
HashSet<ContentValues> newMetadataValues = new HashSet<ContentValues>();
for (Metadata metadatum : metadata) {
metadatum.setValue(Metadata.TASK, taskId);
metadatum.clearValue(Metadata.ID);
newMetadataValues.add(metadatum.getMergedValues());
}
Metadata item = new Metadata();
TodorooCursor<Metadata> cursor =
query(
Query.select(Metadata.PROPERTIES)
.where(Criterion.and(MetadataCriteria.byTask(taskId), metadataCriteria)));
try {
// try to find matches within our metadata list
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
item.readFromCursor(cursor);
long id = item.getId();
// clear item id when matching with incoming values
item.clearValue(Metadata.ID);
ContentValues itemMergedValues = item.getMergedValues();
if (newMetadataValues.contains(itemMergedValues)) {
newMetadataValues.remove(itemMergedValues);
continue;
}
// not matched. cut it
delete(id);
}
} finally {
cursor.close();
}
// everything that remains shall be written
for (ContentValues values : newMetadataValues) {
item.clear();
item.mergeWith(values);
persist(item);
}
}
private void readLists() {
if (lists != null) {
return;
}
TodorooCursor<StoreObject> cursor =
storeObjectDao.query(
Query.select(StoreObject.PROPERTIES)
.where(StoreObjectCriteria.byType(GtasksList.TYPE)));
try {
lists = new StoreObject[cursor.getCount()];
for (int i = 0; i < lists.length; i++) {
cursor.moveToNext();
StoreObject dashboard = new StoreObject(cursor);
lists[i] = dashboard;
}
} finally {
cursor.close();
}
}
private void serializeTasks() throws IOException {
TodorooCursor<Task> cursor;
cursor = taskService.query(Query.select(Task.PROPERTIES).orderBy(Order.asc(Task.ID)));
try {
int length = cursor.getCount();
for (int i = 0; i < length; i++) {
cursor.moveToNext();
Task task = new Task(cursor);
setProgress(i, length);
xml.startTag(null, BackupConstants.TASK_TAG);
serializeModel(task, Task.PROPERTIES, Task.ID);
serializeMetadata(task);
xml.endTag(null, BackupConstants.TASK_TAG);
this.exportCount++;
}
} finally {
cursor.close();
}
}
