/**
* Return MojObject formated to save to MojDb
* Used for incoming messages
*/
MojErr IMMessage::createDBObject(MojObject& returnObj) {
MojLogInfo(IMServiceApp::s_log, _T("createMojObject"));
// Communications kind
// From/to address is itself a CommunicationsAddress object
// "name" and "type" properties are optional
// Sender
MojObject addressObj;
MojErr err = addressObj.putString(MOJDB_ADDRESS, fromAddress);
MojErrCheck(err);
err = returnObj.put(MOJDB_FROM, addressObj);
MojErrCheck(err);
// Recipient
MojObject recipientArray, recipient;
err = recipient.put(MOJDB_ADDRESS, toAddress);
MojErrCheck(err);
err = recipientArray.push(recipient);
MojErrCheck(err);
err = returnObj.put(MOJDB_TO, recipientArray);
MojErrCheck(err);
// Message kind
err = returnObj.putString(MOJDB_FOLDER, folderStrings[folder]);
MojErrCheck(err);
err = returnObj.putString(MOJDB_STATUS, statusStrings[status]);
MojErrCheck(err);
err = returnObj.putString(MOJDB_MSG_TEXT, msgText);
MojErrCheck(err);
// username - since this is incoming message, the username is always in toAddress
err = returnObj.putString(MOJDB_USERNAME, toAddress);
MojErrCheck(err);
// service name
err = returnObj.putString(MOJDB_SERVICENAME, msgType);
MojErrCheck(err);
// localTimestamp
err = returnObj.putInt(MOJDB_DEVICE_TIMESTAMP, deviceTimestamp);
MojErrCheck(err);
// incoming server
err = returnObj.putInt(MOJDB_SERVER_TIMESTAMP, serverTimestamp);
MojErrCheck(err);
IMServiceHandler::privatelogIMMessage(_T("DB Message object %s:"), returnObj, MOJDB_MSG_TEXT);
return err;
}
MojErr MojDbQuotaTest::testEnforce(MojDb& db)
{
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
MojErr err = getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1);
MojTestErrCheck(err);
MojObject obj;
err = obj.putString(_T("owner"), _T("com.foo.bar"));
MojErrCheck(err);
err = obj.putInt(_T("size"), quotaUsage1);
MojErrCheck(err);
err = db.putQuotas(&obj, &obj + 1);
MojErrCheck(err);
err = put(db, MojTestKind1Objects[3]);
MojTestErrExpected(err, MojErrDbQuotaExceeded);
// Try to delete the kind
MojString kindStr;
err = kindStr.assign(_T("Test:1"));
MojTestErrCheck(err);
bool found = false;
err = db.delKind(kindStr, found);
//The delete should be failure, because it contain sub kind "Test2:1"
MojTestErrExpected(err,MojErrDbKindHasSubKinds);
MojTestAssert(!found);
return MojErrNone;
}
void BusClient::ScheduleShutdown()
{
MojLogTrace(m_log);
// Reply to the "run" message now that we're done
if (m_launchedAsService && m_msg.get()) {
const Configurator::ConfigCollection& ok = Configurator::ConfigureOk();
const Configurator::ConfigCollection& failed = Configurator::ConfigureFailure();
if (m_wrongAplication) {
MojString response;
response.appendFormat("Aplication or service doesn't exist");
m_wrongAplication = false;
m_msg->replyError(MojErrInternal, response.data());
} else if (!failed.empty()) {
MojString response;
response.appendFormat("Partial configuration - %zu ok, %zu failed", ok.size(), failed.size());
m_msg->replyError(MojErrInternal, response.data());
} else {
MojObject response;
response.putInt("configured", ok.size());
m_msg->replySuccess(response);
}
m_msg.reset();
}
if (!m_pending.empty()) {
MojLogDebug(m_log, "%d pending service calls to handle remaining", m_pending.size());
// still more pending work
m_configuratorsCompleted = 0;
m_configurators.clear();
Configurator::ResetConfigStats();
const PendingWork &pending = m_pending.back();
(pending.instance->*(pending.callback))(pending.msg.get(), pending.payload);
m_pending.pop_back();
return;
}
MojLogDebug(m_log, "No more pending service calls to handle - scheduling shutdown");
// Schedule an event to shutdown once the stack is unwound.
if (m_timerTimeout == 0) {
// this is to work around around a race condition where the LSCall is delivered
// after we shutdown causing us to start back up - give some time for the LSCall
// to get delivered. NOV-114626. This needs a proper fix within ls2 (can't be
// worked around anywhere else).
m_timerTimeout = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, /* timer priority */
500, /* timeout in ms */
&BusClient::ShutdownCallback, // callback
this, /* callback data */
NULL /*destroy notify callback*/
);
}
//g_idle_add(&BusClient::ShutdownCallback, this);
m_shuttingDown = true;
}
MojErr PowerdPowerActivity::CreateRemotePowerActivity(bool debounce)
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
MojErr err;
MojObject params;
err = params.putString(_T("id"), GetRemotePowerActivityName().c_str());
MojErrCheck(err);
int duration;
if (debounce) {
duration = PowerActivityDebounceDuration * 1000;
} else {
duration = PowerActivityLockDuration * 1000;
}
err = params.putInt(_T("duration_ms"), duration);
MojErrCheck(err);
m_call = boost::make_shared<MojoWeakPtrCall<PowerdPowerActivity> >(
boost::dynamic_pointer_cast<PowerdPowerActivity, PowerActivity>(
shared_from_this()), debounce ?
&PowerdPowerActivity::PowerUnlockedNotificationDebounce :
&PowerdPowerActivity::PowerLockedNotification,
m_service, "palm://com.palm.power/com/palm/power/activityStart",
params);
m_call->Call();
return MojErrNone;
}
MojErr MojDbQuotaTest::testEnforce(MojDb& db)
{
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
MojErr err = getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1);
MojTestErrCheck(err);
MojObject obj;
err = obj.putString(_T("owner"), _T("com.foo.bar"));
MojErrCheck(err);
err = obj.putInt(_T("size"), quotaUsage1);
MojErrCheck(err);
err = db.putQuotas(&obj, &obj + 1);
MojErrCheck(err);
err = put(db, MojTestKind1Objects[3]);
MojTestErrExpected(err, MojErrDbQuotaExceeded);
// make sure we can delete the kind
MojString kindStr;
err = kindStr.assign(_T("Test:1"));
MojTestErrCheck(err);
bool found = false;
err = db.delKind(kindStr, found);
MojTestErrCheck(err);
MojTestAssert(found);
return MojErrNone;
}
void SmtpValidator::Failure(MailError::ErrorCode errorCode, const std::string& errorText)
{
if (m_timeoutId) {
g_source_remove(m_timeoutId);
m_timeoutId = 0;
}
MojLogInfo(m_log, "SmtpValidator %p Failure1", this);
//MojLogInfo(m_log, "SmtpValidator %p Failure1, was trying to connect to %s:%d", this, m_account->GetHostname().c_str(), m_account->GetPort());
MojLogTrace(m_log);
MojObject reply;
MojErr err = reply.putBool(MojServiceMessage::ReturnValueKey, false);
ErrorToException(err);
std::string accountErrorCode = MailError::GetAccountErrorCode(errorCode);
err = reply.putString(MojServiceMessage::ErrorCodeKey, accountErrorCode.c_str());
ErrorToException(err);
err = reply.putInt("mailErrorCode", errorCode);
ErrorToException(err);
err = reply.putString("errorText", errorText.c_str());
ErrorToException(err);
if (!m_replied) {
// if we already replied due to a timeout, don't reply again.
err = m_msg->reply(reply);
ErrorToException(err);
m_replied = true;
}
}
TEST_F(QuotaTest, enforce)
{
MojObject obj;
// put quota
MojAssertNoErr( obj.fromJson(_T("{\"owner\":\"com.foo.bar\",\"size\":1000}")) );
MojAssertNoErr( db.putQuotas(&obj, &obj + 1) );
// make kind2 inherit from kind1
MojAssertNoErr( obj.fromJson(MojTestKind2Str3) );
MojExpectNoErr( db.putKind(obj) );
//// end of prerequisites form prev tests
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
EXPECT_NO_FATAL_FAILURE( getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1) );
MojAssertNoErr( obj.putString(_T("owner"), _T("com.foo.bar")) );
MojAssertNoErr( obj.putInt(_T("size"), quotaUsage1) );
MojExpectNoErr( db.putQuotas(&obj, &obj + 1) );
MojAssertNoErr( obj.fromJson(MojTestKind1Objects[3]) );
EXPECT_EQ( MojErrDbQuotaExceeded, db.put(obj) );
// Try to delete the kind
MojString kindStr;
MojAssertNoErr( kindStr.assign(_T("Test:1")) );
bool found = false;
EXPECT_EQ( MojErrDbKindHasSubKinds, db.delKind(kindStr, found) )
<< "The delete should be failure, because it contain sub kind \"Test2:1\"";
EXPECT_FALSE( found );
}
void Command::Status(MojObject& status) const
{
MojErr err;
err = status.putString("class", GetClassName().c_str());
ErrorToException(err);
err = status.putInt("priority", m_priority);
ErrorToException(err);
}
void SmtpValidator::Status(MojObject& status) const
{
char buf[64];
memset(buf, '\0', sizeof(buf));
snprintf(buf, sizeof(buf)-1, "%p", this);
MojErr err = status.putString("pointer",buf);;
ErrorToException(err);
err = status.putBool("running", m_running);
ErrorToException(err);
err = status.putString("hostname", m_account->GetHostname().c_str());
ErrorToException(err);
err = status.putInt("port", m_account->GetPort());
ErrorToException(err);
err = status.putInt("encryption", m_account->GetEncryption());
ErrorToException(err);
}
MojErr MojoDBPersistToken::ToJson(MojObject& rep) const
{
MojErr err;
if (!m_valid) {
throw std::runtime_error("ID not set");
}
err = rep.putString(_T("_id"), m_id);
MojErrCheck(err);
err = rep.putInt(_T("_rev"), m_rev);
MojErrCheck(err);
return MojErrNone;
}
MojErr formatErrResponse(MojErr errExpected, MojObject& objOut)
{
MojString errTxt;
MojErr err = MojErrToString(errExpected, errTxt);
MojTestErrCheck(err);
// format expected error return
err = objOut.putBool(MojServiceMessage::ReturnValueKey, false);
MojErrCheck(err);
err = objOut.putInt(MojServiceMessage::ErrorCodeKey, (MojInt64)errExpected);
MojErrCheck(err);
err = objOut.putString(MojServiceMessage::ErrorTextKey, errTxt);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbPerfUpdateTest::mergeObj(MojDb& db, MojObject& obj, MojTime& objTime)
{
MojTime startTime;
MojTime endTime;
for (MojUInt64 i = 0; i < numMergeIterations; i++) {
MojErr err = MojGetCurrentTime(startTime);
MojTestErrCheck(err);
err = obj.putInt(_T("newProp"), i);
MojTestErrCheck(err);
err = db.merge(obj);
MojTestErrCheck(err);
err = MojGetCurrentTime(endTime);
MojTestErrCheck(err);
objTime += (endTime - startTime);
totalTestTime += (endTime - startTime);
}
return MojErrNone;
}
MojErr MojServiceMessage::replyError(MojErr code, const MojChar* text)
{
MojAssert(code != MojErrNone && text);
MojObject payload;
MojErr err = payload.putBool(ReturnValueKey, false);
MojErrCheck(err);
err = payload.putInt(ErrorCodeKey, (MojInt64) code);
MojErrCheck(err);
err = payload.putString(ErrorTextKey, text);
MojErrCheck(err);
// reset the writer first, then reply with this payload
err = writer().reset();
MojErrCheck(err);
err = reply(payload);
MojErrCheck(err);
return MojErrNone;
}
/*
* Enabling an IM account requires the following
* add com.palm.imloginstate.libpurple record
*/
MojErr OnEnabledHandler::accountEnabled(const MojString& accountId, const MojString& serviceName, const MojString& username)
{
//TODO: first issue a merge in case the account already exists?
MojLogTrace(IMServiceApp::s_log);
MojLogInfo(IMServiceApp::s_log, _T("accountEnabled id=%s, serviceName=%s"), accountId.data(), serviceName.data());
MojObject imLoginState;
imLoginState.putString(_T("_kind"), IM_LOGINSTATE_KIND);
imLoginState.put(_T("accountId"), accountId);
imLoginState.put(_T("serviceName"), serviceName);
imLoginState.put(_T("username"), username);
imLoginState.putString(_T("state"), LOGIN_STATE_OFFLINE);
imLoginState.putInt(_T("availability"), PalmAvailability::ONLINE); //default to online so we automatically login at first
MojErr err = m_dbClient.put(m_addImLoginStateSlot, imLoginState);
if (err != MojErrNone) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler db.put() failed: error %d - %s"), err, error.data());
}
return err;
}
// Copy fields from createAccount payload into com.palm.imap.account object
void ImapAccountAdapter::GetImapAccountFromPayload(const MojObject& accountObj, const MojObject& payload, MojObject& imapAccount)
{
MojErr err = imapAccount.putString(ImapAccountAdapter::KIND, ImapAccountAdapter::SCHEMA);
ErrorToException(err);
MojObject accountId;
err = payload.getRequired(ImapAccountAdapter::ACCOUNT_ID, accountId);
ErrorToException(err);
err = imapAccount.put(ImapAccountAdapter::ACCOUNT_ID, accountId);
ErrorToException(err);
MojObject config;
err = payload.getRequired(ImapAccountAdapter::CONFIG, config);
ErrorToException(err);
MojString username;
bool hasUsername = false;
err = config.get(ImapAccountAdapter::USERNAME, username, hasUsername);
ErrorToException(err);
if(!hasUsername)
{
err = accountObj.getRequired(ImapAccountAdapter::USERNAME, username);
ErrorToException(err);
}
err = imapAccount.put(ImapAccountAdapter::USERNAME, username);
ErrorToException(err);
MojString hostname;
err = config.getRequired(ImapAccountAdapter::HOSTNAME, hostname);
ErrorToException(err);
err = imapAccount.put(ImapAccountAdapter::HOSTNAME, hostname);
ErrorToException(err);
int port;
err = config.getRequired(ImapAccountAdapter::PORT, port);
ErrorToException(err);
err = imapAccount.put(ImapAccountAdapter::PORT, port);
ErrorToException(err);
MojString encryption;
err = config.getRequired(ImapAccountAdapter::ENCRYPTION, encryption);
ErrorToException(err);
err = imapAccount.put(ImapAccountAdapter::ENCRYPTION, encryption);
ErrorToException(err);
/* Optional config parameters; fill in with defaults if not provided */
bool hasSyncFrequency = false;
int syncFrequencyMins = 0;
config.get(EmailAccountAdapter::SYNC_FREQUENCY_MINS, syncFrequencyMins, hasSyncFrequency);
ErrorToException(err);
err = imapAccount.putInt(EmailAccountAdapter::SYNC_FREQUENCY_MINS,
hasSyncFrequency ? syncFrequencyMins : DEFAULT_SYNC_FREQUENCY_MINS);
ErrorToException(err);
bool hasSyncWindow = false;
int syncWindow = 0;
err = config.get(EmailAccountAdapter::SYNC_WINDOW_DAYS, syncWindow, hasSyncWindow);
ErrorToException(err);
err = imapAccount.putInt(EmailAccountAdapter::SYNC_WINDOW_DAYS,
hasSyncWindow ? syncWindow : DEFAULT_SYNC_WINDOW_DAYS);
ErrorToException(err);
}
MojErr MojDbIndexTest::defaultValuesTest()
{
MojDbIndex index(NULL, NULL);
MojRefCountedPtr<TestIndex> storageIndex(new TestIndex(false));
MojAllocCheck(storageIndex.get());
TestIndex& ti = *storageIndex;
MojObject prop;
MojErr err = prop.putString(MojDbIndex::NameKey, _T("foo"));
MojTestErrCheck(err);
err = prop.putInt(MojDbIndex::DefaultKey, 100);
MojTestErrCheck(err);
err = index.addProp(prop);
MojTestErrCheck(err);
MojDbReq req;
err = index.open(storageIndex.get(), (MojInt64) 0, req);
MojTestErrCheck(err);
err = put(index, 1, _T("{\"bar\":1}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti.m_putCount == 1 && ti.m_delCount == 0 && ti.m_set.size() == 1);
err = put(index, 1, _T("{\"foo\":5}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti.m_putCount == 2 && ti.m_delCount == 0 && ti.m_set.size() == 2);
err = put(index, 1, _T("{\"foo\":{\"bar\":3}}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 0 && ti.m_set.size() == 3);
err = index.close();
MojTestErrCheck(err);
MojDbIndex index2(NULL, NULL);
MojRefCountedPtr<TestIndex> storageIndex2(new TestIndex(false));
MojAllocCheck(storageIndex2.get());
TestIndex& ti2 = *storageIndex2;
MojObject prop2;
err = prop2.putString(MojDbIndex::NameKey, _T("bar"));
MojTestErrCheck(err);
err = index2.addProp(prop2);
MojTestErrCheck(err);
err = index2.open(storageIndex2.get(), (MojInt64) 0, req);
MojTestErrCheck(err);
err = put(index2, 1, _T("{\"bar\":1}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti2.m_putCount == 1 && ti2.m_delCount == 0 && ti2.m_set.size() == 1);
err = put(index2, 1, _T("{\"foo\":5}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti2.m_putCount == 1 && ti2.m_delCount == 0 && ti2.m_set.size() == 1);
err = put(index2, 1, _T("{\"foo\":{\"bar\":3}}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti2.m_putCount == 1 && ti2.m_delCount == 0 && ti2.m_set.size() == 1);
err = index2.close();
MojTestErrCheck(err);
MojDbIndex index3(NULL, NULL);
MojRefCountedPtr<TestIndex> storageIndex3(new TestIndex(false));
MojAllocCheck(storageIndex3.get());
TestIndex& ti3 = *storageIndex3;
MojObject prop3;
err = prop3.putString(MojDbIndex::NameKey, _T("bar"));
MojTestErrCheck(err);
err = index3.addProp(prop3);
MojTestErrCheck(err);
err = prop3.putString(MojDbIndex::NameKey, _T("foo"));
MojTestErrCheck(err);
err = prop3.putInt(MojDbIndex::DefaultKey, 100);
MojTestErrCheck(err);
err = index3.addProp(prop3);
MojTestErrCheck(err);
err = index3.open(storageIndex3.get(), (MojInt64) 0, req);
MojTestErrCheck(err);
err = put(index3, 1, _T("{\"bar\":1}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti3.m_putCount == 1 && ti3.m_delCount == 0 && ti3.m_set.size() == 1);
err = put(index3, 1, _T("{\"foo\":5}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti3.m_putCount == 1 && ti3.m_delCount == 0 && ti3.m_set.size() == 1);
err = put(index3, 1, _T("{\"foo\":{\"bar\":3}}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti3.m_putCount == 1 && ti3.m_delCount == 0 && ti3.m_set.size() == 1);
err = put(index3, 1, _T("{\"foo\":5, \"bar\":5}"), NULL);
MojTestErrCheck(err);
MojTestAssert(ti3.m_putCount == 2 && ti3.m_delCount == 0 && ti3.m_set.size() == 2);
err = index3.close();
MojTestErrCheck(err);
return MojErrNone;
}
MojErr OnEnabledHandler::findImLoginStateResult(MojObject& payload, MojErr err)
{
MojLogTrace(IMServiceApp::s_log);
if (err != MojErrNone) {
MojString error;
MojErrToString(err, error);
MojLogCritical(IMServiceApp::s_log, _T("findImLoginStateResult failed: error %d - %s"), err, error.data());
}
else {
// "results" in result
MojObject results;
payload.get(_T("results"), results);
// check to see if array is empty - normally it will be if this is a newly created account. There should never be more than 1 item here
if (!results.empty()){
IMServiceHandler::logMojObjectJsonString(_T("findImLoginStateResult found existing imLoginState record: %s"), payload);
// if there is a record already, make sure the account id matches.
MojObject loginState;
MojObject::ConstArrayIterator itr = results.arrayBegin();
bool foundOne = false;
while (itr != results.arrayEnd()) {
if (foundOne) {
MojLogError(IMServiceApp::s_log,
_T("findImLoginStateResult: found more than one ImLoginState with same username/serviceName - using the first one"));
break;
}
loginState = *itr;
foundOne = true;
itr++;
}
MojString accountId;
MojErr err = loginState.getRequired("accountId", accountId);
if (err) {
MojLogError(IMServiceApp::s_log, _T("findImLoginStateResult: missing accountId in loginState entry"));
}
if (0 != accountId.compare(m_accountId)) {
MojLogError(IMServiceApp::s_log, _T("findImLoginStateResult: existing loginState record does not have matching account id. accountId = %s"), accountId.data());
// delete this record
MojObject idsToDelete;
MojString dbId;
err = loginState.getRequired("_id", dbId);
if (err) {
MojLogError(IMServiceApp::s_log, _T("findImLoginStateResult: missing dbId in loginState entry"));
}
else {
idsToDelete.push(dbId);
// luna://com.palm.db/del '{"ids":[2]}'
MojLogInfo(IMServiceApp::s_log, _T("findImLoginStateResult: deleting loginState entry id: %s"), dbId.data());
err = m_dbClient.del(this->m_deleteImLoginStateSlot, idsToDelete.arrayBegin(), idsToDelete.arrayEnd());
if (err != MojErrNone) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("findImLoginStateResult: db.del() failed: error %d - %s"), err, error.data());
}
}
}
// if the account id matches, leave the old record and we are done
else return MojErrNone;
}
// no existing record found or the old one was deleted - create a new one
MojLogInfo(IMServiceApp::s_log, _T("findImLoginStateResult: no matching loginState record found for %s, %s. creating a new one"), m_username.data(), m_serviceName.data());
MojObject imLoginState;
imLoginState.putString(_T("_kind"), IM_LOGINSTATE_KIND);
imLoginState.put(_T("accountId"), m_accountId);
imLoginState.put(_T("serviceName"), m_serviceName);
imLoginState.put(_T("username"), m_username);
imLoginState.put(_T("capabilityId"), m_capabilityProviderId);
imLoginState.putString(_T("state"), LOGIN_STATE_OFFLINE);
imLoginState.putInt(_T("availability"), PalmAvailability::ONLINE); //default to online so we automatically login at first
imLoginState.put(_T("config"), m_config);
MojErr err = m_dbClient.put(m_addImLoginStateSlot, imLoginState);
if (err != MojErrNone) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("findImLoginStateResult: db.put() failed: error %d - %s"), err, error.data());
}
}
return err;
}
void PopAccountAdapter::SerializeToDatabasePopObject(const PopAccount& accnt, MojObject& obj)
{
MojErr err;
// Set the object kind
err = obj.putString(KIND, POP_ACCOUNT_KIND);
ErrorToException(err);
// Set ID
err = obj.put(ID, accnt.GetId());
ErrorToException(err);
// Set account ID
err = obj.put(ACCOUNT_ID, accnt.GetAccountId());
ErrorToException(err);
// Set host name
err = obj.putString(HOST_NAME, accnt.GetHostName().c_str());
ErrorToException(err);
// Set port
err = obj.putInt(PORT, accnt.GetPort());
ErrorToException(err);
// Set encryption
err = obj.putString(ENCRYPTION, accnt.GetEncryption().c_str());
ErrorToException(err);
// Set user name
err = obj.putString(USERNAME, accnt.GetUsername().c_str());
ErrorToException(err);
// Set 'initialSynced' flag
err = obj.putBool(INITIAL_SYNC, accnt.IsInitialSync());
ErrorToException(err);
// Set 'deleteFromServer' flag
err = obj.putBool(DELETE_FROM_SERVER, accnt.IsDeleteFromServer());
ErrorToException(err);
// Set 'deleteOnDevice' flag
err = obj.putBool(DELETE_ON_DEVICE, accnt.IsDeleteOnDevice());
ErrorToException(err);
// Set sync window
err = obj.putInt(EmailAccountAdapter::SYNC_WINDOW_DAYS, accnt.GetSyncWindowDays());
ErrorToException(err);
// Set sync frequency
err = obj.putInt(SYNC_FREQUENCY_MINS, accnt.GetSyncFrequencyMins());
ErrorToException(err);
if (accnt.IsError()) {
MojObject mojErr;
err = mojErr.putInt(EmailAccountAdapter::ERROR_CODE, (int)accnt.GetError().errorCode);
ErrorToException(err);
err = mojErr.putString(EmailAccountAdapter::ERROR_TEXT, accnt.GetError().errorText.c_str());
ErrorToException(err);
err = obj.put(EmailAccountAdapter::ERROR, mojErr);
ErrorToException(err);
} else {
err = obj.put(EmailAccountAdapter::ERROR, MojObject::Null);
}
SerializeSpecialFolders(accnt, obj);
}
void PopAccountAdapter::GetPopAccountFromPayload(MojLogger& log, const MojObject& payload, MojObject& popAccount)
{
MojErr err = popAccount.putString(KIND, POP_ACCOUNT_KIND);
ErrorToException(err);
MojObject accountId;
err = payload.getRequired(ACCOUNT_ID, accountId);
ErrorToException(err);
err = popAccount.put(ACCOUNT_ID, accountId);
ErrorToException(err);
MojObject config;
err = payload.getRequired(CONFIG, config);
ErrorToException(err);
MojObject hostname;
err = config.getRequired(HOST_NAME, hostname);
ErrorToException(err);
err = popAccount.put(HOST_NAME, hostname);
ErrorToException(err);
MojObject port;
err = config.getRequired(PORT, port);
ErrorToException(err);
err = popAccount.put(PORT, port);
ErrorToException(err);
MojObject encryption;
err = config.getRequired(ENCRYPTION, encryption);
ErrorToException(err);
err = popAccount.put(ENCRYPTION, encryption);
ErrorToException(err);
MojObject username;
err = config.getRequired(USERNAME, username);
ErrorToException(err);
err = popAccount.put(USERNAME, username);
ErrorToException(err);
// Set 'deleteFromServer' flag
bool deleteFromServer = true;
if (!config.get(DELETE_FROM_SERVER, deleteFromServer)) {
// default value is true if this field doesn't exist
deleteFromServer = true;
}
err = popAccount.putBool(DELETE_FROM_SERVER, deleteFromServer);
ErrorToException(err);
// Set 'deleteOnDevice' flag
bool deleteOnDevice = false;
if (!config.get(DELETE_ON_DEVICE, deleteOnDevice)) {
// defaul value is false if this field doesn't exist
deleteOnDevice = false;
}
err = popAccount.putBool(DELETE_ON_DEVICE, deleteOnDevice);
ErrorToException(err);
// Set sync window
MojInt64 syncWindow;
if (!config.get(EmailAccountAdapter::SYNC_WINDOW_DAYS, syncWindow)) {
// set default value if this field doesn't exist
syncWindow = PopAccount::DEFAULT_SYNC_WINDOW;
}
err = popAccount.putInt(EmailAccountAdapter::SYNC_WINDOW_DAYS, syncWindow);
ErrorToException(err);
// Set sync frequency
MojInt64 syncFreq;
if (!config.get(SYNC_FREQUENCY_MINS, syncFreq)) {
syncFreq = PopAccount::DEFAULT_SYNC_FREQUENCY_MINS;
}
err = popAccount.putInt(SYNC_FREQUENCY_MINS, syncFreq);
ErrorToException(err);
}
MojObject getProtocolOptions(MojString prpl)
{
MojObject result;
PurplePluginProtocolInfo* info = getProtocolInfo(prpl.data());
for(GList* l = info->protocol_options; l != NULL; l = l->next)
{
PurpleAccountOption* option = (PurpleAccountOption*)l->data;
MojObject node;
MojObject choices;
node.putString("text", purple_account_option_get_text(option));
switch(purple_account_option_get_type(option))
{
case PURPLE_PREF_BOOLEAN:
node.putString("type", "bool");
node.putBool("default_value",
purple_account_option_get_default_bool(option)
);
break;
case PURPLE_PREF_INT:
node.putString("type", "int");
node.putInt("default_value",
purple_account_option_get_default_int(option)
);
break;
case PURPLE_PREF_STRING:
node.putString("type", "string");
{
const char* def
= purple_account_option_get_default_string(option);
node.putString("default_value", def ? def : "");
}
break;
case PURPLE_PREF_STRING_LIST:
node.putString("type", "list");
{
MojObject choices;
for (GList* list = purple_account_option_get_list(option);
list != NULL; list = list->next)
{
PurpleKeyValuePair* kvp = (PurpleKeyValuePair*)list->data;
// XXX: Dangerous!
if (kvp->key && kvp->value)
choices.putString((const char*)kvp->value,
(const char*)kvp->key);
}
node.put("choices", choices);
const char* def
= purple_account_option_get_default_list_value(option);
node.putString("default_value", def ? def : "");
}
break;
default:
continue;
};
result.put(purple_account_option_get_setting(option), node);
}
return result;
}
