// TODO: Need to use ActivitySet for activity hanlding SmtpSyncOutboxCommand::SmtpSyncOutboxCommand(SmtpClient& client, const MojObject& accountId, const MojObject& folderId, bool force, bool clear) : SmtpCommand(client), m_client(client), m_accountId(accountId), m_folderId(folderId), m_highestRev(0), m_canAdopt(true), m_setSyncStatusSlot(this, &SmtpSyncOutboxCommand::SetSyncStatusResponse), m_clearSyncStatusSlot(this, &SmtpSyncOutboxCommand::ClearSyncStatusResponse), m_setSyncStatusSlot2(this, &SmtpSyncOutboxCommand::SetSyncStatusResponse2), m_clearSyncStatusSlot2(this, &SmtpSyncOutboxCommand::ClearSyncStatusResponse2), m_getOutboxEmailsSlot(this, &SmtpSyncOutboxCommand::GetOutboxEmailsResponse), m_sendDoneSlot(this, &SmtpSyncOutboxCommand::SendDone), m_activityUpdatedSlot(this, &SmtpSyncOutboxCommand::ActivityUpdated), m_activityErrorSlot(this, &SmtpSyncOutboxCommand::ActivityError), m_accountActivityUpdatedSlot(this, &SmtpSyncOutboxCommand::AccountActivityUpdated), m_accountActivityErrorSlot(this, &SmtpSyncOutboxCommand::AccountActivityError), m_getAccountSlot(this, &SmtpSyncOutboxCommand::GotAccount), m_temporaryError(false), m_createWatchActivitySlot(this, &SmtpSyncOutboxCommand::CreateWatchActivityResponse), m_createAccountWatchActivityResponseSlot(this, &SmtpSyncOutboxCommand::CreateAccountWatchResponse), m_findFolderSlot(this, &SmtpSyncOutboxCommand::FindOutgoingFolderResponse), m_updateRetrySlot(this, &SmtpSyncOutboxCommand::UpdateRetryResponse), m_updateErrorSlot(this, &SmtpSyncOutboxCommand::UpdateErrorResponse), m_resetErrorSlot(this, &SmtpSyncOutboxCommand::ResetErrorResponse), m_cancelled(false), m_force(force), m_clear(clear), m_networkStatus(new NetworkStatus()), m_networkActivityUpdatedSlot(this, &SmtpSyncOutboxCommand::NetworkActivityUpdated), m_networkActivityErrorSlot(this, &SmtpSyncOutboxCommand::NetworkActivityError) { MojString d; m_accountId.stringValue(d); m_outboxWatchActivityName.format(SmtpActivityFactory::OUTBOX_WATCH_ACTIVITY_FMT, d.data()); m_accountWatchActivityName.format(SmtpActivityFactory::ACCOUNT_WATCH_ACTIVITY_FMT, d.data()); #ifdef WEBOS_TARGET_MACHINE_STANDALONE MojObject cmStatus; MojErr err; err = cmStatus.put("isInternetConnectionAvailable", true); ErrorToException(err); m_networkStatus->ParseStatus(cmStatus); #endif }
MojErr AuthYahooCommand::GetYahooCookiesSlot(MojObject& response, MojErr err) { MojLogTrace(m_log); try { ResponseToException(response, err); MojObject object; err = response.getRequired("tCookie", m_tCookie); ErrorToException(err); err = response.getRequired("yCookie", m_yCookie); ErrorToException(err); } catch (const std::exception& e) { MojLogInfo(m_log, "Failed to retrieve Yahoo cookies, failing login: %s", e.what()); // FIXME: We should possibly try to decode and pass along a specific error SmtpSession::SmtpError error; error.errorCode = MailError::ACCOUNT_UNAVAILABLE; error.errorOnAccount = true; error.internalError = std::string("Unable to retrieve yahoo cookies: ") + e.what(); m_session.AuthYahooFailure(error); Complete(); return MojErrNone; } catch (...) { MojLogInfo(m_log, "Failed to retrieve Yahoo cookies, failing login: unknown exception"); // FIXME: We should possibly try to decode and pass along a specific error SmtpSession::SmtpError error; error.errorCode = MailError::ACCOUNT_UNAVAILABLE; error.errorOnAccount = true; error.internalError = "Unable to retrieve yahoo cookies: unknown exception"; m_session.AuthYahooFailure(error); Complete(); return MojErrNone; } m_state = State_SendingYCookie; WriteCommand(); return MojErrNone; }
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; } MojString accountId; err = result.getRequired("_id", accountId); if (err != MojErrNone || accountId.empty()) { MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult accountId empty or error %d"), err); return err; } MojString username; err = result.getRequired("username", username); if (err != MojErrNone || username.empty()) { MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult username empty or error %d"), err); return err; } MojString serviceName; getServiceNameFromCapabilityId(serviceName); if (serviceName.empty()) { MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::getAccountInfoResult serviceName empty")); return err; } if (m_enable) { err = accountEnabled(accountId, serviceName, username); } else { err = accountDisabled(accountId, serviceName, username); } return err; }
MojoObjectJson::MojoObjectJson(const MojObject& obj) { MojErr err = obj.toJson(m_str); /* Intentially ignore err here. This is for debug output, let's not * make the problem worse... */ (void)err; }
MojErr MojDbServiceHandler::handleMerge(MojServiceMessage* msg, MojObject& payload, MojDbReq& req) { MojAssert(msg); MojLogTrace(s_log); MojErr err = MojErrNone; MojUInt32 count = 0; MojObject obj; if (payload.get(MojDbServiceDefs::ObjectsKey, obj)) { if (payload.contains(MojDbServiceDefs::QueryKey)) MojErrThrowMsg(MojErrInvalidArg, _T("db: cannot have both an objects param and a query param")); MojObject::ArrayIterator begin; bool ignoreM = false; payload.get(MojDbServiceDefs::IgnoreMissingKey, ignoreM); MojUInt32 mflags = MojDb::FlagNone; if (ignoreM) mflags = mflags | MojDb::FlagIgnoreMissing; err = obj.arrayBegin(begin); MojErrCheck(err); MojObject::ConstArrayIterator end = obj.arrayEnd(); err = m_db.merge(begin, end, mflags, req); MojErrCheck(err); err = formatPut(msg, begin, end); // TO DO: we need to drop non-existing objects MojErrCheck(err); } else if (payload.get(MojDbServiceDefs::QueryKey, obj)) { MojObject props; err = payload.getRequired(MojDbServiceDefs::PropsKey, props); MojErrCheck(err); bool ignoreM = false; if (payload.get(MojDbServiceDefs::IgnoreMissingKey, ignoreM)) MojErrThrowMsg(MojErrInvalidArg, _T("db: ignoreMissing - invalid option for merge query")); MojDbQuery query; err = query.fromObject(obj); MojErrCheck(err); MojUInt32 queryCount = 0; err = m_db.merge(query, props, queryCount, MojDb::FlagNone, req); MojErrCheck(err); count += queryCount; err = formatCount(msg, count); MojErrCheck(err); } else { MojErrThrowMsg(MojErrInvalidArg, _T("db: either objects or query param required for merge")); } return MojErrNone; }
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(); }
MojErr MojoCompareMatcher::ToJson(MojObject& rep, unsigned long flags) const { MojErr err; MojObject compare; err = compare.put(_T("key"), m_key); MojErrCheck(err); err = compare.put(_T("value"), m_value); MojErrCheck(err); err = rep.put(_T("compare"), compare); MojErrCheck(err); return MojErrNone; }
void MojoDBProxy::PreparePurgeCall() { LOG_TRACE("Entering function %s", __FUNCTION__); LOG_DEBUG("Preparing to purge batch of old Activities"); MojObject ids(MojObject::TypeArray); PopulatePurgeIds(ids); MojObject params; params.put(_T("ids"), ids); m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >( boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy> (shared_from_this()), &MojoDBProxy::ActivityPurgeComplete, m_service, "palm://com.palm.db/del", params); }
MojErr sendEcho(const MojChar* json, const MojObject& expectedResponse, const MojChar* method) { MojRefCountedPtr<EchoResponseHdlr> handler(new EchoResponseHdlr(expectedResponse, ++m_pendingResponseCount)); MojAllocCheck(handler.get()); MojRefCountedPtr<MojServiceRequest> req; MojErr err = m_service.createRequest(req); MojTestErrCheck(err); MojObject payload; err = payload.fromJson(json); MojTestErrCheck(err); err = req->send(handler->m_slot, ServiceName, method, payload); MojTestErrCheck(err); return MojErrNone; }
MojErr MojDbQuotaEngine::put(MojObject& obj, MojDbReq& req, bool putObj) { MojLogTrace(s_log); MojAssertWriteLocked(m_db->schemaLock()); // check for admin permission if (!req.admin()) { MojErrThrow(MojErrDbPermissionDenied); } // pull params out of object MojString owner; MojErr err = obj.getRequired(MojDbServiceDefs::OwnerKey, owner); MojErrCheck(err); MojInt64 size = 0; err = obj.getRequired(MojDbServiceDefs::SizeKey, size); MojErrCheck(err); // validate owner err = validateWildcard(owner, MojErrDbInvalidOwner); MojErrCheck(err); // put object if (putObj) { MojString id; err = id.format(_T("_quotas/%s"), owner.data()); MojErrCheck(err); err = obj.put(MojDb::IdKey, id); MojErrCheck(err); err = obj.putString(MojDb::KindKey, MojDbKindEngine::QuotaId); MojErrCheck(err); MojDbAdminGuard adminGuard(req); err = m_db->put(obj, MojDb::FlagForce, req); MojErrCheck(err); // defer commit of quota until txn commit MojRefCountedPtr<MojDbQuotaCommitHandler> handler(new MojDbQuotaCommitHandler(this, owner, size, req.txn())); MojAllocCheck(handler.get()); } else { err = commitQuota(owner, size); MojErrCheck(err); } return MojErrNone; }
void FileCacheClient::InsertCacheObject(ReplySignal::SlotRef slot, const char* typeName, const char* fileName, MojInt64 size, MojInt64 cost, MojInt64 lifetime) { MojErr err; MojObject payload; err = payload.putString("typeName", typeName); ErrorToException(err); err = payload.putString("fileName", fileName); ErrorToException(err); // Size must be >0 and larger than the actual content. // If the content is empty, we'll use 1 so FileCache doesn't complain. err = payload.put("size", size > 0 ? size : 1); ErrorToException(err); if(cost >= 0) { err = payload.put("cost", cost); ErrorToException(err); } if(lifetime >= 0) { err = payload.put("lifetime", lifetime); ErrorToException(err); } err = payload.put("subscribe", true); ErrorToException(err); m_busClient.SendRequest(slot, FILECACHE_SERVICE, "InsertCacheObject", payload, MojServiceRequest::Unlimited); }
MojErr PopAccountUpdateCommand::GetPasswordResponse(MojObject& response, MojErr err) { CommandTraceFunction(); try { // check the result first ErrorToException(err); MojObject credentials; err = response.getRequired("credentials", credentials); ErrorToException(err); MojString password; err = credentials.getRequired("password", password); ErrorToException(err); boost::shared_ptr<PopAccount> newPopAccount(new PopAccount()); PopAccountAdapter::GetPopAccountFromTransportObject(m_transportObj, *(newPopAccount.get())); newPopAccount->SetPassword(password.data()); boost::shared_ptr<PopAccount> oldPopAccount = m_client.GetAccount(); if (!oldPopAccount.get()) { m_callSyncFolderOnClient = true; } else if (newPopAccount->GetPort() != oldPopAccount->GetPort() || newPopAccount->GetEncryption() != oldPopAccount->GetEncryption() || newPopAccount->GetUsername() != oldPopAccount->GetUsername() || newPopAccount->GetSyncFrequencyMins() != oldPopAccount->GetSyncWindowDays() || newPopAccount->GetHostName() != oldPopAccount->GetHostName()) { m_callSyncFolderOnClient = true; } // Should be initial sync if the old account does not exist // or the old account is in initial sync state. newPopAccount->SetInitialSync(!oldPopAccount.get() || oldPopAccount->IsInitialSync()); m_client.SetAccount(newPopAccount); UpdateAccountWatchActivity(); } catch (const std::exception& ex) { Failure(ex); } catch (...) { Failure(MailException("unknown exception", __FILE__, __LINE__)); } return MojErrNone; }
MojErr MojDbKindState::delIndex(const MojChar* indexName, MojDbReq& req) { MojAssert(indexName); MojThreadGuard guard(m_lock); MojObject obj; MojRefCountedPtr<MojDbStorageItem> item; MojErr err = readIds(IndexIdsKey, req, obj, item); MojErrCheck(err); bool found = false; err = obj.del(indexName, found); MojErrCheck(err); MojAssert(found); err = writeIds(IndexIdsKey, obj, req, item); MojErrCheck(err); return MojErrNone; }
MojErr MojServiceMessage::replySuccess(MojObject& payload) { MojErr err = payload.putBool(ReturnValueKey, true); MojErrCheck(err); err = reply(payload); MojErrCheck(err); return MojErrNone; }
MojErr ControlGroup::ToJson(MojObject& rep) const { std::string path = GetRoot() + "/" + m_name; MojErr err = rep.putString(_T("path"), path.c_str()); MojErrCheck(err); return ResourceContainer::ToJson(rep); }
void DownloadListener::BuildResponse(MojObject& payload, MojInt64 bytesDownloaded, MojInt64 totalBytes) { MojErr err; err = payload.put("emailId", m_emailId); ErrorToException(err); if(!m_partId.undefined()) { err = payload.put("partId", m_partId); ErrorToException(err); } err = payload.put("bytesDownloaded", bytesDownloaded); ErrorToException(err); err = payload.put("totalBytes", totalBytes); ErrorToException(err); }
MojErr KindsModel::handleKindsList(MojObject& result, MojErr errCode) { MojString str; result.toJson(str); result.getRequired(_T("results")) return MojErrNone; }
void PopAccountUpdateCommand::GetPassword() { try { MojObject params; MojErr err = params.put("accountId", m_accountId); ErrorToException(err); err = params.putString("name", "common"); ErrorToException(err); err = m_client.CreateRequest()->send(m_getPasswordSlot, "com.palm.service.accounts","readCredentials", params); ErrorToException(err); } catch (const std::exception& ex) { Failure(ex); } catch (...) { Failure(MailException("unknown exception", __FILE__, __LINE__)); } }
MojErr MojSchemaTest::checkValid(const MojChar* schemaJson, const MojChar* instanceJson, bool expected) { MojObject schemaObj; MojErr err = schemaObj.fromJson(schemaJson); MojTestErrCheck(err); MojSchema schema; err = schema.fromObject(schemaObj); MojTestErrCheck(err); MojObject instance; err = instance.fromJson(instanceJson); MojTestErrCheck(err); MojSchema::Result res; err = schema.validate(instance, res); MojTestErrCheck(err); MojTestAssert(res.valid() == expected); return MojErrNone; }
void MojoDBProxy::PrepareConfiguratorCall() { LOG_TRACE("Entering function %s", __FUNCTION__); LOG_DEBUG("Prepared to update Activity configuration from static store"); MojObject types(MojObject::TypeArray); types.pushString(_T("activities")); MojObject params; params.put(_T("types"), types); m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >( boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy> (shared_from_this()), &MojoDBProxy::ActivityConfiguratorComplete, m_service, "palm://com.palm.configurator/run", params); }
MojErr MojDbKindState::readObj(const MojChar* key, MojObject& val, MojDbStorageDatabase* db, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageItem>& oldItem) { MojAssert(key && db); MojErr err = db->get(m_kindId, txn, false, oldItem); MojErrCheck(err); if (oldItem.get()) { // get objects MojObject obj; // TODO: this bugging ( on calling getObj) err = oldItem->toObject(obj, *m_kindEngine, false); MojErrCheck(err); obj.get(key, val); } return MojErrNone; }
MojErr MojoKeyMatcher::ToJson(MojObject& rep, unsigned long flags) const { MojErr err; err = rep.put(_T("key"), m_key); MojErrCheck(err); return MojErrNone; }
MojErr MojServiceMessage::reply(const MojObject& payload) { MojErr err = payload.visit(writer()); MojErrCheck(err); err = reply(); MojErrCheck(err); return MojErrNone; }
MojErr MojDbPutHandler::configure(const MojObject& conf, MojDbReq& req) { LOG_TRACE("Entering function %s", __FUNCTION__); MojAssertWriteLocked(m_db->schemaLock()); // built-in permissions MojObject objects; if (conf.get(m_confProp, objects)) { MojObject::ConstArrayIterator end = objects.arrayEnd(); for (MojObject::ConstArrayIterator i = objects.arrayBegin(); i != end; ++i) { MojObject perm(*i); MojErr err = put(perm, req, false); MojErrCheck(err); } } return MojErrNone; }
MojErr MojoWhereMatcher::ToJson(MojObject& rep, unsigned long flags) const { MojErr err; err = rep.put(_T("where"), m_where); MojErrCheck(err); return MojErrNone; }
MojErr MojDbIndexTest::wildcardTest() { 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.*.bar")); 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("{\"foo\":{\"bar\":1}}"), NULL); MojTestErrCheck(err); MojTestAssert(ti.m_putCount == 0 && ti.m_delCount == 0 && ti.m_set.size() == 0); err = put(index, 1, _T("{\"foo\":{\"1\":{\"bar\":1},\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"), NULL); MojTestErrCheck(err); MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 0 && ti.m_set.size() == 3); err = assertContains(ti, 1, 1); MojTestErrCheck(err); err = assertContains(ti, 1, 2); MojTestErrCheck(err); err = assertContains(ti, 1, 3); MojTestErrCheck(err); err = put(index, 1, _T("{\"foo\":{\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}"), _T("{\"foo\":{\"1\":{\"bar\":1},\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}")); MojTestErrCheck(err); MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 1 && ti.m_set.size() == 2); err = assertContains(ti, 1, 2); MojTestErrCheck(err); err = assertContains(ti, 1, 3); MojTestErrCheck(err); err = del(index, 1, _T("{\"foo\":{\"2\":{\"bar\":2},\"3\":{\"bar\":3}}}")); MojTestErrCheck(err); MojTestAssert(ti.m_putCount == 3 && ti.m_delCount == 3 && ti.m_set.size() == 0); err = index.close(); MojTestErrCheck(err); return MojErrNone; }
MojErr PowerdPowerActivity::RemoveRemotePowerActivity() { LOG_AM_TRACE("Entering function %s", __FUNCTION__); MojErr err; MojObject params; err = params.putString(_T("id"), GetRemotePowerActivityName().c_str()); MojErrCheck(err); m_call = boost::make_shared<MojoWeakPtrCall<PowerdPowerActivity> >( boost::dynamic_pointer_cast<PowerdPowerActivity, PowerActivity>( shared_from_this()), &PowerdPowerActivity::PowerUnlockedNotificationNormal, m_service, "palm://com.palm.power/com/palm/power/activityEnd", params); m_call->Call(); return MojErrNone; }
/* * Example messaging capability provider * "capabilityProviders": [{ "_id": "2+MR", "capability": "MESSAGING", "id": "com.palm.google.talk", "capabilitySubtype": "IM", "loc_name": "Google Talk", "icon": { "loc_32x32": "/usr/palm/public/accounts/com.palm.google/images/gtalk32x32.png", "loc_48x48": "/usr/palm/public/accounts/com.palm.google/images/gtalk48x48.png", "splitter": "/usr/palm/public/accounts/com.palm.google/images/gtalk_transport_splitter.png" }, "implementation": "palm://com.palm.imlibpurple/", "onEnabled": "palm://com.palm.imlibpurple/onEnabled" "serviceName":"type_aim", "dbkinds": { "immessage":"com.palm.immessage.libpurple:1", "imcommand":"com.palm.imcommand.libpurple:1" } }], */ MojErr OnEnabledHandler::getMessagingCapabilityObject(const MojObject& capabilityProviders, MojObject& messagingObj) { // iterate thru the capabilities array MojErr err = MojErrRequiredPropNotFound; MojString capability; MojObject::ConstArrayIterator itr = capabilityProviders.arrayBegin(); // This shouldn't happen, but check if there's nothing to do. while (itr != capabilityProviders.arrayEnd()) { messagingObj = *itr; err = messagingObj.getRequired("capability", capability); if (capability == "MESSAGING") { err = MojErrNone; break; } ++itr; } return err; }
MojErr MojDbPerfUpdateTest::putObjs(MojDb& db, const MojChar* kindId, MojUInt64 numInsert, MojErr (MojDbPerfTest::*createFn) (MojObject&, MojUInt64), MojObject& objs) { for (MojUInt64 i = 0; i < numInsert; i++) { MojObject obj; MojErr err = obj.putString(MojDb::KindKey, kindId); MojTestErrCheck(err); err = (*this.*createFn)(obj, i); MojTestErrCheck(err); err = db.put(obj); MojTestErrCheck(err); err = objs.push(obj); MojTestErrCheck(err); } return MojErrNone; }
void MojoDBProxy::LoadActivities() { LOG_TRACE("Entering function %s", __FUNCTION__); LOG_DEBUG("Loading persisted Activities from MojoDB"); MojObject query; query.putString(_T("from"), ActivityKind); MojObject params; params.put(_T("query"), query); m_call = boost::make_shared<MojoWeakPtrCall<MojoDBProxy> >( boost::dynamic_pointer_cast<MojoDBProxy, PersistProxy> (shared_from_this()), &MojoDBProxy::ActivityLoadResults, m_service, "palm://com.palm.db/find", params); m_call->Call(); }