MojErr MojDbPropExtractor::fromObjectImpl(const MojObject& obj, const MojDbPropExtractor& defaultConfig, const MojChar* locale)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
// super
MojErr err = MojDbExtractor::fromObject(obj, locale);
MojErrCheck(err);
// default value
m_default = defaultConfig.m_default;
MojObject defaultVal;
if (obj.get(DefaultKey, defaultVal)) {
MojObject::Type type = defaultVal.type();
MojDbKey key;
if (type == MojObject::TypeArray) {
// if the value is an array, act on its elements rather than the array object itself
MojObject::ConstArrayIterator end = defaultVal.arrayEnd();
for (MojObject::ConstArrayIterator j = defaultVal.arrayBegin(); j != end; ++j) {
err = key.assign(*j);
MojErrCheck(err);
err = m_default.put(key);
MojErrCheck(err);
}
} else {
err = key.assign(defaultVal);
MojErrCheck(err);
err = m_default.put(key);
MojErrCheck(err);
}
}
// tokenizer
m_tokenizer = defaultConfig.m_tokenizer;
MojString tokenize;
bool found = false;
err = obj.get(TokenizeKey, tokenize, found);
MojErrCheck(err);
if (found) {
if (tokenize == AllKey || tokenize == DefaultKey) {
m_tokenizer.reset(new MojDbTextTokenizer);
MojAllocCheck(m_tokenizer.get());
err = m_tokenizer->init(locale);
MojErrCheck(err);
} else {
MojErrThrow(MojErrDbInvalidTokenization);
}
}
// collator
if (m_collation == MojDbCollationInvalid)
m_collation = defaultConfig.m_collation;
err = updateLocale(locale);
MojErrCheck(err);
// set prop
err = prop(m_name);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbMultiExtractor::fromObject(const MojObject& obj, const MojChar* locale)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojErr err = MojDbExtractor::fromObject(obj, locale);
MojErrCheck(err);
// load the default config
MojDbPropExtractor defaultExtractor;
err = defaultExtractor.fromObject(obj, locale);
MojErrCheck(err);
MojObject include;
err = obj.getRequired(IncludeKey, include);
MojErrCheck(err);
for (MojObject::ConstArrayIterator i = include.arrayBegin();
i != include.arrayEnd(); ++i) {
MojString includeName;
err = i->stringValue(includeName);
MojErrCheck(err);
MojRefCountedPtr<MojDbPropExtractor> propExtractor(new MojDbPropExtractor);
MojAllocCheck(propExtractor.get());
err = propExtractor->fromObjectImpl(*i, defaultExtractor, locale);
MojErrCheck(err);
err = m_extractors.push(propExtractor);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbKind::configureRevSets(const MojObject& obj)
{
MojLogTrace(s_log);
m_revSets.clear();
MojSet<MojString> setNames;
MojObject array;
if (obj.get(RevisionSetsKey, array)) {
MojObject::ConstArrayIterator end = array.arrayEnd();
for (MojObject::ConstArrayIterator i = array.arrayBegin(); i != end; ++i) {
MojRefCountedPtr<MojDbRevisionSet> set(new MojDbRevisionSet());
MojAllocCheck(set.get());
MojErr err = set->fromObject(*i);
MojErrCheck(err);
if (setNames.contains(set->name())) {
MojErrThrowMsg(MojErrDbInvalidRevisionSet, _T("db: cannot repeat revSet name: '%s'"), set->name().data());
}
err = setNames.put(set->name());
MojErrCheck(err);
err = m_revSets.push(set);
MojErrCheck(err);
}
}
return MojErrNone;
}
static MojErr getTypes(MojObject typesArray, BusClient::ScanTypes &bitmask)
{
MojObject::ConstArrayIterator it = typesArray.arrayBegin();
if (it == NULL)
MojErrThrowMsg(MojErrInvalidMsg, "'types' not an array");
for (MojObject::ConstArrayIterator ni = typesArray.arrayEnd(); it != ni; it++) {
const MojObject& element = *it;
MojString type;
MojErr err;
err = element.stringValue(type);
MojErrCheck(err);
if (type == "dbkinds")
bitmask |= BusClient::DBKINDS;
else if (type == "dbpermissions")
bitmask |= BusClient::DBPERMISSIONS;
else if (type == "filecache")
bitmask |= BusClient::FILECACHE;
else if (type == "activities")
bitmask |= BusClient::ACTIVITIES;
else
MojErrThrowMsg(MojErrInvalidMsg, "unrecognized type '%s'", type.data());
}
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 MojDbServiceHandler::handleGet(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
MojObject ids;
MojErr err = payload.getRequired(MojDbServiceDefs::IdsKey, ids);
MojErrCheck(err);
MojObjectVisitor& writer = msg->writer();
err = writer.beginObject();
MojErrCheck(err);
err = writer.boolProp(MojServiceMessage::ReturnValueKey, true);
MojErrCheck(err);
err = writer.propName(MojDbServiceDefs::ResultsKey);
MojErrCheck(err);
err = writer.beginArray();
MojErrCheck(err);
err = m_db.get(ids.arrayBegin(), ids.arrayEnd(), writer, req);
MojErrCheck(err);
err = writer.endArray();
MojErrCheck(err);
err = writer.endObject();
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbTextTokenizerTest::check(const MojChar* text, const MojChar* tokens)
{
// tokenize string
MojString textStr;
MojErr err = textStr.assign(text);
MojTestErrCheck(err);
MojSet<MojDbKey> set;
MojRefCountedPtr<MojDbTextTokenizer> tokenizer(new MojDbTextTokenizer);
MojAllocCheck(tokenizer.get());
err = tokenizer->init(_T("en_US"));
MojTestErrCheck(err);
err = tokenizer->tokenize(textStr, NULL, set);
MojTestErrCheck(err);
// check that tokens match
MojObject obj;
err = obj.fromJson(tokens);
MojTestErrCheck(err);
MojSize objSize = obj.size();
MojSize setSize = set.size();
MojTestAssert(objSize == setSize);
for (MojObject::ConstArrayIterator i = obj.arrayBegin(); i != obj.arrayEnd(); ++i) {
MojDbKey key;
err = key.assign(*i);
MojTestErrCheck(err);
MojTestAssert(set.contains(key));
}
return MojErrNone;
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckMatches(
const MojObject& rhsArray, const MojObject& op, const MojObject& val,
MatchMode mode) const
{
/* Matching a value against an array */
for (MojObject::ConstArrayIterator iter = rhsArray.arrayBegin();
iter != rhsArray.arrayEnd(); ++iter) {
MatchResult result = CheckMatch(*iter, op, val);
if (mode == AndMode) {
if (result != Matched) {
return NotMatched;
}
} else {
if (result == Matched) {
return Matched;
}
}
}
/* If we got here in And mode it means all the values matched. If we
* got here in Or mode, it means none of them did. */
if (mode == AndMode) {
return Matched;
} else {
return NotMatched;
}
}
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;
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckProperty(
const MojObject& key, const MojObject& response, const MojObject& op,
const MojObject& val, MatchMode mode) const
{
if (key.type() == MojObject::TypeString) {
MojString keyStr;
MojErr err = key.stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to convert property lookup key "
"to string");
}
MojObject propVal;
bool found = response.get(keyStr.data(), propVal);
if (!found) {
return NoProperty;
}
return CheckMatch(propVal, op, val);
} else if (key.type() == MojObject::TypeArray) {
return CheckProperty(key, key.arrayBegin(), response, op, val, mode);
} else {
throw std::runtime_error("Key specified was neither a string or "
"array of strings");
}
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckProperty(
const MojObject& keyArray, MojObject::ConstArrayIterator keyIter,
const MojObject& response, const MojObject& op, const MojObject& val,
MatchMode mode) const
{
MojObject onion = response;
for (; keyIter != keyArray.arrayEnd(); ++keyIter) {
if (onion.type() == MojObject::TypeArray) {
return CheckProperty(keyArray, keyIter, onion, onion.arrayBegin(),
op, val, mode);
} else if (onion.type() == MojObject::TypeObject) {
MojString keyStr;
MojErr err = (*keyIter).stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to convert property lookup "
"key to string");
}
MojObject next;
if (!onion.get(keyStr.data(), next)) {
return NoProperty;
}
onion = next;
} else {
return NoProperty;
}
}
return CheckMatch(onion, op, val);
}
void EmailAdapter::ParseRecipients(const MojObject& recipients, Email& email)
{
MojErr err;
EmailAddressListPtr to_list(new EmailAddressList);
EmailAddressListPtr cc_list(new EmailAddressList);
EmailAddressListPtr bcc_list(new EmailAddressList);
MojObject::ConstArrayIterator it = recipients.arrayBegin();
for (; it != recipients.arrayEnd(); ++it) {
const MojObject& recipient = *it;
MojString type;
err = recipient.getRequired(Part::TYPE, type);
ErrorToException(err);
EmailAddressPtr addr = ParseAddress(recipient);
if(type.compareCaseless("to") == 0)
to_list->push_back(addr);
else if(type.compareCaseless("cc") == 0)
cc_list->push_back(addr);
else if(type.compareCaseless("bcc") == 0)
bcc_list->push_back(addr);
else // not a valid recipient type
throw MailException("invalid recipient type", __FILE__, __LINE__);
}
email.SetTo(to_list);
email.SetCc(cc_list);
email.SetBcc(bcc_list);
}
MojErr OnEnabledHandler::getAccountConfigResult(MojObject& payload, MojErr err)
{
MojLogTrace(IMServiceApp::s_log);
if (err != MojErrNone) {
MojString error;
MojErrToString(err, error);
MojLogCritical(IMServiceApp::s_log, "getAccountConfig failed: error %d - %s", err, error.data());
}
else
{
MojObject results;
payload.get("results", results);
if (!results.empty())
{
m_config = *results.arrayBegin();
}
}
if (m_enable) {
err = accountEnabled();
} else {
err = accountDisabled();
}
return err;
}
MojErr MojDbPerfUpdateTest::updateObjsViaPut(MojDb& db, const MojChar* kindId, 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, numInsertForPut, createFn, objs);
MojTestErrCheck(err);
MojObject midObj;
bool found = objs.at(numInsertForPut/2, midObj);
MojTestAssert(found);
MojTime objTime;
err = putObj(db, midObj, objTime);
MojTestErrCheck(err);
MojUInt64 putTime = objTime.microsecs();
err = MojPrintF("\n -------------------- \n");
MojTestErrCheck(err);
err = MojPrintF(" putting single object - index %llu - of kind %s %llu times took: %llu microsecs\n", numInsertForPut/2, kindId, numPutIterations, putTime);
MojTestErrCheck(err);
err = MojPrintF(" time per put: %llu microsecs", (putTime) / (numPutIterations));
MojTestErrCheck(err);
err = MojPrintF("\n\n");
MojTestErrCheck(err);
MojString buf;
err = buf.format("Put single object - index %llu - %llu times,%s,%llu,%llu,%llu,\n", numInsertForPut/2, numPutIterations, kindId, putTime, putTime/numPutIterations, putTime/(1*numPutIterations));
MojTestErrCheck(err);
err = fileWrite(file, buf);
MojTestErrCheck(err);
MojTime batchTime;
MojObject::ArrayIterator beginArr;
err = objs.arrayBegin(beginArr);
MojErrCheck(err);
err = batchPutObj(db, beginArr, beginArr + (numInsertForPut / 10), batchTime);
putTime = batchTime.microsecs();
MojTestErrCheck(err);
err = MojPrintF(" putting batch - %llu objects - of kind %s %llu times took: %llu microsecs\n", numInsertForPut/10, kindId, numBatchPutIterations, putTime);
MojTestErrCheck(err);
err = MojPrintF(" time per batch put: %llu microsecs\n", (putTime) / (numBatchPutIterations));
MojTestErrCheck(err);
err = MojPrintF(" time per object: %llu microsecs", (putTime) / (numInsertForPut/10 * numBatchPutIterations));
MojTestErrCheck(err);
err = MojPrintF("\n\n");
MojTestErrCheck(err);
err = buf.format("Batch put %llu objects %llu times,%s,%llu,%llu,%llu,\n", numInsertForPut/10, numBatchPutIterations, kindId, putTime, putTime/numBatchPutIterations, putTime/(numInsertForPut/10*numBatchPutIterations));
MojTestErrCheck(err);
err = fileWrite(file, buf);
MojTestErrCheck(err);
return MojErrNone;
}
MojErr BusClient::BusMethods::ScanRequest(MojServiceMessage* msg, MojObject& payload, ConfigurationMode confmode)
{
try {
MojErr err;
if (payload.type() != MojObject::TypeArray) {
MojErrThrowMsg(MojErrInternal, "invalid message format");
}
m_client.m_msg.reset(msg);
for (MojObject::ConstArrayIterator it = payload.arrayBegin(); it != payload.arrayEnd(); it++) {
const MojObject& request = *it;
MojString locationStr;
MojString typeStr;
MojString app;
BusClient::PackageType type;
BusClient::PackageLocation location;
err = request.getRequired("id", app);
MojErrCheck(err);
err = request.getRequired("type", typeStr);
MojErrCheck(err);
err = request.getRequired("location", locationStr);
MojErrCheck(err);
if (typeStr == "app") {
type = BusClient::Application;
} else if (typeStr == "service") {
type = BusClient::Service;
} else {
MojErrThrow(MojErrInvalidMsg);
}
if (locationStr == "system") {
location = BusClient::System;
} else if (locationStr == "third party") {
location = BusClient::ThirdParty;
} else {
MojErrThrow(MojErrInvalidMsg);
}
m_client.Scan(confmode, app, type, location);
}
m_client.RunNextConfigurator();
} catch (const std::exception& e) {
MojErrThrowMsg(MojErrInternal, "%s", e.what());
} catch (...) {
MojErrThrowMsg(MojErrInternal, "uncaught exception");
}
return MojErrNone;
}
bool MojoWhereMatcher::GetObjectValue(const MojObject& key,
const MojObject& response, MojObject& value) const
{
if (key.type() == MojObject::TypeString) {
MojString keyStr;
MojErr err = key.stringValue(keyStr);
if (err) {
throw std::runtime_error("Error attempting to retrieve key name "
"getting object value");
}
if (response.contains(keyStr)) {
return response.get(keyStr, value);
} else {
return false;
}
} else if (key.type() == MojObject::TypeArray) {
MojObject cur = response;
for (MojObject::ConstArrayIterator iter = key.arrayBegin();
iter != key.arrayEnd(); ++iter) {
const MojObject& keyObj = *iter;
if (keyObj.type() != MojObject::TypeString) {
throw std::runtime_error("Non-string found in property "
"specifiction array");
}
MojString keyStr;
MojErr err = keyObj.stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to access lookup key");
}
if (cur.contains(keyStr)) {
MojObject tmp;
if (!cur.get(keyStr, tmp)) {
return false;
} else {
cur = tmp;
}
} else {
return false;
}
}
value = cur;
return true;
} else {
throw std::runtime_error("Property specification must be the "
"property name or array of property names");
}
}
void EmailAdapter::ParseParts(const MojObject& partsArray, EmailPartList& partList)
{
MojObject::ConstArrayIterator it = partsArray.arrayBegin();
for (; it != partsArray.arrayEnd(); ++it) {
const MojObject& partObj = *it;
EmailPartPtr emailPart = ParseEmailPart(partObj);
// Add to the part list
partList.push_back(emailPart);
}
}
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;
}
MojErr MojDbDistinctTest::check(MojDb& db, const MojDbQuery& query, MojDbCursor& cursor, const MojChar* queryString, const MojChar* expectedIdsJson)
{
MojErr err = db.find(query, cursor);
MojTestErrCheck(err);
MojObjectBuilder builder;
err = builder.beginArray();
MojTestErrCheck(err);
err = cursor.visit(builder);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
err = builder.endArray();
MojTestErrCheck(err);
MojObject results = builder.object();
MojString json;
err = results.toJson(json);
MojTestErrCheck(err);
MojObject expected;
err = expected.fromJson(expectedIdsJson);
MojTestErrCheck(err);
// size check
MojTestAssert(expected.size() == results.size());
// value check
MojObject::ConstArrayIterator j = results.arrayBegin();
for (MojObject::ConstArrayIterator i = expected.arrayBegin();
i != expected.arrayEnd(); ++i, ++j) {
MojObject value;
err = j->getRequired(queryString, value);
MojTestErrCheck(err);
MojTestAssert(*i == value);
}
return MojErrNone;
}
MojErr MojDbServiceHandler::handleBatch(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
MojObject operations;
MojErr err = payload.getRequired(MojDbServiceDefs::OperationsKey, operations);
MojErrCheck(err);
MojObject::ArrayIterator begin;
err = operations.arrayBegin(begin);
MojErrCheck(err);
//start the response array
MojObjectVisitor& writer = msg->writer();
err = writer.beginObject();
MojErrCheck(err);
err = writer.boolProp(MojServiceMessage::ReturnValueKey, true);
MojErrCheck(err);
err = writer.propName(MojDbServiceDefs::ResponsesKey);
MojErrCheck(err);
err = writer.beginArray();
MojErrCheck(err);
for (MojObject* i = begin; i != operations.arrayEnd(); ++i) {
MojString method;
err = i->getRequired(MojDbServiceDefs::MethodKey, method);
MojErrCheck(err);
MojObject params;
err = i->getRequired(MojDbServiceDefs::ParamsKey, params);
MojErrCheck(err);
// not allowed to specify watch key in a batch
bool watchValue = false;
if (payload.get(MojDbServiceDefs::WatchKey, watchValue) && watchValue) {
MojErrThrow(MojErrDbInvalidBatch);
}
DbCallback cb;
if (!m_batchCallbacks.get(method, cb)) {
MojErrThrow(MojErrDbInvalidBatch);
}
err = (this->*cb)(msg, params, req);
MojErrCheck(err);
}
err = writer.endArray();
MojErrCheck(err);
err = writer.endObject();
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbSearchTest::check(MojDb& db, const MojDbQuery& query, const MojChar* expectedIdsJson)
{
MojString str;
MojDbSearchCursor cursor(str);
MojErr err = db.find(query, cursor);
MojTestErrCheck(err);
MojObjectBuilder builder;
err = builder.beginArray();
MojTestErrCheck(err);
err = cursor.visit(builder);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
err = builder.endArray();
MojTestErrCheck(err);
MojObject results = builder.object();
MojString json;
err = results.toJson(json);
MojTestErrCheck(err);
MojObject expected;
err = expected.fromJson(expectedIdsJson);
MojTestErrCheck(err);
MojTestAssert(expected.size() == results.size());
MojObject::ConstArrayIterator j = results.arrayBegin();
for (MojObject::ConstArrayIterator i = expected.arrayBegin();
i != expected.arrayEnd(); ++i, ++j) {
MojObject id;
err = j->getRequired(MojDb::IdKey, id);
MojTestErrCheck(err);
MojTestAssert(*i == id);
}
return MojErrNone;
}
MojErr MojDbServiceHandler::handleDel(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
MojErr err = MojErrNone;
MojUInt32 count = 0;
MojUInt32 flags = MojDb::FlagNone;
bool purge = false;
if (payload.get(MojDbServiceDefs::PurgeKey, purge) && purge) {
flags |= MojDb::FlagPurge;
}
MojObject obj;
if (payload.get(MojDbServiceDefs::IdsKey, obj)) {
if (payload.contains(MojDbServiceDefs::QueryKey))
MojErrThrowMsg(MojErrInvalidArg, _T("db: cannot have both an objects argument and a query argument"));
MojObject deletedObjects;
err = m_db.del(obj.arrayBegin(), obj.arrayEnd(), count, deletedObjects, flags, req);
MojErrCheck(err);
err = formatPut(msg, deletedObjects.arrayBegin(), deletedObjects.arrayEnd());
MojErrCheck(err);
}
else if (payload.get(MojDbServiceDefs::QueryKey, obj)) {
MojDbQuery query;
err = query.fromObject(obj);
MojErrCheck(err);
MojUInt32 queryCount = 0;
err = m_db.del(query, queryCount, flags, req);
MojErrCheck(err);
count += queryCount;
err = formatCount(msg, count);
MojErrCheck(err);
}
return MojErrNone;
}
void MojoWhereMatcher::ValidateKey(const MojObject& key) const
{
if (key.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = key.arrayBegin();
iter != key.arrayEnd(); ++iter) {
const MojObject& keyObj = *iter;
if (keyObj.type() != MojObject::TypeString) {
throw std::runtime_error("Something other than a string "
"found in array of property names");
}
}
} else if (key.type() != MojObject::TypeString) {
throw std::runtime_error("Property keys must be specified as "
"a property name, or array of property names");
}
}
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;
}
/*
* 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;
}
/*
* Parse the account id from the results object for the accountId query
* saved in m_accountId member variable
*
*/
MojErr SendOneMessageHandler::readAccountIdFromResults(MojObject& result)
{
// log the results
MojString mojStringJson;
result.toJson(mojStringJson);
MojLogDebug(IMServiceApp::s_log, _T("readAccountIdFromResults result: %s"), mojStringJson.data());
// "results" in result
MojObject results;
result.get(_T("results"), results);
// check to see if array is empty - there should really always be 1 item here
if (!results.empty()){
// get the db id of the buddy
MojObject loginState;
MojObject::ConstArrayIterator itr = results.arrayBegin();
bool foundOne = false;
while (itr != results.arrayEnd()) {
if (foundOne) {
MojLogError(IMServiceApp::s_log,
_T("readAccountIdFromResults: found more than one ImLoginState with same username/serviceName - using the first one"));
break;
}
loginState = *itr;
foundOne = true;
itr++;
}
// create the DB object
MojErr err = loginState.getRequired("accountId", m_accountId);
if (err) {
MojLogError(IMServiceApp::s_log, _T("readAccountIdFromResults: missing accountId in loginState entry"));
}
MojLogInfo(IMServiceApp::s_log, _T("readAccountIdFromResults - accountId: %s. "), m_accountId.data());
}
else {
MojLogError(IMServiceApp::s_log, _T("readAccountIdFromResults: no matching loginState record found for %s"), m_serviceName.data());
}
return MojErrNone;
}
bool MojoWhereMatcher::CheckClauses(const MojObject& clauses,
const MojObject& response) const
{
MojLogTrace(s_log);
if (clauses.type() == MojObject::TypeObject) {
return CheckClause(clauses, response);
} else if (clauses.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = clauses.arrayBegin();
iter != clauses.arrayEnd(); ++iter) {
if (!CheckClause(*iter, response)) {
return false;
}
}
} else {
throw std::runtime_error("Clauses must consist of either a single "
"where clause or array of where clauses");
}
return true;
}
MojErr SyncFolderListCommand::GetLocalFoldersResponse(MojObject& response, MojErr err)
{
CommandTraceFunction();
try {
ErrorToException(err);
MojObject accountId = m_session.GetAccount()->GetId();
MojObject results;
err = response.getRequired("results", results);
ErrorToException(err);
MojObject::ArrayIterator it;
err = results.arrayBegin(it);
ErrorToException(err);
// Read list of local folders
for (; it != results.arrayEnd(); ++it) {
MojObject& folderObj = *it;
ImapFolderPtr folder = boost::make_shared<ImapFolder>();
ImapFolderAdapter::ParseDatabaseObject(folderObj, *folder);
folder->SetAccountId(accountId);
m_localFolders.push_back(folder);
}
if(DatabaseAdapter::GetNextPage(response, m_folderPage)) {
// Get more folders
GetLocalFolders();
} else {
// Next step: get list of emails from server
SendListCommand();
}
} CATCH_AS_FAILURE
return MojErrNone;
}
void MojoNewWhereMatcher::ValidateClauses(const MojObject& where) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Validating trigger clauses");
if (where.type() == MojObject::TypeObject) {
ValidateClause(where);
} else if (where.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = where.arrayBegin();
iter != where.arrayEnd(); ++iter) {
const MojObject& clause = *iter;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("where statement array must "
"consist of valid clauses");
} else {
ValidateClause(clause);
}
}
} else {
throw std::runtime_error("where statement should consist of a single "
"clause or array of valid clauses");
}
}
void MojoWhereMatcher::ValidateClauses(const MojObject& where) const
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Validating trigger clauses"));
if (where.type() == MojObject::TypeObject) {
ValidateClause(where);
} else if (where.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = where.arrayBegin();
iter != where.arrayEnd(); ++iter) {
const MojObject& clause = *iter;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("where statement array must "
"consist of valid clauses");
} else {
ValidateClause(clause);
}
}
} else {
throw std::runtime_error("where statement should consist of a single "
"clause or array of valid clauses");
}
}
