MojErr MojDbQuery::includeDeleted(bool val)
{
if (val) {
MojObject array;
MojErr err = array.push(false);
MojErrCheck(err);
err = array.push(true);
MojErrCheck(err);
// TODO: Move string constants to single location
err = where(DelKey, MojDbQuery::OpEq, array);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbPerfCreateTest::batchPutLargeArrayObj(MojDb& db, const MojChar* kindId, MojUInt64& lgArrayObjTime)
{
timespec startTime;
startTime.tv_nsec = 0;
startTime.tv_sec = 0;
timespec endTime;
endTime.tv_nsec = 0;
endTime.tv_sec = 0;
MojObject objArray;
for (MojUInt64 i = 0; i < numInsert; i++) {
MojObject obj;
MojErr err = obj.putString(MojDb::KindKey, kindId);
MojTestErrCheck(err);
err = createLargeArrayObj(obj, i);
MojTestErrCheck(err);
err = objArray.push(obj);
MojTestErrCheck(err);
}
MojObject::ArrayIterator begin;
MojErr err = objArray.arrayBegin(begin);
MojTestErrCheck(err);
MojObject::ConstArrayIterator end = objArray.arrayEnd();
clock_gettime(CLOCK_REALTIME, &startTime);
err = db.put(begin, end);
MojTestErrCheck(err);
clock_gettime(CLOCK_REALTIME, &endTime);
lgArrayObjTime += timeDiff(startTime, endTime);
totalTestTime += timeDiff(startTime, endTime);
return MojErrNone;
}
MojErr MojDb::del(const MojObject* idsBegin, const MojObject* idsEnd, MojUInt32& countOut, MojObject& arrOut, MojUInt32 flags, MojDbReqRef req)
{
MojAssert(idsBegin || idsBegin == idsEnd);
MojAssert(idsEnd >= idsBegin);
MojLogTrace(s_log);
countOut = 0;
MojErr err = beginReq(req);
MojErrCheck(err);
// do the dels
MojUInt32 count= 0;
for (const MojObject* i = idsBegin; i != idsEnd; ++i) {
MojObject foundObj;
bool found = false;
err = delImpl(*i, found, foundObj, req, flags);
MojErrCheck(err);
if (found) {
count++;
err = arrOut.push(foundObj);
MojErrCheck(err);
}
}
// commit txn
err = req->end();
MojErrCheck(err);
countOut = count;
return MojErrNone;
}
MojErr MojDbPerfCreateTest::batchPutLargeArrayObj(MojDb& db, const MojChar* kindId, MojTime& lgArrayObjTime)
{
MojTime startTime;
MojTime endTime;
MojObject objArray;
for (MojUInt64 i = 0; i < numInsert; i++) {
MojObject obj;
MojErr err = obj.putString(MojDb::KindKey, kindId);
MojTestErrCheck(err);
err = createLargeArrayObj(obj, i);
MojTestErrCheck(err);
err = objArray.push(obj);
MojTestErrCheck(err);
}
MojObject::ArrayIterator begin;
MojErr err = objArray.arrayBegin(begin);
MojTestErrCheck(err);
MojObject::ConstArrayIterator end = objArray.arrayEnd();
err = MojGetCurrentTime(startTime);
MojTestErrCheck(err);
err = db.put(begin, end);
MojTestErrCheck(err);
err = MojGetCurrentTime(endTime);
MojTestErrCheck(err);
lgArrayObjTime += (endTime - startTime);
totalTestTime += (endTime - startTime);
return MojErrNone;
}
MojErr MojDbPerfUpdateTest::updateKind(MojDb& db, const MojChar* kindId, const MojChar* kindJson, const MojChar* extraIdxJson, MojErr (MojDbPerfTest::*createFn) (MojObject&, MojUInt64))
{
// register all the kinds
MojTime time;
MojErr err = putKinds(db, time);
MojTestErrCheck(err);
// put objects using createFn
MojObject objs;
err = putObjs(db, kindId, numObjectsBeforeUpdateKind, createFn, objs);
MojTestErrCheck(err);
// add an index
MojObject kindObj;
err = kindObj.fromJson(kindJson);
MojTestErrCheck(err);
MojObject indexes;
kindObj.get(_T("indexes"), indexes);
MojTestErrCheck(err);
MojObject extraIdx;
err = extraIdx.fromJson(extraIdxJson);
MojTestErrCheck(err);
indexes.push(extraIdx);
err = kindObj.put(_T("indexes"), indexes);
MojTestErrCheck(err);
MojTime addIndexTime;
MojTime dropIndexTime;
err = timeUpdateKind(db, kindJson, kindObj, addIndexTime, dropIndexTime);
MojTestErrCheck(err);
MojUInt64 addTime = addIndexTime.microsecs();
MojUInt64 dropTime = dropIndexTime.microsecs();
err = MojPrintF("\n -------------------- \n");
MojTestErrCheck(err);
err = MojPrintF(" updating kind %s - adding index %s %llu times took: %llu microsecs\n", kindId, extraIdxJson, numUpdateKindIterations, addTime);
MojTestErrCheck(err);
err = MojPrintF(" time per add/reindex: %llu microsecs\n", (addTime) / (numUpdateKindIterations));
MojTestErrCheck(err);
err = MojPrintF(" updating kind %s - dropping index %s %llu times took: %llu microsecs\n", kindId, extraIdxJson, numUpdateKindIterations, dropTime);
MojTestErrCheck(err);
err = MojPrintF(" time per drop: %llu microsecs", (dropTime) / (numUpdateKindIterations));
MojTestErrCheck(err);
err = MojPrintF("\n\n");
MojTestErrCheck(err);
MojString buf;
err = buf.format("Updating kind %s - adding index %s %llu times,%s,%llu,%llu,%llu,\nUpdating kind %s - dropping index %s %llu times,%s,%llu,%llu,%llu,\n",
kindId, extraIdxJson, numUpdateKindIterations, kindId, addTime, addTime/numUpdateKindIterations, addTime/(1*numUpdateKindIterations),
kindId, extraIdxJson, numUpdateKindIterations, kindId, dropTime, dropTime/numUpdateKindIterations, dropTime/(1*numUpdateKindIterations));
MojTestErrCheck(err);
err = fileWrite(file, buf);
MojTestErrCheck(err);
return MojErrNone;
}
void MojoDBProxy::PopulatePurgeIds(MojObject& ids)
{
int count = PurgeBatchSize;
while (!m_oldTokens.empty()) {
boost::shared_ptr<MojoDBPersistToken> pt = m_oldTokens.front();
m_oldTokens.pop_front();
ids.push(pt->GetId());
if (--count == 0)
return;
}
}
void EmailAdapter::SerializeRecipients(const char* type, const EmailAddressListPtr& list, MojObject& recipients)
{
EmailAddressList::const_iterator it;
for(it = list->begin(); it != list->end(); ++it) {
EmailAddressPtr address = *it;
if (!address.get()) {
throw MailException("Unable to serialize email: one of recipients is null", __FILE__, __LINE__);
}
MojObject recipient;
SerializeAddress(type, address, recipient);
MojErr err = recipients.push(recipient);
ErrorToException(err);
}
}
void ResourceContainer::PushJson(MojObject& array) const
{
MojErr errs = MojErrNone;
MojObject rep(MojObject::TypeObject);
MojErr err = ToJson(rep);
MojErrAccumulate(errs, err);
err = array.push(rep);
MojErrAccumulate(errs, err);
if (errs) {
throw std::runtime_error("Unable to convert resource container to "
"JSON object");
}
}
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 EmailAdapter::SerializeParts(const EmailPartList& partsList, MojObject& partsArrayObj)
{
EmailPartList::const_iterator it;
for(it = partsList.begin(); it != partsList.end(); ++it) {
EmailPartPtr emailPart = *it;
if (!emailPart.get()) {
throw MailException("Unable to serialize email: one of the parts is null", __FILE__, __LINE__);
}
MojObject partObj;
MojErr err;
// Add part information to the part object
err = partObj.putString(Part::TYPE, GetPartTypeAsString(emailPart));
ErrorToException(err);
err = partObj.putString(Part::MIME_TYPE, emailPart->GetMimeType().c_str());
ErrorToException(err);
DatabaseAdapter::PutOptionalString(partObj, Part::PATH, emailPart->GetLocalFilePath());
DatabaseAdapter::PutOptionalString(partObj, Part::NAME, emailPart->GetDisplayName());
DatabaseAdapter::PutOptionalString(partObj, Part::CONTENT_ID, emailPart->GetContentId());
DatabaseAdapter::PutOptionalString(partObj, Part::ENCODING, emailPart->GetEncoding());
DatabaseAdapter::PutOptionalString(partObj, Part::CHARSET, emailPart->GetCharset());
DatabaseAdapter::PutOptionalString(partObj, Part::SECTION, emailPart->GetSection());
if(emailPart->GetEstimatedSize() >= 0) {
err = partObj.put(Part::ESTIMATED_SIZE, emailPart->GetEstimatedSize());
ErrorToException(err);
}
if(emailPart->GetEncodedSize() >= 0) {
err = partObj.put(Part::ENCODED_SIZE, emailPart->GetEncodedSize());
ErrorToException(err);
}
// Add to partsArrayObject
err = partsArrayObj.push(partObj);
ErrorToException(err);
}
}
MojErr SearchFolderCommand::HandleHeadersResponse()
{
CommandTraceFunction();
try {
MojErr err;
MojObject response;
MojObject results;
BOOST_FOREACH(const FetchUpdate& update, m_headersResponseParser->GetUpdates()) {
const boost::shared_ptr<ImapEmail>& email = update.email;
if (email.get() && !email->IsDeleted()) {
MojObject emailObj;
// Set folderId
email->SetFolderId(m_folderId);
ImapEmailAdapter::SerializeToDatabaseObject(*email, emailObj);
err = results.push(emailObj);
ErrorToException(err);
}
}
err = response.put("results", results);
ErrorToException(err);
if (m_searchRequest->GetServiceMessage().get()) {
m_searchRequest->GetServiceMessage()->replySuccess(response);
m_searchRequest->SetServiceMessage(NULL);
}
Done();
} CATCH_AS_FAILURE
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;
}
MojErr MojObjectTest::typeTest()
{
MojObject obj;
MojObject obj2;
MojString str1;
MojString str2;
MojHashMap<MojObject, MojObject> map;
// null
MojTestAssert(obj.type() == MojObject::TypeUndefined);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
MojErr err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("null"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
MojTestAssert(obj == obj2);
MojTestAssert(obj.compare(obj2) == 0);
err = obj.coerce(MojObject::TypeNull);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeNull);
err = obj.coerce(MojObject::TypeString);
MojTestErrCheck(err);
MojTestAssert(obj == str1);
err = obj.coerce(MojObject::TypeBool);
MojTestErrCheck(err);
MojTestAssert(obj == true);
err = obj.coerce(MojObject::TypeInt);
MojTestErrCheck(err);
MojTestAssert(obj == 1);
err = obj.coerce(MojObject::TypeDecimal);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeDecimal && obj == MojDecimal(1, 0));
err = obj.coerce(MojObject::TypeObject);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeObject);
err = obj.coerce(MojObject::TypeArray);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeArray);
// object
err = obj.put(_T("hello"), 5);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeObject);
MojTestAssert(obj.size() == 1);
MojTestAssert(!obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("{\"hello\":5}"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
obj.clear(MojObject::TypeObject);
MojTestAssert(obj.type() == MojObject::TypeObject);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("{}"));
// array
for (int i = 0; i < 1000; ++i) {
err = obj.push(i);
MojTestErrCheck(err);
}
MojTestAssert(obj.type() == MojObject::TypeArray);
MojTestAssert(obj.size() == 1000);
MojTestAssert(!obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
for (int i = 0; i < 1000; ++i) {
MojTestAssert(obj.at(i, obj2));
MojTestAssert(obj2 == i);
}
MojTestAssert(!obj.at(1000, obj2));
err = obj.setAt(1001, 1001);
MojTestErrCheck(err);
MojTestAssert(obj.size() == 1002);
MojTestAssert(obj.at(1000, obj2));
MojTestAssert(obj2.type() == MojObject::TypeUndefined);
obj.clear(MojObject::TypeArray);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("[]"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// string
err = str1.assign(_T("yo"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.type() == MojObject::TypeString);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str2);
MojTestErrCheck(err);
MojTestAssert(str1 == str2);
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
obj.clear(MojObject::TypeString);
MojTestAssert(obj.boolValue() == false);
err = str1.assign(_T("12345"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345);
MojTestAssert(obj.decimalValue() == MojDecimal(12345, 0));
err = str1.assign(_T("-67890"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == -67890);
MojTestAssert(obj.decimalValue() == MojDecimal(-67890, 0));
err = str1.assign(_T("12345000000000"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345000000000LL);
err = str1.assign(_T("12345.6789"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345);
MojTestAssert(obj.decimalValue() == MojDecimal(12345, 678900));
err = str1.assign(_T("1.0e3"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 1);
MojTestAssert(obj.decimalValue() == MojDecimal(1000, 0));
err = str1.assign(_T("45hello"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 45);
MojTestAssert(obj.decimalValue() == MojDecimal(45, 0));
// bool
obj = true;
MojTestAssert(obj.type() == MojObject::TypeBool);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 1);
MojTestAssert(obj.decimalValue() == MojDecimal(1, 0));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("true"));
obj.clear(MojObject::TypeBool);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("false"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// MojDecimal
obj = MojDecimal(3, 140000);
MojTestAssert(obj.type() == MojObject::TypeDecimal);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 3);
MojTestAssert(obj.decimalValue() == MojDecimal(3.14));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("3.14"));
obj.clear(MojObject::TypeDecimal);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("0.0"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// MojDecimal
obj = -987654321;
MojTestAssert(obj.type() == MojObject::TypeInt);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == -987654321);
MojTestAssert(obj.decimalValue() == MojDecimal(-987654321, 0));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("-987654321"));
obj.clear(MojObject::TypeInt);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("0"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
return MojErrNone;
}
MojErr MojDbSearchTest::simpleTest(MojDb& db)
{
// just foo
MojErr err = check(db, _T("bogus"), _T("[]"));
MojTestErrCheck(err);
err = check(db, _T("f"), _T("[1,2,3,4]"));
MojTestErrCheck(err);
err = check(db, _T("F"), _T("[1,2,3,4]"));
MojTestErrCheck(err);
err = check(db, _T("fo"), _T("[1,2,3,4]"));
MojTestErrCheck(err);
err = check(db, _T("four"), _T("[1,3,4]"));
MojTestErrCheck(err);
err = check(db, _T("score"), _T("[1]"));
MojTestErrCheck(err);
err = check(db, _T("four years"), _T("[1]"));
MojTestErrCheck(err);
err = check(db, _T("Four Years"), _T("[1]"));
MojTestErrCheck(err);
err = check(db, _T("four decades"), _T("[]"));
MojTestErrCheck(err);
err = check(db, _T("fathers forth"), _T("[2,3]"));
MojTestErrCheck(err);
err = check(db, _T("four f"), _T("[1,3,4]"));
MojTestErrCheck(err);
err = check(db, _T("four f fo fou"), _T("[1,3,4]"));
MojTestErrCheck(err);
// bar and foo
err = check(db, _T("f"), _T("[3]"), NULL, 2);
MojTestErrCheck(err);
// order by bar
err = check(db, _T("f"), _T("[4,3,2,1]"), _T("bar"));
MojTestErrCheck(err);
err = check(db, _T("f"), _T("[1,2,3,4]"), _T("bar"), MojObject::Undefined, true);
MojTestErrCheck(err);
err = check(db, _T("f"), _T("[4,3,1,2]"), _T("foo"));
MojTestErrCheck(err);
// array value for bar
MojObject array;
err = array.push(1);
MojErrCheck(err);
err = array.push(2);
MojErrCheck(err);
err = check(db, _T("f"), _T("[4,3]"), _T("bar"), array);
MojTestErrCheck(err);
// limit
MojDbQuery query;
err = initQuery(query, _T("f"));
MojTestErrCheck(err);
query.limit(2);
err = check(db, query, _T("[1,2]"));
MojTestErrCheck(err);
err = initQuery(query, _T("f"), _T("bar"));
MojTestErrCheck(err);
query.limit(2);
err = check(db, query, _T("[4,3]"));
MojTestErrCheck(err);
// accent insensitivity
err = check(db, _T("COTE"), _T("[5,6,7,8,9]"));
MojTestErrCheck(err);
// case-insensitive ordering
err = check(db, _T("a"), _T("[12,13,11]"), _T("foo"));
MojTestErrCheck(err);
// multi-prop
query.clear();
err = query.from(_T("SearchTest:1"));
MojTestErrCheck(err);
MojString val;
err = val.assign(_T("test"));
MojTestErrCheck(err);
err = query.where(_T("multiprop"), MojDbQuery::OpSearch, val, MojDbCollationPrimary);
MojTestErrCheck(err);
err = check(db, query, _T("[14,15]"));
MojTestErrCheck(err);
return MojErrNone;
}
void SyncStateUpdater::UpdateSyncState(MojSignal<>::SlotRef slot, const SyncState& syncState, bool clearSyncState)
{
m_doneSignal.connect(slot);
MojErr err;
MojObject batchPayload;
MojObject batchOperations;
// Delete old sync state
MojObject delPayload;
MojDbQuery query;
err = query.from(SyncStateAdapter::SYNC_STATE_KIND);
ErrorToException(err);
MojString capabilityProvider;
capabilityProvider.assign(m_capabilityProvider.c_str());
err = query.where(SyncStateAdapter::CAPABILITY_PROVIDER, MojDbQuery::OpEq, capabilityProvider);
ErrorToException(err);
err = query.where(SyncStateAdapter::ACCOUNT_ID, MojDbQuery::OpEq, syncState.GetAccountId());
ErrorToException(err);
err = query.where(SyncStateAdapter::COLLECTION_ID, MojDbQuery::OpEq, syncState.GetCollectionId());
ErrorToException(err);
MojObject queryObj;
err = query.toObject(queryObj);
ErrorToException(err);
err = delPayload.put("query", queryObj);
ErrorToException(err);
MojObject delOperation;
err = delOperation.putString("method", "del");
ErrorToException(err);
err = delOperation.put("params", delPayload);
ErrorToException(err);
err = batchOperations.push(delOperation);
ErrorToException(err);
if(!clearSyncState) { // Store new sync state
MojObject putPayload;
MojObject syncStateObj;
SyncStateAdapter::SerializeToDatabaseObject(syncState, syncStateObj, m_capabilityProvider.c_str(), m_busAddress.c_str());
MojObject objects;
err = objects.push(syncStateObj);
ErrorToException(err);
err = putPayload.put("objects", objects);
ErrorToException(err);
MojObject putOperation;
err = putOperation.putString("method", "put");
ErrorToException(err);
err = putOperation.put("params", putPayload);
ErrorToException(err);
err = batchOperations.push(putOperation);
ErrorToException(err);
}
err = batchPayload.put("operations", batchOperations);
ErrorToException(err);
// Note: batch operations are not atomic, this is just for convenience and performance
m_busClient.SendRequest(m_updateSlot, "com.palm.tempdb", "batch", batchPayload);
}
/*
* Send one IMCommand that has handler set to transport
*
* errors returned up to OutgoingIMCommandHandler
*
*
* @param imCmd - imCommand that was read out of the DB with handler set to transport
{
"id" : "ImCommand",
"type" : "object",
"properties" : {
"command" : {"type" : "string",
"enum" : ["blockBuddy","deleteBuddy","sendBuddyInvite","receivedBuddyInvite","createChatGroup","inviteToGroup","leaveGroup"],
"description" : "The command to be processed"},
"params" : {"type" : "any",
"description" : "Parameters associated with the command are stored here."}
"handler" : {"type" : "string",
"enum" : ["transport","application"],
"description" : "Who is responsible for handling the command"},
"targetUsername" : {"type" : "string",
"description" : "The buddyname the command will act on"},
"fromUsername" : {"type" : "string",
"description" : "The username that originated the command"},
"serviceName" : {"type" : "string",
"description" : "Name of originating service (see IMAddress of contacts load library*)."}
}
* }
*/
MojErr SendOneCommandHandler::doSend(const MojObject imCmd) {
IMServiceHandler::logMojObjectJsonString(_T("send command: %s"),imCmd);
MojString command;
LibpurpleAdapter::SendResult retVal = LibpurpleAdapter::SENT;
bool found = false;
MojErr err = imCmd.get(MOJDB_COMMAND, command, found);
MojErrCheck(err);
// serviceName
err = imCmd.get(MOJDB_SERVICE_NAME, m_serviceName, found);
MojErrCheck(err);
// get the id so we can update the status in the DB after sending
err = imCmd.getRequired(MOJDB_ID, m_currentCmdDbId);
MojErrCheck(err);
// for receiving invite, the user account and remote user are reversed: targetUsername is us and the fromUsername is the remote buddy
if (0 == command.compare(_T("receivedBuddyInvite"))) {
// username of current account
err = imCmd.get(MOJDB_FROM_USER, m_buddyName, found);
MojErrCheck(err);
// buddy / remote user
err = imCmd.get(MOJODB_TARGET_USER, m_username, found);
MojErrCheck(err);
}
else {
// username of current account
err = imCmd.get(MOJDB_FROM_USER, m_username, found);
MojErrCheck(err);
// buddy / remote user
err = imCmd.get(MOJODB_TARGET_USER, m_buddyName, found);
MojErrCheck(err);
}
// which command?
if (0 == command.compare(_T("blockBuddy"))) {
retVal = blockBuddy(imCmd);
}
else if (0 == command.compare(_T("deleteBuddy"))) {
retVal = removeBuddy(imCmd);
}
else if (0 == command.compare(_T("sendBuddyInvite"))) {
retVal = inviteBuddy(imCmd);
}
else if (0 == command.compare(_T("receivedBuddyInvite"))) {
retVal = receivedBuddyInvite(imCmd);
}
else {
MojLogError(IMServiceApp::s_log, _T("doSend: unknown command %s"), command.data());
retVal = LibpurpleAdapter::SEND_FAILED;
}
// we can't just delete the command if the user is not logged on...
// need to save command in "waiting" state waiting for user to login
if (LibpurpleAdapter::USER_NOT_LOGGED_IN == retVal) {
// user not logged in - put in queued state
MojLogError(IMServiceApp::s_log, _T("doSend - can't process command - user not logged in. Waiting for connection"));
MojObject propObject;
propObject.putString(MOJDB_STATUS, IMMessage::statusStrings[WaitingForConnection]);
// id to update
propObject.putString(MOJDB_ID, m_currentCmdDbId);
// save the new fields - call merge
err = m_dbClient.merge(this->m_imSaveCommandSlot, propObject);
if (err) {
MojLogError(IMServiceApp::s_log, _T("doSend - DB merge command failed. err %d, DB id %s: "), err, m_currentCmdDbId.data() );
}
}
else {
// delete command so we don't keep processing it
// put id in an array
MojObject idsToDelete; // array
err = idsToDelete.push(m_currentCmdDbId);
// luna://com.palm.db/del '{"ids":[2]}'
IMServiceHandler::logMojObjectJsonString(_T("deleting imcommand: %s"), idsToDelete);
err = m_dbClient.del(this->m_imDeleteCommandSlot, idsToDelete.arrayBegin(), idsToDelete.arrayEnd());
if (err) {
MojLogError(IMServiceApp::s_log, _T("doSend - DB del command failed. err %d, DB id %s: "), err, m_currentCmdDbId.data() );
}
}
if (LibpurpleAdapter::SENT != retVal) {
// something went wrong - nothing more we can do
MojLogError(IMServiceApp::s_log, _T("doSend: command failed"));
m_outgoingIMHandler->messageFinished();
}
return MojErrNone;
}
