void FotoBilderAccount::handleGotPhotos ()
{
QDomDocument document;
const auto& content = CreateDomDocumentFromReply (qobject_cast<QNetworkReply*> (sender ()),
document);
if (content.isEmpty ())
return;
if (IsErrorReply (content))
return;
for (const auto& photo : ParseGetPicsRequest (document))
AllPhotosItem_->appendRow (CreatePhotoItem (photo));
emit doneUpdating ();
CallNextFunctionFromQueue ();
}
void PhotosTab::handleAccountChosen (int idx)
{
auto accVar = AccountsBox_->itemData (idx, AccountsManager::Role::AccountObj);
auto accObj = accVar.value<QObject*> ();
auto acc = qobject_cast<IAccount*> (accObj);
if (acc == CurAcc_)
return;
if (CurAccObj_)
disconnect (CurAccObj_,
0,
this,
0);
CurAccObj_ = accObj;
CurAcc_ = acc;
connect (CurAccObj_,
SIGNAL (doneUpdating ()),
this,
SLOT (handleAccDoneUpdating ()));
CurAcc_->UpdateCollections ();
auto model = CurAcc_->GetCollectionsModel ();
if (auto sel = Ui_.CollectionsTree_->selectionModel ())
disconnect (sel,
SIGNAL (currentRowChanged (QModelIndex, QModelIndex)),
this,
SLOT (handleRowChanged (QModelIndex)));
Ui_.CollectionsTree_->setModel (model);
connect (Ui_.CollectionsTree_->selectionModel (),
SIGNAL (currentRowChanged (QModelIndex, QModelIndex)),
this,
SLOT (handleRowChanged (QModelIndex)));
ProxyModel_->SetCurrentAccount (CurAccObj_);
ProxyModel_->setSourceModel (model);
ImagesView_->rootContext ()->setContextProperty ("collRootIndex", QVariant::fromValue (QModelIndex ()));
HandleCollectionSelected ({});
UploadAction_->setEnabled (qobject_cast<ISupportUploads*> (CurAccObj_));
emit tabRecoverDataChanged ();
}
void FotoBilderAccount::handleImageUploaded ()
{
auto reply = qobject_cast<QNetworkReply*> (sender ());
QDomDocument document;
const QByteArray& content = CreateDomDocumentFromReply (reply, document);
if (content.isEmpty ())
return;
if (IsErrorReply (content))
return;
const auto& item = Reply2UploadItem_.take (reply);
auto pic = ParseUploadedPictureResponse (document);
pic.Title_ = QFileInfo (item.FilePath_).fileName ();
AllPhotosItem_->appendRow (CreatePhotoItem (pic));
emit doneUpdating ();
emit itemUploaded (item, pic.Url_);
CallNextFunctionFromQueue ();
}
PlanStage::StageState UpdateStage::work(WorkingSetID* out) {
++_commonStats.works;
// Adds the amount of time taken by work() to executionTimeMillis.
ScopedTimer timer(&_commonStats.executionTimeMillis);
if (isEOF()) { return PlanStage::IS_EOF; }
if (doneUpdating()) {
// Even if we're done updating, we may have some inserting left to do.
if (needInsert()) {
doInsert();
}
// At this point either we're done updating and there was no insert to do,
// or we're done updating and we're done inserting. Either way, we're EOF.
invariant(isEOF());
return PlanStage::IS_EOF;
}
// If we're here, then we still have to ask for results from the child and apply
// updates to them. We should only get here if the collection exists.
invariant(_collection);
WorkingSetID id = WorkingSet::INVALID_ID;
StageState status = _child->work(&id);
if (PlanStage::ADVANCED == status) {
// Need to get these things from the result returned by the child.
DiskLoc loc;
BSONObj oldObj;
WorkingSetMember* member = _ws->get(id);
if (!member->hasLoc()) {
_ws->free(id);
const std::string errmsg = "update stage failed to read member w/ loc from child";
*out = WorkingSetCommon::allocateStatusMember(_ws, Status(ErrorCodes::InternalError,
errmsg));
return PlanStage::FAILURE;
}
loc = member->loc;
// Updates can't have projections. This means that covering analysis will always add
// a fetch. We should always get fetched data, and never just key data.
invariant(member->hasObj());
oldObj = member->obj;
// If we're here, then we have retrieved both a DiskLoc and the corresponding
// unowned object from the child stage. Since we have the object and the diskloc,
// we can free the WSM.
_ws->free(id);
// We fill this with the new locs of moved doc so we don't double-update.
if (_updatedLocs && _updatedLocs->count(loc) > 0) {
// Found a loc that we already updated.
++_commonStats.needTime;
return PlanStage::NEED_TIME;
}
++_specificStats.nMatched;
// Do the update and return.
transformAndUpdate(oldObj, loc);
++_commonStats.needTime;
return PlanStage::NEED_TIME;
}
else if (PlanStage::IS_EOF == status) {
// The child is out of results, but we might not be done yet because we still might
// have to do an insert.
++_commonStats.needTime;
return PlanStage::NEED_TIME;
}
else if (PlanStage::FAILURE == status) {
*out = id;
// If a stage fails, it may create a status WSM to indicate why it failed, in which case
// 'id' is valid. If ID is invalid, we create our own error message.
if (WorkingSet::INVALID_ID == id) {
const std::string errmsg = "delete stage failed to read in results from child";
*out = WorkingSetCommon::allocateStatusMember(_ws, Status(ErrorCodes::InternalError,
errmsg));
return PlanStage::FAILURE;
}
return status;
}
else {
if (PlanStage::NEED_TIME == status) {
++_commonStats.needTime;
}
return status;
}
}
bool UpdateStage::isEOF() {
return doneUpdating() && !needInsert();
}
