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); }