void PopAccountUpdateCommand::UpdateAccountWatchActivity()
{
CommandTraceFunction();
try {
MojObject revPop;
MojErr err = m_transportObj.getRequired("_revPop", revPop);
ErrorToException(err);
ActivityBuilder ab;
m_activityBuilderFactory->BuildAccountPrefsWatch(ab, revPop);
MojObject payload;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
ErrorToException(err);
m_client.SendRequest(m_createActivitySlot, "com.palm.activitymanager", "create", payload);
} catch (const std::exception& ex) {
Failure(ex);
} catch (...) {
Failure(MailException("unknown exception", __FILE__, __LINE__));
}
}
void MovePopEmailsCommand::RunImpl()
{
CommandTraceFunction();
try {
if (!m_client.GetAccount().get()) {
MojString err;
err.format("Account is not loaded for '%s'", AsJsonString(
m_client.GetAccountId()).c_str());
throw MailException(err.data(), __FILE__, __LINE__);
}
MojErr err = m_payload.getRequired("accountId", m_accountId);
ErrorToException(err);
m_activity = ActivityParser::GetActivityFromPayload(m_payload);
if (m_activity.get()) {
m_activity->SetSlots(m_activityUpdateSlot, m_activityErrorSlot);
m_activity->Adopt(m_client);
return;
} else {
GetEmailsToMove();
}
} catch (const std::exception& ex) {
m_msg->replyError(MojErrInternal, ex.what());
Failure(ex);
} catch (...) {
MailException ex("unknown exception", __FILE__, __LINE__);
m_msg->replyError(MojErrInternal, ex.what());
Failure(ex);
}
}
MojErr DeleteAccountCommand::GetAccountInfoResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ResponseToException(response, err);
MojObject result;
err = response.getRequired("result", result);
ErrorToException(err);
MojString templateId;
bool hasTemplateId = false;
err = result.get(ImapAccountAdapter::TEMPLATEID, templateId, hasTemplateId);
ErrorToException(err);
if(hasTemplateId) {
if(templateId == "com.palm.yahoo") { // FIXME use constant
m_isYahoo = true;
}
}
DeleteAccount();
} CATCH_AS_FAILURE
return MojErrNone;
}
void UpSyncSentEmailsCommand::GetSentEmails()
{
CommandTraceFunction();
MojObject outboxId = m_session.GetAccount()->GetOutboxFolderId();
m_session.GetDatabaseInterface().GetSentEmails(m_getSentEmailsSlot, outboxId, m_sentEmailsPage, LOCAL_BATCH_SIZE);
}
bool ImapSyncSessionCommand::PrepareToRun()
{
CommandTraceFunction();
if(!ImapSessionCommand::PrepareToRun()) {
// Parent class isn't ready to let us run yet
return false;
}
if(m_syncSessionReady) {
return true;
}
try {
if(m_session.GetClient().get() == NULL) {
throw MailException("can't run sync session command without a client", __FILE__, __LINE__);
}
m_session.GetClient()->RequestSyncSession(m_folderId, this, m_syncSessionReadySlot);
// SyncSessionReady will be called when the sync session is ready to run
} catch(const exception& e) {
Failure(e);
} catch(...) {
Failure(UNKNOWN_EXCEPTION);
}
return false;
}
void DeleteAccountCommand::DeleteYahooAccount()
{
CommandTraceFunction();
MojLogInfo(m_log, "notifying Yahoo service of account deletion");
m_client.SendRequest(m_yahooAccountDeletedSlot, "com.palm.yahoo", "accountdeleted", m_payload);
}
void ReconcileEmailsCommand::GetLocalEmails()
{
CommandTraceFunction();
// TODO: need to get last sync rev from sync session
MojInt32 lastRev = 0;
m_getLocalEmailsResponseSlot.cancel(); // in case this is called multiple times
m_session.GetDatabaseInterface().GetEmailSyncList(m_getLocalEmailsResponseSlot, m_folderId, lastRev, true, m_localEmailsPage, LOAD_EMAIL_BATCH_SIZE);
}
void IdleCommand::Idle()
{
CommandTraceFunction();
m_parser.reset(new ImapResponseParser(m_session, m_doneSlot));
m_parser->SetContinuationResponseSlot(m_continuationSlot);
m_session.SendRequest("IDLE", m_parser);
}
void DeleteActivitiesCommand::GetActivityList()
{
CommandTraceFunction();
MojObject payload(MojObject::TypeObject);
m_client.SendRequest(m_activityListSlot, "com.palm.activitymanager", "list", payload);
}
MojErr ImapSyncSessionCommand::SyncSessionReady()
{
CommandTraceFunction();
m_syncSessionReady = true;
RunIfReady();
return MojErrNone;
}
// Find existing special folders
void PopAccountEnableCommand::FindSpecialFolders()
{
CommandTraceFunction();
MojObject::ObjectVec folders;
EmailAccountAdapter::AppendSpecialFolderIds(*m_account.get(), folders);
m_client.GetDatabaseInterface().GetByIds(m_getFoldersSlot, folders);
}
void IdleCommand::BuildUIDMap()
{
CommandTraceFunction();
MojLogInfo(m_log, "need to sync UID list before entering idle");
// Run sync command
m_syncCommand.reset(new SyncEmailsCommand(m_session, m_folderId));
m_syncCommand->Run(m_syncSlot);
}
void ScheduleRetryCommand::UpdateAccount()
{
CommandTraceFunction();
MojObject accountObj;
EmailAccountAdapter::SerializeAccountRetryStatus(m_client.GetAccount(), accountObj);
m_client.GetDatabaseInterface().UpdateAccountRetry(m_updateAccountSlot, m_client.GetAccountId(), accountObj);
}
void DeleteAccountCommand::Done()
{
CommandTraceFunction();
m_client.DeletedAccount();
if(m_msg.get()) {
m_msg->replySuccess();
}
Complete();
}
MojErr ScheduleRetryCommand::CancelActivitiesDone()
{
CommandTraceFunction();
try {
m_deleteActivitiesCommand->GetResult()->CheckException();
UpdateAccount();
} CATCH_AS_FAILURE
return MojErrNone;
}
MojErr ScheduleRetryCommand::ScheduleRetryResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ErrorToException(err);
CancelActivities();
} CATCH_AS_FAILURE
return MojErrNone;
}
// Tell SMTP that the account has been updated; only if the credentials changed
void PopAccountUpdateCommand::NotifySmtp()
{
CommandTraceFunction();
MojErr err;
MojObject payload;
err = payload.put("accountId", m_client.GetAccountId());
ErrorToException(err);
m_client.SendRequest(m_notifySmtpSlot, "com.palm.smtp", "credentialsChanged", payload);
}
MojErr ScheduleRetryCommand::UpdateAccountResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ErrorToException(err);
Complete();
} CATCH_AS_FAILURE
return MojErrNone;
}
MojErr SearchFolderCommand::HandleContinuation()
{
CommandTraceFunction();
try {
OutputStreamPtr& os = m_session.GetOutputStream();
os->Write(m_searchRequest->GetSearchText());
os->Write("\r\n");
os->Flush();
} CATCH_AS_FAILURE
return MojErrNone;
}
void ConnectCommand::ConnectFailure(const exception& e)
{
CommandTraceFunction();
MojLogError(m_log, "error connecting to server: %s", e.what());
if(m_connection.get()) {
m_connection->Shutdown();
}
m_session.ConnectFailure(e);
Failure(e);
}
void SearchFolderCommand::RequestHeaders()
{
CommandTraceFunction();
stringstream ss;
ss << "UID FETCH ";
AppendUIDs(ss, m_matchingUIDs.rbegin(), m_matchingUIDs.rend());
ss << " (" << FetchNewHeadersCommand::FETCH_ITEMS << ")";
m_headersResponseParser.reset(new FetchResponseParser(m_session, m_headersResponseSlot));
m_session.SendRequest(ss.str(), m_headersResponseParser);
}
MojErr IdleCommand::SyncResponse()
{
CommandTraceFunction();
try {
m_syncCommand->GetResult()->CheckException();
m_syncCommand.reset();
ScheduleWakeup();
} CATCH_AS_FAILURE
return MojErrNone;
}
void IdleCommand::RunImpl()
{
CommandTraceFunction();
boost::shared_ptr<FolderSession> folderSession = m_session.GetFolderSession();
if(folderSession.get() && folderSession->HasUIDMap()) {
// Already have a UID map
ScheduleWakeup();
} else {
// Need a UID map before we can do anything
BuildUIDMap();
}
}
MojErr DeleteAccountCommand::DeleteAccountResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ErrorToException(err);
// Tell SMTP service to clean up any SMTP state
DeleteSmtpAccount();
} CATCH_AS_FAILURE
return MojErrNone;
}
void DeleteAccountCommand::GetAccountInfo()
{
CommandTraceFunction();
MojLogInfo(m_log, "getting account info to delete account");
MojErr err;
MojObject params;
err = params.put("accountId", m_client.GetAccountId());
ErrorToException(err);
m_client.SendRequest(m_getAccountSlot, "com.palm.service.accounts","getAccountInfo", params);
}
MojErr ConnectCommand::Connected(const std::exception* exc)
{
CommandTraceFunction();
if(exc == NULL) {
MojLogInfo(m_log, "connected to server");
m_session.Connected(m_connection);
Complete();
} else {
ConnectFailure(*exc);
}
return MojErrNone;
}
MojErr PopAccountUpdateCommand::NotifySmtpResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ResponseToException(response, err);
} catch(const std::exception& e) {
// log and ignore error
MojLogError(m_log, "error calling SMTP credentialsChanged: %s", e.what());
}
Done();
return MojErrNone;
}
void SmtpSyncOutboxCommand::GetOutboxEmails()
{
CommandTraceFunction();
try {
m_outboxPage.clear();
m_emailsToSend.clear();
GetSomeOutboxEmails();
} catch (std::exception & e) {
HandleException(e, __func__);
} catch (...) {
HandleException(__func__);
}
}
void PopAccountDeleteCommand::RunImpl()
{
CommandTraceFunction();
try {
MojErr err = m_payload.getRequired("accountId", m_accountId);
ErrorToException(err);
m_dbInterface->DeleteItems(m_deletePopAccountSlot, PopAccountAdapter::POP_ACCOUNT_KIND, "accountId", m_accountId);
} catch (const std::exception& e) {
m_msg->replyError(MojErrInternal);
Failure(e);
} catch (...) {
m_msg->replyError(MojErrInternal);
Failure(MailException("unknown exception", __FILE__, __LINE__));
}
}
void NoopIdleCommand::EndIdle()
{
CommandTraceFunction();
m_wakeupActivity->Unsubscribe();
MojLogInfo(m_log, "ending NOOP idle");
long duration = std::abs(time(NULL) - m_timeStarted);
if (m_session.IsConnected() && !m_timeExpired && duration >= NOOP_THRESHOLD) {
try {
SendNoop();
} CATCH_AS_FAILURE
} else {
