void ActivityBuilderFactory::BuildAccountPrefsWatch(ActivityBuilder& builder, MojObject& accountRev)
{
MojString name;
GetAccountPrefsWatchActivityName(name);
MojString desc;
GetAccountPrefsWatchActivityDesc(desc);
builder.SetName(name.data());
builder.SetDescription(desc.data());
builder.SetPersist(true);
builder.SetExplicit(true);
builder.SetImmediate(true, "low");
MojDbQuery trigger;
MojErr err = trigger.from(PopAccountAdapter::POP_ACCOUNT_KIND);
ErrorToException(err);
err = trigger.where(PopAccountAdapter::ACCOUNT_ID, MojDbQuery::OpEq, m_accountId);
ErrorToException(err);
err = trigger.where("_revPop", MojDbQuery::OpGreaterThan, accountRev);
ErrorToException(err);
builder.SetDatabaseWatchTrigger(trigger);
MojObject params;
err = params.put(PopAccountAdapter::ACCOUNT_ID, m_accountId);
ErrorToException(err);
builder.SetCallback(ACCOUNT_PREFS_WATCH_CALLBACK, params);
MojObject metadata;
err = metadata.put(PopAccountAdapter::ACCOUNT_ID, m_accountId);
ErrorToException(err);
builder.SetMetadata(metadata);
}
void MojoDatabase::GetSentEmails(Signal::SlotRef slot, const MojObject& outboxFolderId, MojInt32 limit)
{
MojErr err;
MojDbQuery query;
err = query.from(EmailSchema::Kind::EMAIL);
ErrorToException(err);
err = query.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, outboxFolderId);
ErrorToException(err);
MojString sendStatus;
err = sendStatus.format("%s.%s",EmailSchema::SEND_STATUS, EmailSchema::SendStatus::SENT);
ErrorToException(err);
err = query.where(sendStatus.data(), MojDbQuery::OpEq, true);
ErrorToException(err);
// Set limit
if(limit > 0) {
query.limit(limit);
}
slot.cancel(); // cancel existing slot in case we're in a callback
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
void MojoDatabase::GetAutoDownloadEmails(Signal::SlotRef slot, const MojObject& folderId, const MojInt64& rev, MojDbQuery::Page& page, MojInt32 limit)
{
MojDbQuery query;
MojErr err = query.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = query.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, folderId);
ErrorToException(err);
if (rev > 0) {
err = query.where(PopFolderAdapter::LAST_SYNC_REV, MojDbQuery::OpGreaterThan, rev);
ErrorToException(err);
}
query.page(page);
// Sort by timestamp descending
err = query.order(EmailSchema::TIMESTAMP);
ErrorToException(err);
query.desc(true);
// Set limit
if(limit > 0) {
query.limit(limit);
}
slot.cancel();
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
void ImapActivityFactory::BuildPreferencesWatch(ActivityBuilder& ab, const MojObject& accountId, MojInt64 rev)
{
MojErr err;
ab.SetName( GetPreferencesWatchName(accountId) );
ab.SetDescription("IMAP account preferences watch");
ab.SetPersist(true);
ab.SetForeground(true);
// Metadata
MojObject metadata;
SetMetadata(metadata, PREFS_WATCH_NAME, accountId);
ab.SetMetadata(metadata);
MojDbQuery trigger;
err = trigger.from(ImapAccountAdapter::SCHEMA);
ErrorToException(err);
err = trigger.where(ImapAccountAdapter::ACCOUNT_ID, MojDbQuery::OpEq, accountId);
ErrorToException(err);
err = trigger.where(ImapAccountAdapter::CONFIG_REV, MojDbQuery::OpGreaterThan, rev);
ErrorToException(err);
ab.SetDatabaseWatchTrigger(trigger);
MojObject params;
err = params.put("accountId", accountId);
ErrorToException(err);
ab.SetCallback(PREFS_WATCH_CALLBACK, params);
}
TEST_F(ReqSuite, original)
{
buildSample();
mark1();
// test visibility with update
{
MojDbReq req;
// start transaction
req.begin(&db, false);
mark2(req);
// visible within transaction
checkMarkWithUpdate(50ul, -2, req);
}
// invisible after aborted transaction
checkMarkWithUpdate(0ul, -2);
// test visibility with delete
mark1();
{
MojDbReq req;
// start transaction
req.begin(&db, false);
deleteMark(50ul, -1, req);
// visible within transaction
{
MojDbQuery query;
MojAssertNoErr( query.from(_T("Test:1")) );
MojAssertNoErr( query.where(_T("bar"), MojDbQuery::OpLessThan, 2) );
MojObject update;
MojUInt32 count = 0xbaddcafe;
MojAssertNoErr( db.merge(query, update, count, MojDb::FlagNone, req) );
EXPECT_EQ( 33ul, count);
}
}
// invisible after aborted transaction
{
MojDbQuery query;
MojAssertNoErr( query.from(_T("Test:1")) );
MojAssertNoErr( query.where(_T("bar"), MojDbQuery::OpLessThan, 2) );
MojObject update;
// Note: should not set value to something that will introduce double-update
MojUInt32 count = 0xbaddcafe;
MojAssertNoErr( db.merge(query, update, count) );
EXPECT_EQ( 83ul, count);
}
}
MojErr MojDbWatchTest::cancelTest(MojDb& db)
{
// cancel find
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpLessThanEq, 45);
MojTestErrCheck(err);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
watcher->m_slot.cancel();
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
watcher->m_slot.cancel();
MojTestAssert(watcher->m_count == 0);
MojObject id;
err = put(db, 1, 1, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
// cancel watch
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
MojDbQuery queryWithRev;
err = queryWithRev.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = queryWithRev.where(_T("foo"), MojDbQuery::OpEq, 45);
MojTestErrCheck(err);
err = queryWithRev.where(_T("_rev"), MojDbQuery::OpGreaterThan, m_rev);
MojTestErrCheck(err);
bool fired = false;
err = db.watch(queryWithRev, cursor, watcher->m_slot, fired);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(!fired);
MojTestAssert(watcher->m_count == 0);
watcher->m_slot.cancel();
MojTestAssert(watcher->m_count == 0);
err = put(db, 45, 45, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
return MojErrNone;
}
void MojoDatabase::GetEmailsToMove(Signal::SlotRef slot, const MojObject& accountId)
{
MojErr err;
MojDbQuery query;
err = query.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = query.select(PopEmailAdapter::ID);
ErrorToException(err);
err = query.select("folderId");
ErrorToException(err);
err = query.select("destFolderId");
ErrorToException(err);
err = query.select("flags");
ErrorToException(err);
err = query.select(PopEmailAdapter::SERVER_UID);
ErrorToException(err);
err = query.where("destFolderId", MojDbQuery::OpNotEq, MojObject());
ErrorToException(err);
slot.cancel();
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
void ActivityBuilderFactory::BuildDeleteEmailsWatch(ActivityBuilder& builder)
{
MojString name;
GetDeleteEmailsActivityName(name);
MojString desc;
GetDeleteEmailsActivityDesc(desc);
builder.SetName(name.data());
builder.SetDescription(desc.data());
builder.SetPersist(true);
builder.SetExplicit(true);
builder.SetImmediate(true, "low");
// setup trigger
MojDbQuery trigger;
MojErr err = trigger.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = trigger.where("_del", MojDbQuery::OpEq, true);
ErrorToException(err);
builder.SetDatabaseWatchTrigger(trigger);
// setup parameters (to be sent when trigger is called)
MojObject params;
err = params.put(PopFolderAdapter::ACCOUNT_ID, m_accountId);
ErrorToException(err);
builder.SetCallback(DELETE_EMAILS_CALLBACK, params);
// put accountId in metadata
MojObject metadata;
err = metadata.put(PopFolderAdapter::ACCOUNT_ID, m_accountId);
ErrorToException(err);
builder.SetMetadata(metadata);
}
void MojoDatabase::GetEmailsToDelete(Signal::SlotRef slot)
{
MojErr err;
MojDbQuery query;
err = query.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = query.select(PopEmailAdapter::ID);
ErrorToException(err);
err = query.select(PopEmailAdapter::SERVER_UID);
ErrorToException(err);
err = query.select(EmailSchema::FOLDER_ID);
ErrorToException(err);
err = query.where("_del", MojDbQuery::OpEq, true);
ErrorToException(err);
query.includeDeleted(true);
slot.cancel();
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
MojErr OnEnabledHandler::getAccountInfoResult(MojObject& payload, MojErr resultErr)
{
MojLogTrace(IMServiceApp::s_log);
IMServiceHandler::logMojObjectJsonString(_T("OnEnabledHandler::getAccountInfoResult payload: %s"), payload);
if (resultErr != MojErrNone) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler getAccountInfo result error %d"), resultErr);
return resultErr;
}
MojObject result;
MojErr err = payload.getRequired("result", result);
if (err != MojErrNone || result.empty()) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult result empty or error %d"), err);
return err;
}
err = result.getRequired("_id", m_accountId);
if (err != MojErrNone || m_accountId.empty()) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult accountId empty or error %d"), err);
return err;
}
err = result.getRequired("username", m_username);
if (err != MojErrNone || m_username.empty()) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult username empty or error %d"), err);
return err;
}
{
MojObject capabilities;
MojObject messagingObject;
result.get("capabilityProviders", capabilities);
getMessagingCapabilityObject(capabilities, messagingObject);
err = messagingObject.getRequired("serviceName", m_serviceName);
if (m_serviceName.empty()) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult serviceName empty"));
return err;
}
}
if (m_enable)
{
MojDbQuery query;
query.from("com.palm.config.libpurple:1");
query.where("accountId", MojDbQuery::OpEq, m_accountId);
query.limit(1);
err = m_dbClient.find(m_getAccountConfigSlot, query);
}
else
{
err = accountDisabled();
}
return err;
}
void deleteMark(MojUInt32 expect = 50ul, int mark = -1, MojDbReqRef req = MojDbReq())
{
MojDbQuery query;
MojAssertNoErr( query.from(_T("Test:1")) );
MojAssertNoErr( query.where(_T("bar"), MojDbQuery::OpEq, mark) );
MojUInt32 count = 0xbaddcafe;
MojAssertNoErr( db.del(query, count, MojDb::FlagNone, req) );
EXPECT_EQ( expect, count );
}
void MojoDatabase::GetEmailSyncList(Signal::SlotRef slot, const MojObject& folderId, const MojInt64& rev, bool desc, MojDbQuery::Page& page, MojInt32 limit)
{
MojErr err;
MojDbQuery query;
err = query.from(PopEmailAdapter::POP_EMAIL_KIND);//EmailSchema::Kind::EMAIL);
ErrorToException(err);
// Select relevant fields
err = query.select(PopEmailAdapter::ID);
ErrorToException(err);
err = query.select(PopEmailAdapter::SERVER_UID);
ErrorToException(err);
err = query.select(EmailSchema::TIMESTAMP);
ErrorToException(err);
err = query.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, folderId);
ErrorToException(err);
if (rev > 0) {
err = query.where(PopFolderAdapter::LAST_SYNC_REV, MojDbQuery::OpGreaterThan, rev);
ErrorToException(err);
}
query.page(page);
// Sort by timestamp descending
err = query.order(EmailSchema::TIMESTAMP);
ErrorToException(err);
query.desc(desc);
// Set limit
if(limit > 0) {
query.limit(limit);
}
slot.cancel(); // cancel existing slot in case we're in a callback
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
/*
* Result of query for loginState entry with given username and serviceName when removing a buddy
*
* Remove buddy from buddyStatus and contact DB
*/
MojErr SendOneCommandHandler::findAccountIdForRemoveResult(MojObject& result, MojErr findErr)
{
if (findErr) {
MojString error;
MojErrToString(findErr, error);
MojLogError(IMServiceApp::s_log, _T("findAccountIdResult failed: error %d - %s"), findErr, error.data());
} else {
// parse out the accountId
readAccountIdFromResults(result);
if (!m_accountId.empty()){
// construct our where clause - find by username, accountId and servicename
MojDbQuery query;
query.where("username", MojDbQuery::OpEq, m_buddyName);
query.where("accountId", MojDbQuery::OpEq, m_accountId);
query.from(IM_BUDDYSTATUS_KIND);
// call del
// virtual MojErr del(Signal::SlotRef handler, const MojDbQuery& query,
// MojUInt32 flags = MojDb::FlagNone);
MojErr err = m_tempdbClient.del(m_removeBuddySlot, query);
if (err) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("removeBuddy: dbClient.del() failed: error %d - %s"), err, error.data());
// tell the outgoing Command handler we are done
m_outgoingIMHandler->messageFinished();
}
}
else {
MojLogError(IMServiceApp::s_log, _T("findAccountIdResult: no matching loginState record found for %s %s"), m_username.data(), m_serviceName.data());
// tell the outgoing Command handler we are done
m_outgoingIMHandler->messageFinished();
}
}
return MojErrNone;
}
void ActivityBuilderFactory::BuildSentEmailsWatch(ActivityBuilder& builder, const MojObject& outboxFolderId, const MojObject& sentFolderId)
{
// activity to setup watch
MojString name;
GetSentEmailsWatchActivityName(name);
// description of watch
MojString desc;
GetSentEmailsWatchActivityDesc(desc);
builder.SetName(name.data());
builder.SetDescription(desc.data());
builder.SetPersist(true);
builder.SetExplicit(true);
builder.SetForeground(true);
// setup trigger
MojDbQuery trigger;
MojErr err = trigger.from(EmailSchema::Kind::EMAIL);
ErrorToException(err);
err = trigger.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, outboxFolderId);
ErrorToException(err);
err = trigger.where("sendStatus.sent", MojDbQuery::OpEq, true);
ErrorToException(err);
builder.SetDatabaseWatchTrigger(trigger);
// setup parameters (to be sent when trigger is called)
MojObject params;
err = params.put(PopFolderAdapter::ACCOUNT_ID, m_accountId);
ErrorToException(err);
err = params.put(PopFolderAdapter::OUTBOX_FOLDER_ID, outboxFolderId);
ErrorToException(err);
err = params.put(PopFolderAdapter::SENT_FOLDER_ID, sentFolderId);
ErrorToException(err);
builder.SetCallback(SENT_EMAILS_WATCH_CALLBACK, params);
// put accountId in metadata
MojObject metadata;
err = metadata.put("accountId", m_accountId);
ErrorToException(err);
builder.SetMetadata(metadata);
}
MojErr MojDbWatchTest::rangeTest(MojDb& db)
{
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpGreaterThan, 5);
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpLessThan, 100);
MojTestErrCheck(err);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
MojObject id;
MojInt64 rev;
err = put(db, 5, 5, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 100, 100, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 6, 6, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 99, 99, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
return MojErrNone;
}
void SmtpActivityFactory::BuildSmtpConfigWatch(ActivityBuilder& ab, const MojObject& accountId, MojInt64 rev)
{
MojErr err;
MojString name;
err = name.format(ACCOUNT_WATCH_ACTIVITY_FMT, AsJsonString(accountId).c_str());
ErrorToException(err);
// description of watch
MojString desc;
err = desc.format("Watches SMTP config on account %s", AsJsonString(accountId).c_str());
ErrorToException(err);
// activity to setup watch
ab.SetName(name);
ab.SetDescription(desc.data());
ab.SetPersist(true);
ab.SetExplicit(true);
ab.SetRequiresInternet(false); // trigger even if we don't have a network connection
ab.SetImmediate(true, ActivityBuilder::PRIORITY_LOW);
// setup trigger
// NOTE: how to trigger only on SMTP config change?
MojDbQuery trigger;
err = trigger.from("com.palm.mail.account:1");
ErrorToException(err);
err = trigger.where("accountId", MojDbQuery::OpEq, accountId);
ErrorToException(err);
if (rev > 0) {
trigger.where("_revSmtp", MojDbQuery::OpGreaterThan, rev);
}
ab.SetDatabaseWatchTrigger(trigger);
MojObject params;
err = params.put("accountId", accountId);
ErrorToException(err);
ab.SetCallback(ACCOUNT_UPDATED_BUS_METHOD, params);
ab.SetMetadata(params);
}
/*
* Create the query to find the buddy in contacts table by username and serviceName
*
* errors returned to caller
*/
MojErr SendOneCommandHandler::createContactQuery(MojDbQuery& query)
{
MojErr err = query.where("ims.value", MojDbQuery::OpEq, m_buddyName);
MojErrCheck(err);
err = query.where("ims.type", MojDbQuery::OpEq, m_serviceName);
MojErrCheck(err);
//add our kind to the object
err = query.from(IM_CONTACT_KIND);
MojErrCheck(err);
// log the query
MojObject queryObject;
err = query.toObject(queryObject);
MojErrCheck(err);
IMServiceHandler::logMojObjectJsonString(_T("createContactQuery: %s"), queryObject);
return MojErrNone;
}
MojErr MojDbSearchTest::initQuery(MojDbQuery& query, const MojChar* queryStr, const MojChar* orderBy, const MojObject& barVal, bool desc)
{
query.clear();
MojErr err = query.from(_T("SearchTest:1"));
MojTestErrCheck(err);
MojString val;
err = val.assign(queryStr);
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpSearch, val, MojDbCollationPrimary);
MojTestErrCheck(err);
query.desc(desc);
if (!barVal.undefined()) {
err = query.where(_T("bar"), MojDbQuery::OpEq, barVal);
MojTestErrCheck(err);
}
if (orderBy) {
err = query.order(orderBy);
MojTestErrCheck(err);
}
return MojErrNone;
}
void checkMarkWithUpdate(MojUInt32 expect = 50ul, int mark = -1, MojDbReqRef req = MojDbReq())
{
MojDbQuery query;
MojAssertNoErr( query.from(_T("Test:1")) );
MojAssertNoErr( query.where(_T("bar"), MojDbQuery::OpEq, mark) );
MojObject update;
MojUInt32 count = (MojUInt32)(-1);
MojAssertNoErr( db.merge(query, MojObject(), count, MojDb::FlagNone, req) );
EXPECT_EQ( expect, count );
}
void MojoDatabase::GetFolder(Signal::SlotRef slot, const MojObject& folderId)
{
MojDbQuery q;
MojErr err = q.from(PopFolderAdapter::POP_FOLDER_KIND);
ErrorToException(err);
err = q.where(PopFolderAdapter::ID, MojDbQuery::OpEq, folderId);
ErrorToException(err);
err = m_dbClient.find(slot, q);
ErrorToException(err);
}
void MojoDatabase::GetUidCache(Signal::SlotRef slot, const MojObject& accountId)
{
MojDbQuery q;
MojErr err = q.from(UidCacheAdapter::EMAILS_UID_CACHE_KIND);
ErrorToException(err);
err = q.where(UidCacheAdapter::ACCOUNT_ID, MojDbQuery::OpEq, accountId);
ErrorToException(err);
err = m_dbClient.find(slot, q);
ErrorToException(err);
}
void MojoDatabase::DeleteItems (Signal::SlotRef slot, const std::string kind, const std::string idField, const MojObject& id)
{
MojDbQuery q;
MojErr err = q.from(kind.c_str());
ErrorToException(err);
err = q.where(idField.c_str(), MojDbQuery::OpEq, id);
ErrorToException(err);
err = m_dbClient.del(slot, q, MojDb::FlagPurge);
ErrorToException(err);
}
void MojoDatabase::GetAccount(Signal::SlotRef slot, const MojObject& accountId)
{
MojDbQuery q;
MojErr err = q.from(PopAccountAdapter::POP_ACCOUNT_KIND);
ErrorToException(err);
err = q.where(PopAccountAdapter::ACCOUNT_ID, MojDbQuery::OpEq, accountId);
ErrorToException(err);
// now find the folder the e-mail belongs to
err = m_dbClient.find(slot, q);
ErrorToException(err);
}
void mark3(MojDbReqRef req = MojDbReq())
{
MojDbQuery query;
MojAssertNoErr( query.from(_T("Test:1")) );
MojAssertNoErr( query.where(_T("bar"), MojDbQuery::OpLessThan, 2) );
MojObject update;
MojAssertNoErr( update.put(_T("bar"), -3) );
MojUInt32 count = 0xbaddcafe;
MojAssertNoErr( db.merge(query, update, count, MojDb::FlagNone, req) );
EXPECT_EQ( 33ul, count );
}
void MojoDatabase::GetLocalEmailChanges(Signal::SlotRef slot, const MojObject& folderId, const MojInt64& rev, MojDbQuery::Page& page, MojInt32 limit)
{
MojDbQuery query;
MojErr err = query.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = query.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, folderId);
ErrorToException(err);
if (rev > 0) {
err = query.where(PopFolderAdapter::LAST_SYNC_REV, MojDbQuery::OpGreaterThan, rev);
ErrorToException(err);
}
query.includeDeleted(true);
query.page(page);
slot.cancel();
err = m_dbClient.find(slot, query);
ErrorToException(err);
}
/*
* Enabling an IM account requires the following
* add com.palm.imloginstate.libpurple record
*/
MojErr OnEnabledHandler::accountEnabled()
{
MojLogTrace(IMServiceApp::s_log);
MojLogInfo(IMServiceApp::s_log, _T("accountEnabled id=%s, serviceName=%s"), m_accountId.data(), m_serviceName.data());
// first see if an imloginstate record already exists for this account. This can happen on an OTA update or restore
// construct our where clause - find by username and servicename
MojDbQuery query;
query.where("serviceName", MojDbQuery::OpEq, m_serviceName);
query.where("username", MojDbQuery::OpEq, m_username);
query.from(IM_LOGINSTATE_KIND);
MojErr err = m_dbClient.find(this->m_findImLoginStateSlot, query);
if (err) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("accountEnabled: dbClient.find() failed: error %d - %s"), err, error.data());
// query failed - not much we can do here...
}
return err;
}
void MojoDatabase::GetEmail(Signal::SlotRef slot, const MojObject& emailId)
{
MojDbQuery q;
MojErr err = q.from(PopEmailAdapter::POP_EMAIL_KIND);
ErrorToException(err);
err = q.where(PopEmailAdapter::ID, MojDbQuery::OpEq, emailId);
ErrorToException(err);
err = m_dbClient.find(slot, q);
ErrorToException(err);
}
void MojoDatabase::GetMainAccount(Signal::SlotRef slot, const MojObject& accountId)
{
MojDbQuery q;
MojErr err = q.from("com.palm.account:1");
ErrorToException(err);
err = q.where(DatabaseAdapter::ID, MojDbQuery::OpEq, accountId);
ErrorToException(err);
err = m_dbClient.find(slot, q);
ErrorToException(err);
}
void MojoDatabase::UpdateAccountRetry(Signal::SlotRef slot, const MojObject& accountId, const MojObject& account)
{
MojErr err;
MojDbQuery query;
err = query.from(PopAccountAdapter::POP_ACCOUNT_KIND);
ErrorToException(err);
err = query.where(PopAccountAdapter::ACCOUNT_ID, MojDbQuery::OpEq, accountId);
ErrorToException(err);
err = m_dbClient.merge(slot, query, account);
ErrorToException(err);
}
void ImapActivityFactory::BuildDraftsWatch(ActivityBuilder& ab, const MojObject& accountId, const MojObject& folderId, MojInt64 rev)
{
MojErr err;
ab.SetName( GetDraftsWatchName(accountId, folderId) );
ab.SetDescription("Watches for updates to draft emails");
ab.SetPersist(true);
ab.SetExplicit(true);
ab.SetForeground(true);
// Metadata
MojObject metadata;
SetMetadata(metadata, DRAFTS_WATCH_NAME, accountId, folderId);
ab.SetMetadata(metadata);
MojDbQuery query;
err = query.from(EmailSchema::Kind::EMAIL);
ErrorToException(err);
err = query.where(EmailSchema::FOLDER_ID, MojDbQuery::OpEq, folderId);
ErrorToException(err);
MojString editedDraftFlag;
editedDraftFlag.format("%s.%s", EmailSchema::FLAGS, EmailSchema::Flags::EDITEDDRAFT);
err = query.where(editedDraftFlag.data(), MojDbQuery::OpEq, true);
ErrorToException(err);
ab.SetDatabaseWatchTrigger(query);
// Callback
MojObject callbackParams;
err = callbackParams.put("accountId", accountId);
ErrorToException(err);
err = callbackParams.put("folderId", accountId);
ErrorToException(err);
ab.SetCallback(DRAFTS_WATCH_CALLBACK, callbackParams);
}
