void EmailAdapter::SerializeFlags(const Email& email, MojObject& flags)
{
MojErr err;
err = flags.putBool(Flags::READ, email.IsRead());
ErrorToException(err);
err = flags.putBool(Flags::REPLIED, email.IsReplied());
ErrorToException(err);
err = flags.putBool(Flags::FLAGGED, email.IsFlagged());
ErrorToException(err);
}
MojErr MojDb::delObj(const MojObject& id, const MojObject& obj, MojDbStorageItem* item, MojObject& foundObjOut, MojDbReq& req, MojUInt32 flags)
{
MojAssert(item);
MojLogTrace(s_log);
if (MojFlagGet(flags, FlagPurge)) {
// update indexes
MojTokenSet tokenSet;
// we want purge to force delete
req.fixmode(true);
MojErr err = m_kindEngine.update(NULL, &obj, req, OpDelete, tokenSet);
MojErrCheck(err);
// gross layering violation
err = req.txn()->offsetQuota(-(MojInt64) item->size());
MojErrCheck(err);
// permanently delete
bool found = false;
err = m_objDb->del(id, req.txn(), found);
MojErrCheck(err);
if (!found)
MojErrThrow(MojErrDbCorruptDatabase);
err = foundObjOut.put(IdKey, id);
MojErrCheck(err);
} else {
// set deleted flag and put if we are not purging
MojObject newObj = obj;
MojErr err = newObj.putBool(DelKey, true);
MojErrCheck(err);
err = putObj(id, newObj, &obj, item, req, OpDelete);
MojErrCheck(err);
foundObjOut = newObj;
}
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;
}
}
MojErr IntervalSchedule::ToJson(MojObject& rep, unsigned long flags) const
{
MojErr err;
if (flags & ACTIVITY_JSON_CURRENT) {
err = rep.putString(_T("nextStart"),
Scheduler::TimeToString(m_nextStart, !m_local).c_str());
MojErrCheck(err);
}
if (m_end != UNBOUNDED) {
err = rep.putString(_T("end"),
Scheduler::TimeToString(m_end, !m_local).c_str());
MojErrCheck(err);
}
if (m_skip) {
err = rep.putBool(_T("skip"), true);
MojErrCheck(err);
}
if (m_lastFinished != NEVER) {
err = rep.putString(_T("lastFinished"),
Scheduler::TimeToString(m_lastFinished, !m_local).c_str());
MojErrCheck(err);
}
err = rep.putString(_T("interval"), IntervalToString(m_interval).c_str());
MojErrCheck(err);
return Schedule::ToJson(rep, flags);
}
MojErr MojService::CategoryHandler::addMethod(const MojChar* methodName, Callback callback, bool pub, const MojChar* schemaJson)
{
MojAssert(methodName && callback);
MojString str;
MojErr err = str.assign(methodName);
MojErrCheck(err);
MojRefCountedPtr<MojSchema> schema;
if (schemaJson) {
MojObject schemaObj;
err = schemaObj.fromJson(schemaJson);
MojErrCheck(err);
// add implicit $activity property
MojObject properties;
schemaObj.get(MojSchema::PropertiesKey, properties);
MojObject activityProp;
err = activityProp.putBool(MojSchema::OptionalKey, true);
MojErrCheck(err);
err = properties.put(_T("$activity"), activityProp);
MojErrCheck(err);
err = schemaObj.put(MojSchema::PropertiesKey, properties);
MojErrCheck(err);
schema.reset(new MojSchema);
MojAllocCheck(schema.get());
err = schema->fromObject(schemaObj);
MojErrCheck(err);
}
MojAssert(!m_callbackMap.contains(str));
err = m_callbackMap.put(str, CallbackInfo(callback, schema.get(), pub));
MojErrCheck(err);
return MojErrNone;
}
MojErr
TestCategoryHandler::WhereMatchTest(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojObject response;
bool found = payload.get(_T("response"), response);
if (!found) {
throw std::runtime_error("Please provide a \"response\" and a "
"\"where\" clause to test against it");
}
MojObject where;
found = payload.get(_T("where"), where);
if (!found) {
throw std::runtime_error("Please provide a \"where\" clause to test "
"the response against");
}
MojoNewWhereMatcher matcher(where);
bool matched = matcher.Match(response);
MojObject reply;
MojErr err = reply.putBool(_T("matched"), matched);
MojErrCheck(err);
err = msg->reply(reply);
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr MojDbIndex::addBuiltinProps()
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojString idStr;
MojErr err = idStr.assign(MojDb::IdKey);
MojErrCheck(err);
if (m_propNames.find(idStr) == MojInvalidSize) {
MojObject idProp;
err = idProp.put(NameKey, idStr);
MojErrCheck(err);
err = addProp(idProp);
MojErrCheck(err);
}
if (m_includeDeleted && m_propNames.front() != MojDb::DelKey) {
MojObject delProp;
err = delProp.putString(NameKey, MojDb::DelKey);
MojErrCheck(err);
err = delProp.putBool(DefaultKey, false);
MojErrCheck(err);
err = addProp(delProp, true);
MojErrCheck(err);
MojAssert(m_propNames.front() == MojDb::DelKey);
}
m_idIndex = m_propNames.find(idStr);
MojAssert(m_idIndex != MojInvalidSize);
m_idIndex++; // account for prefix
return MojErrNone;
}
MojErr PreciseIntervalSchedule::ToJson(MojObject& rep,
unsigned long flags) const
{
MojErr err = rep.putBool(_T("precise"), true);
MojErrCheck(err);
return IntervalSchedule::ToJson(rep, flags);
}
MojErr formatEchoResponse(const MojChar* str, MojObject& respOut)
{
MojErr err = respOut.putBool(MojServiceMessage::ReturnValueKey, true);
MojTestErrCheck(err);
err = respOut.putString(_T("echo"), str);
MojTestErrCheck(err);
return MojErrNone;
}
MojErr MojServiceMessage::replySuccess(MojObject& payload)
{
MojErr err = payload.putBool(ReturnValueKey, true);
MojErrCheck(err);
err = reply(payload);
MojErrCheck(err);
return MojErrNone;
}
MojErr Schedule::ToJson(MojObject& rep, unsigned long flags) const
{
MojErr err;
if (flags & ACTIVITY_JSON_CURRENT) {
err = rep.putBool(_T("scheduled"), m_scheduled);
MojErrCheck(err);
}
if (m_local) {
err = rep.putBool(_T("local"), m_local);
MojErrCheck(err);
}
if (m_start != DAY_ONE) {
err = rep.putString(_T("start"),
Scheduler::TimeToString(m_start, !m_local).c_str());
MojErrCheck(err);
}
return MojErrNone;
}
MojErr PopBusDispatcher::ReplyToPing(MojServiceMessage* msg)
{
MojLogTrace(s_log);
MojObject reply;
MojErr err = reply.putBool(MojServiceMessage::ReturnValueKey, true);
ErrorToException(err);
err = reply.putString(_T("response"), _T("pong"));
ErrorToException(err);
err = msg->reply(reply);
ErrorToException(err);
return MojErrNone;
}
MojErr ConnectionState::ConnectionChangedScheduler::scheduleActivity()
{
MojLogInfo(IMServiceApp::s_log, _T("com.palm.activitymanager/create \"IMLibpurple Connect Changed\""));
MojRefCountedPtr<MojServiceRequest> req;
MojErr err = m_service->createRequest(req);
if (err != MojErrNone)
{
MojLogError(IMServiceApp::s_log, _T("ConnectionChangedScheduler createRequest failed for connect debounce. error %d"), err);
}
else
{
// Schedule an activity to callback after a few seconds. The activity may already exist
MojObject activity;
const MojChar* activityJSON = _T("{\"name\":\"IMLibpurple Connect Changed\"," \
"\"description\":\"Scheduled callback to check the current connection status\"," \
"\"type\":{\"foreground\":true}}");
activity.fromJson(activityJSON);
// activity.schedule
time_t targetDate;
time(&targetDate);
targetDate += 10; // 10 seconds in the future
tm* ptm = gmtime(&targetDate);
char scheduleTime[50];
sprintf(scheduleTime, "%d-%02d-%02d %02d:%02d:%02dZ", ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
MojObject scheduleObj;
scheduleObj.putString("start", scheduleTime);
activity.put("schedule", scheduleObj);
MojObject params;
params.putBool("start", true);
params.putBool("subscribe", true);
params.put("activity", activity);
err = req->send(m_scheduleActivitySlot, "com.palm.activitymanager", "create", params, MojServiceRequest::Unlimited);
}
return err;
}
void MojoDatabase::UpdateAccountInitialSync(Signal::SlotRef slot, const MojObject& accountId, bool sync)
{
//MojLogInfo(PopClient::s_log, "Updating account '%s' initialSynced to %d", AsJsonString(accountId).c_str(), sync);
MojObject account;
MojErr err = account.putBool(PopAccountAdapter::INITIAL_SYNC, sync);
ErrorToException(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 ConnectionManagerProxy::Enable()
{
LOG_TRACE("Entering function %s", __FUNCTION__);
LOG_DEBUG("Enabling Connection Manager Proxy");
MojObject params;
params.putBool(_T("subscribe"), true);
m_call = boost::make_shared<MojoWeakPtrCall<ConnectionManagerProxy> >(
boost::dynamic_pointer_cast<ConnectionManagerProxy, RequirementManager>
(shared_from_this()),
&ConnectionManagerProxy::ConnectionManagerUpdate, m_service,
"luna://com.palm.connectionmanager/getstatus", params,
MojoCall::Unlimited);
m_call->Call();
}
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 echo(MojServiceMessage* msg, const MojObject& payload)
{
MojString echoStr;
MojErr err = payload.toJson(echoStr);
MojTestErrCheck(err);
MojObject response;
err = response.putBool(MojServiceMessage::ReturnValueKey, true);
MojTestErrCheck(err);
err = response.putString(_T("echo"), echoStr);
MojTestErrCheck(err);
err = msg->reply(response);
MojTestErrCheck(err);
return MojErrNone;
}
MojErr Response(MojObject& response, MojErr err)
{
bool success = true;
bool getSuccess = response.get("returnValue", success);
if (err || !getSuccess || !success) {
// unfortunately file cache doesn't use regular C++ mojo error codes
// & more unfortunately all the various failure reasons for define are hidden
// behind 1 error code
MojInt64 errorCode;
if (response.get("errorCode", errorCode)) {
FileCacheFailure failure = (FileCacheFailure)errorCode;
// be generous in the error code that can be used
if (failure == FCDefineError || failure == FCExistsError) {
MojString mojErrorText;
string errorText;
std::string nakOkSuffix = "' already exists.";
response.getRequired("errorText", mojErrorText);
errorText = mojErrorText.data();
if (endsWith(errorText, nakOkSuffix)) {
LOG_DEBUG("caching negative response for %s", m_config.c_str());
bool found = false;
response.del("errorCode", found);
response.del("errorText", found);
err = response.putBool("returnValue", true);
MarkConfigured();
} else {
LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 2,
PMLOGKS("error", errorText.c_str()),
PMLOGKS("suffix", nakOkSuffix.c_str()),
"File cache failed to register type (`%s' doesn't end with `%s'", errorText.c_str(), nakOkSuffix.c_str());
}
} else {
LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 1,
PMLOGKFV("error", "%d", (int)errorCode),
"Unrecognized errorCode %d", (int)errorCode);
}
} else {
LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 0, "errorCode not provided in request failure");
}
} else {
LOG_DEBUG("FileCacheConfigurator response for %s contained no problems", m_config.c_str());
}
return DelegateResponse(response, err);
}
void TelephonyProxy::Enable()
{
LOG_TRACE("Entering function %s", __FUNCTION__);
LOG_DEBUG("Enabling TIL Proxy");
MojObject params;
params.putBool(_T("subscribe"), true);
// Start out with a platformQuery
m_platformQuery = boost::make_shared<MojoWeakPtrCall<TelephonyProxy> >(
boost::dynamic_pointer_cast<TelephonyProxy, RequirementManager>
(shared_from_this()),
&TelephonyProxy::PlatformQueryUpdate, m_service,
"palm://com.palm.telephony/platformQuery", params,
MojoCall::Unlimited);
m_platformQuery->Call();
}
void PowerdScheduler::UpdateTimeout(time_t nextWakeup, time_t curTime)
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Updating powerd scheduling callback - nextWakeup %llu, current time %llu",
(unsigned long long)nextWakeup, (unsigned long long)curTime);
MojErr err;
MojErr errs = MojErrNone;
MojObject params;
params.putBool("wakeup", true);
char formattedTime[32];
FormatWakeupTime(nextWakeup, formattedTime, sizeof(formattedTime));
err = params.putString(_T("at"), formattedTime);
MojErrAccumulate(errs, err);
err = params.putString(_T("key"), PowerdWakeupKey);
MojErrAccumulate(errs, err);
err = params.putString(_T("uri"),
"palm://com.palm.activitymanager/callback/scheduledwakeup");
MojErrAccumulate(errs, err);
MojObject cbParams(MojObject::TypeObject);
err = params.put(_T("params"), cbParams);
MojErrAccumulate(errs, err);
if (errs) {
LOG_AM_ERROR(MSGID_SET_TIMEOUT_PARAM_ERR,0,
"Error constructing parameters for powerd set timeout call");
throw std::runtime_error("Error constructing parameters for "
"powerd set timeout call");
}
m_call = boost::make_shared<MojoWeakPtrCall<PowerdScheduler> >(
boost::dynamic_pointer_cast<PowerdScheduler, Scheduler>(
shared_from_this()), &PowerdScheduler::HandleTimeoutSetResponse,
m_service, "palm://com.palm.power/timeout/set", params);
m_call->Call();
}
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;
}
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);
}
void PowerdScheduler::MonitorSystemTime()
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Subscribing to System Time change notifications");
MojObject params;
MojErr err = params.putBool(_T("subscribe"), true);
if (err) {
LOG_AM_ERROR(MSGID_GET_SYSTIME_PARAM_ERR,0,
"Error constructing parameters for subscription to System Time Service");
throw std::runtime_error("Error constructing parameters for "
"subscription to System Time Service");
}
m_systemTimeCall = boost::make_shared<MojoWeakPtrCall<PowerdScheduler> >(
boost::dynamic_pointer_cast<PowerdScheduler, Scheduler>(
shared_from_this()), &PowerdScheduler::HandleSystemTimeResponse,
m_service, "palm://com.palm.systemservice/time/getSystemTime", params,
MojoCall::Unlimited);
m_systemTimeCall->Call();
}
MojErr ResourceContainer::ToJson(MojObject& rep) const
{
MojErr err = rep.putString(_T("name"), m_name.c_str());
MojErrCheck(err);
err = rep.putString(_T("priority"), ActivityPriorityNames[GetPriority()]);
MojErrCheck(err);
err = rep.putBool(_T("focused"), IsFocused());
MojErrCheck(err);
MojObject entities(MojObject::TypeArray);
std::for_each(m_entities.begin(), m_entities.end(),
boost::bind(&BusEntity::PushJson, _1, boost::ref(entities), false));
err = rep.put(_T("entities"), entities);
MojErrCheck(err);
return MojErrNone;
}
MojErr PopBusDispatcher::Status(MojServiceMessage* msg, MojObject& payload)
{
MojErr err;
MojObject status;
try {
if(m_tasks->GetActiveCommandCount() > 0 || m_tasks->GetActiveCommandCount()) {
MojObject tasksStatus;
err = tasksStatus.putBool(MojServiceMessage::ReturnValueKey, true);
m_tasks->Status(tasksStatus);
err = status.put("tasks", tasksStatus);
ErrorToException(err);
}
MojObject clients(MojObject::TypeArray);
ClientMap::const_iterator it;
for(it = m_clients.begin(); it != m_clients.end(); ++it) {
MojObject clientStatus;
it->second->Status(clientStatus);
err = clients.push(clientStatus);
ErrorToException(err);
}
err = status.put("clients", clients);
ErrorToException(err);
msg->replySuccess(status);
} catch(const std::exception& e) {
msg->replyError(MojErrInternal, e.what());
} catch(...) {
msg->replyError(MojErrInternal);
}
return MojErrNone;
}
MojErr SaveEmailCommand::PutDone(MojObject &response, MojErr err)
{
try {
ResponseToException(response, err);
MojObject results;
err = response.getRequired("results", results);
ErrorToException(err);
MojObject put;
results.at(0, put);
MojObject emailId;
err = put.getRequired("id", emailId);
ErrorToException(err);
// create response that contains emailId
MojObject response;
err = response.putBool(MojServiceMessage::ReturnValueKey, true);
ErrorToException(err);
err = response.put(DatabaseAdapter::ID, emailId);
ErrorToException(err);
err = m_message->reply(response);
ErrorToException(err);
m_client.CommandComplete(this);
} catch(const std::exception& e) {
Error(e);
} catch(...) {
Error( MailException("unknown", __FILE__, __LINE__) );
}
return MojErrNone;
}
MojErr Response(MojObject& response, MojErr err)
{
bool success = true;
response.get("returnValue", success);
if (err || !success) {
MojInt64 errorCode;
if (response.get("errorCode", errorCode)) {
if (errorCode == MojErrExists) {
MojLogInfo(Logger(), "caching ok negative response for %s", m_config.c_str());
bool found = false;
response.del("errorCode", found);
response.del("errorText", found);
err = response.putBool("returnValue", true);
MarkConfigured();
} else {
MojLogWarning(Logger(), "Unrecognized errorCode %d", (int)errorCode);
}
} else {
MojLogWarning(Logger(), "errorCode not provided in request failure");
}
}
return DelegateResponse(response, 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;
}
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);
}
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);
}
