void JsonPrepareThread::run()
{
int position = 1; // 1-based numbering to match tree & table views
for(std::vector<MongoDocumentPtr>::const_iterator it = _bsonObjects.begin();it!=_bsonObjects.end();++it)
{
MongoDocumentPtr doc = *it;
mongo::StringBuilder sb;
if (position == 1)
sb << "/* 1 */\n";
else
sb << "\n\n/* " << position << " */\n";
mongo::BSONObj obj = doc->bsonObj();
std::string stdJson = BsonUtils::jsonString(obj, mongo::TenGen, 1, _uuidEncoding, _timeZone);
if (_stop)
break;
sb << stdJson;
QString json = QtUtils::toQString(sb.str());
if (_stop)
break;
emit partReady(json);
position++;
}
emit done();
}
BsonTableModel::BsonTableModel(const std::vector<MongoDocumentPtr> &documents, QObject *parent)
: BaseClass(parent) ,
_root(new BsonTableItem(this))
{
for (std::vector<MongoDocumentPtr>::const_iterator it = documents.begin(); it!=documents.end(); ++it)
{
MongoDocumentPtr doc = (*it);
parseDocument(_root,doc->bsonObj());
}
}
void BsonTreeItem::expand()
{
QtUtils::clearChildItems(this);
MongoDocumentPtr document = _document ? _document : _element->asDocument();
bool isArray = _element ? _element->isArray() : false;
MongoDocumentIterator iterator(document.get());
int position = 0;
while(iterator.hasMore())
{
MongoElementPtr element = iterator.next();
BsonTreeItem *childItem = new BsonTreeItem(_rootDocument, element, isArray ? position : -1);
addChild(childItem);
position++;
}
}
BsonTreeModel::BsonTreeModel(const std::vector<MongoDocumentPtr> &documents, QObject *parent) :
BaseClass(parent),
_root(new BsonTreeItem(this))
{
for (int i = 0; i < documents.size(); ++i) {
MongoDocumentPtr doc = documents[i];
BsonTreeItem *child = new BsonTreeItem(doc->bsonObj(), _root);
parseDocument(child, doc->bsonObj(), doc->bsonObj().isArray());
QString idValue;
BsonTreeItem *idItem = child->childByKey("_id");
if (idItem) {
idValue = idItem->value();
}
child->setKey(QString("(%1) %2").arg(i + 1).arg(idValue));
int count = BsonUtils::elementsCount(doc->bsonObj());
if (doc->bsonObj().isArray()) {
child->setValue(arrayValue(count));
child->setType(mongo::Array);
} else {
child->setValue(objectValue(count));
child->setType(mongo::Object);
}
_root->addChild(child);
}
}
CollectionStatsTreeItem::CollectionStatsTreeItem(MongoDocumentPtr document) :
_document(document)
{
_obj = document->bsonObj();
MongoNamespace ns(getString("ns"));
setText(0, prepareValue(ns.collectionName()));
setIcon(0, GuiRegistry::instance().collectionIcon());
setText(1, prepareValue(QString::number(getLongLong("count"))));
setText(2, prepareValue(MongoUtils::buildNiceSizeString(getDouble("size"))));
setText(3, prepareValue(MongoUtils::buildNiceSizeString(getDouble("storageSize"))));
setText(4, prepareValue(MongoUtils::buildNiceSizeString(getDouble("totalIndexSize"))));
setText(5, prepareValue(MongoUtils::buildNiceSizeString(getDouble("avgObjSize"))));
setText(6, prepareValue(QString::number(getDouble("paddingFactor"))));
}
/*
** Build Json string that represent this element.
*/
void MongoElement::buildJsonString(Concatenator &con)
{
switch (_bsonElement.type())
{
/** double precision floating point value */
case NumberDouble:
con.append(QString::number(_bsonElement.Double()));
break;
/** character string, stored in utf8 */
case String:
{
/*
** If you'll write:
**
** int valsize = element.valuesize();
** int strsize = element.valuestrsize();
** int bytescount = qstrlen(element.valuestr());
**
** You'll get:
**
** bytescount + 1 == strsize
** strsize + 4 == valsize
**
** So:
** bytescount + 5 == valsize
**
*/
QString res = QString::fromUtf8(_bsonElement.valuestr(), _bsonElement.valuestrsize() - 1);
con.append(res);
}
break;
/** an embedded object */
case Object:
{
MongoDocumentPtr doc = asDocument();
doc->buildJsonString(con);
}
break;
/** an embedded array */
case Array:
{
MongoDocumentPtr doc = asDocument();
doc->buildJsonString(con);
}
break;
/** binary data */
case BinData:
{
mongo::BinDataType binType = _bsonElement.binDataType();
if (binType == mongo::newUUID || binType == mongo::bdtUUID) {
std::string uuid = HexUtils::formatUuid(_bsonElement, AppRegistry::instance().settingsManager()->uuidEncoding());
con.append(QString::fromStdString(uuid));
break;
}
con.append("<binary>");
}
break;
/** Undefined type */
case Undefined:
con.append("<undefined>");
break;
/** ObjectId */
case jstOID:
{
QString idValue = QString::fromStdString(_bsonElement.OID().toString());
QString objectId = QString("ObjectId(\"%1\")").arg(idValue);
con.append(objectId);
}
break;
/** boolean type */
case Bool:
con.append(_bsonElement.Bool() ? "true" : "false");
break;
/** date type */
case Date:
{
long long ms = (long long) _bsonElement.Date().millis;
boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
boost::posix_time::time_duration diff = boost::posix_time::millisec(ms);
boost::posix_time::ptime time = epoch + diff;
std::stringstream strm;
//boost::date_time::time_facet *timeFacet = new boost::date_time::time_facet("%a, %d %b %Y %H:%M:%S.%f GMT"); // "%Y---%m-%d %H:%M:%S"
boost::posix_time::time_facet *facet = new boost::posix_time::time_facet("%Y-%m-%d %H:%M:%S");
strm.imbue(std::locale(strm.getloc(), facet));
strm << time;
con.append(QString::fromStdString(strm.str()));
break;
/*
// this code is left untill the upper one will stabilize
unsigned long long millis = _bsonElement.Date().millis;
if ((long long)millis >= 0 &&
((long long)millis/1000) < (std::numeric_limits<time_t>::max)()) {
con.append(QString::fromStdString(_bsonElement.Date().toString()));
}
break;
*/
}
/** null type */
case jstNULL:
con.append(QString("<null>"));
break;
/** regular expression, a pattern with options */
case RegEx:
{
con.append("/" + QString::fromUtf8(_bsonElement.regex()) + "/");
for ( const char *f = _bsonElement.regexFlags(); *f; ++f ) {
switch ( *f ) {
case 'g':
case 'i':
case 'm':
con.append(QString(*f));
default:
break;
}
}
}
break;
/** deprecated / will be redesigned */
case DBRef:
break;
/** deprecated / use CodeWScope */
case Code:
con.append(QString::fromUtf8(_bsonElement._asCode().data()));
break;
/** a programming language (e.g., Python) symbol */
case Symbol:
con.append(QString::fromUtf8(_bsonElement.valuestr(), _bsonElement.valuestrsize() - 1));
break;
/** javascript code that can execute on the database server, with SavedContext */
case CodeWScope:
{
mongo::BSONObj scope = _bsonElement.codeWScopeObject();
if (!scope.isEmpty() ) {
con.append(QString::fromUtf8(_bsonElement._asCode().data()));
break;
}
}
break;
/** 32 bit signed integer */
case NumberInt:
con.append(QString::number(_bsonElement.Int()));
break;
/** Updated to a Date with value next OpTime on insert */
case Timestamp:
{
Date_t date = _bsonElement.timestampTime();
unsigned long long millis = date.millis;
if ((long long)millis >= 0 &&
((long long)millis/1000) < (std::numeric_limits<time_t>::max)()) {
con.append(QString::fromStdString(date.toString()));
}
break;
}
/** 64 bit integer */
case NumberLong:
con.append(QString::number(_bsonElement.Long()));
break;
default:
con.append("<unsupported>");
break;
}
}
/*
** Build Json string that represent this element.
*/
void MongoElement::buildJsonString(std::string &con)
{
switch (_bsonElement.type())
{
/** double precision floating point value */
case NumberDouble:
con.append(QtUtils::toStdString<std::string>(QString::number(_bsonElement.Double(),'g',14)));
break;
/** character string, stored in utf8 */
case String:
{
/*
** If you'll write:
**
** int valsize = element.valuesize();
** int strsize = element.valuestrsize();
** int bytescount = qstrlen(element.valuestr());
**
** You'll get:
**
** bytescount + 1 == strsize
** strsize + 4 == valsize
**
** So:
** bytescount + 5 == valsize
**
*/
con.append(_bsonElement.valuestr(), _bsonElement.valuestrsize() - 1);
}
break;
/** an embedded object */
case Object:
{
MongoDocumentPtr doc = asDocument();
doc->buildJsonString(con);
}
break;
/** an embedded array */
case Array:
{
MongoDocumentPtr doc = asDocument();
doc->buildJsonString(con);
}
break;
/** binary data */
case BinData:
{
mongo::BinDataType binType = _bsonElement.binDataType();
if (binType == mongo::newUUID || binType == mongo::bdtUUID) {
std::string uuid = HexUtils::formatUuid(_bsonElement, AppRegistry::instance().settingsManager()->uuidEncoding());
con.append(uuid);
break;
}
con.append("<binary>");
}
break;
/** Undefined type */
case Undefined:
con.append("<undefined>");
break;
/** ObjectId */
case jstOID:
{
std::string idValue = _bsonElement.OID().toString();
char buff[256]={0};
sprintf(buff,"ObjectId(\"%s\")",idValue.c_str());
con.append(buff);
}
break;
/** boolean type */
case Bool:
con.append(_bsonElement.Bool() ? "true" : "false");
break;
/** date type */
case Date:
{
long long ms = (long long) _bsonElement.Date().millis;
boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
boost::posix_time::time_duration diff = boost::posix_time::millisec(ms);
boost::posix_time::ptime time = epoch + diff;
std::string date = miutil::isotimeString(time,false,AppRegistry::instance().settingsManager()->timeZone()==LocalTime);
con.append(date);
break;
}
/** null type */
case jstNULL:
con.append("<null>");
break;
/** regular expression, a pattern with options */
case RegEx:
{
con.append("/" + std::string(_bsonElement.regex()) + "/");
for ( const char *f = _bsonElement.regexFlags(); *f; ++f ) {
switch ( *f ) {
case 'g':
case 'i':
case 'm':
con+=*f;
default:
break;
}
}
}
break;
/** deprecated / will be redesigned */
case DBRef:
break;
/** deprecated / use CodeWScope */
case Code:
con.append(_bsonElement._asCode());
break;
/** a programming language (e.g., Python) symbol */
case Symbol:
con.append(_bsonElement.valuestr(), _bsonElement.valuestrsize() - 1);
break;
/** javascript code that can execute on the database server, with SavedContext */
case CodeWScope:
{
mongo::BSONObj scope = _bsonElement.codeWScopeObject();
if (!scope.isEmpty() ) {
con.append(_bsonElement._asCode());
break;
}
}
break;
/** 32 bit signed integer */
case NumberInt:
{
char num[16]={0};
sprintf(num,"%d",_bsonElement.Int());
con.append(num);
break;
}
/** Updated to a Date with value next OpTime on insert */
case Timestamp:
{
Date_t date = _bsonElement.timestampTime();
unsigned long long millis = date.millis;
if ((long long)millis >= 0 &&
((long long)millis/1000) < (std::numeric_limits<time_t>::max)()) {
con.append(date.toString());
}
break;
}
/** 64 bit integer */
case NumberLong:
{
char num[32]={0};
sprintf(num,"%lld",_bsonElement.Long());
con.append(num);
break;
}
default:
con.append("<unsupported>");
break;
}
}
std::string MongoDocument::buildJsonString(const MongoDocumentPtr &doc)
{
//qt4 QTextCodec::setCodecForCStrings(codec);
std::string jsonString = doc->bsonObj().jsonString(mongo::TenGen, 1);
return jsonString;
}
