C++ QDjangoQuerySet::filter方法代码示例

static void saveMessage(const QXmppMessage &message, const QDateTime &now, bool received)
{
    const QString localJid = QXmppUtils::jidToBareJid(received ? message.to() : message.from());
    const QString remoteJid = QXmppUtils::jidToBareJid(received ? message.from() : message.to());

    // get or create collection
    int chatId;
    QDjangoQuerySet<ArchiveMessage> qs;
    qs = qs.filter(QDjangoWhere("chat__jid", QDjangoWhere::Equals, localJid));
    qs = qs.filter(QDjangoWhere("chat__with", QDjangoWhere::Equals, remoteJid));
    qs = qs.orderBy(QStringList() << "-date").limit(0, 1);
    ArchiveMessage tmp;
    if (qs.size() > 0 && qs.at(0, &tmp) && tmp.date().secsTo(now) < 3600) {
        chatId = tmp.property("chat_id").toInt();
    } else {
        ArchiveChat chat;
        chat.setJid(localJid);
        chat.setWith(remoteJid);
        chat.setStart(now);
        chat.save();
        chatId = chat.pk().toInt();
    }

    // save outgoing message
    ArchiveMessage msg;
    msg.setProperty("chat_id", chatId);
    msg.setBody(message.body());
    msg.setDate(now);
    msg.setReceived(received);
    msg.save();
}

void Patient::filtred_Patients(){
    ui->lw_filtredPatients->clear();
    QDjangoQuerySet <Paciente> pat;
    if (!ui->le_patFILTER->text().isEmpty())
        pat = pat.filter(QDjangoWhere("nameP", QDjangoWhere::Contains, ui->le_patFILTER->text()));
else
    if(!ui->le_prontSearch->text().isEmpty())
        pat = pat.filter(QDjangoWhere("pront", QDjangoWhere::Contains, ui->le_prontSearch->text()));

    for (int i = 0; i < pat.count(); ++i){
        QListWidgetItem * itemP = new QListWidgetItem(pat.at(i)->nameP(), ui->lw_filtredPatients);
        itemP->setData(Qt::UserRole, pat.at(i)->pront());
    }
}

/** Perform filtering on foreign keys.
 */
void tst_QDjangoModel::filterRelated()
{
    // load fixtures
    {
        Item *item1 = new Item;
        item1->setName("first");
        QCOMPARE(item1->save(), true);

        Item *item2 = new Item;
        item2->setName("second");
        QCOMPARE(item2->save(), true);

        Owner owner;
        owner.setName("owner");
        owner.setItem1(item1);
        owner.setItem2(item2);
        QCOMPARE(owner.save(), true);
    }

    // perform filtering
    QDjangoQuerySet<Owner> owners;

    QDjangoQuerySet<Owner> qs = owners.filter(
        QDjangoWhere("item1__name", QDjangoWhere::Equals, "first"));
    CHECKWHERE(qs.where(), QLatin1String("T0.\"name\" = ?"), QVariantList() << "first");
    QCOMPARE(qs.count(), 1);
    QCOMPARE(qs.size(), 1);

    Owner *owner = qs.at(0);
    QVERIFY(owner != 0);
    QCOMPARE(owner->name(), QLatin1String("owner"));
    delete owner;
}

QDjangoQuerySet<Project> DatabaseController::listProjects(QDateTime from, QDateTime to=QDateTime::currentDateTime()){
    QDjangoQuerySet<Project> projects;

    projects = projects.filter( QDjangoWhere("start_date", QDjangoWhere::GreaterOrEquals, from) &&
                                QDjangoWhere("start_date", QDjangoWhere::LessOrEquals, to) );

    return projects;
}

//! When a Patient is clicked those informations is showed in a QTableWidget
void Patient::on_lw_filtredPatients_itemClicked(QListWidgetItem* item)
{
    QDjangoQuerySet<Paciente> ptPront;
    ptPront = ptPront.filter(QDjangoWhere("nameP", QDjangoWhere::Equals, ui->lw_filtredPatients->currentItem()->text()));
    for(int i = 0; i < ptPront.count(); ++i){
        QString t;
        QSqlQuery s;
        s.prepare("SELECT pront FROM sae.paciente WHERE nameP = :name");
        s.bindValue(":name", ui->lw_filtredPatients->currentItem()->text());
        s.exec();
        while (s.next()){
            t = s.value(0).toString();
        }
        ui->tblW_selectedPatient->setItem(0, 0, new QTableWidgetItem(t));
        ui->tblW_selectedPatient->setItem(0, 1, new QTableWidgetItem(ptPront.at(i)->rg()));
        ui->tblW_selectedPatient->setItem(0, 2, new QTableWidgetItem(ptPront.at(i)->dBornP().toString("dd / MM / yyyy")));
        ui->tblW_selectedPatient->setItem(0, 3, new QTableWidgetItem(ptPront.at(i)->mailP()));
        ui->tblW_selectedPatient->setItem(0, 4, new QTableWidgetItem(ptPront.at(i)->ethn()));
    }
}

/*
 * Чтение и подгрузка из БД требований.
 */
void BF_AnalizeForm::fillRequirements(const QString &type, QListWidget *lwgt) {

    lwgt->clear();

    QDjango::setDatabase(*Core::Base::instance().sessionDatabase());
    QDjangoQuerySet<RequirementElement> someRequirementElements;
    someRequirementElements = someRequirementElements.filter(
                QDjangoWhere("type", QDjangoWhere::Equals, type));

    // retrieve usernames and passwords for matching users as maps
    QList<QVariantMap> propertyMaps = someRequirementElements.values(
                QStringList() << "id" << "type" << "name");
    foreach (const QVariantMap &propertyList, propertyMaps) {
      QString tmp = QString("%1:%2%3-%4")
              .arg(propertyList["id"].toString())
              .arg(propertyList["type"].toString())
              .arg(propertyList["id"].toString())
              .arg(propertyList["name"].toString());
      lwgt->addItem(tmp);
    }

PromissionModel::PromissionModel()
{
    QDjango::setDatabase(*Core::Base::instance().sessionDatabase());
    QDjango::registerModel<Promission>();
    QDjango::createTables();

    // Создаем роль по-умолчанию
    QDjangoQuerySet<Role> roles;
    roles = roles.filter(QDjangoWhere("name", QDjangoWhere::Equals, "Admin"));

    if (roles.count()==0) {
        messageLibrary msg;
        msg.createInfoMessage("Информация",
                              "Роль администратора отсутствует, разрешения по-умолчанию создать не могу!");
    }
    else {
        addPromission( tr("Возможность смотреть документацию приложения"),    "CAN_SEE_APP_DOCS",          "CONST", roles.at(0) );
        addPromission( tr("Возможность смотреть настройки приложения"),       "CAN_SEE_APP_SETTINGS",      "CONST", roles.at(0) );
        addPromission( tr("Возможность смотреть меню плагинов приложения"), "CAN_SEE_MANAGERS_MENU",     "CONST", roles.at(0) );
        addPromission( tr("Возможность управлять настройками плагинов"),    "CAN_SEE_MANAGERS_SETTINGS", "CONST", roles.at(0) );
        addPromission( tr("Возможность работать с панелями плагинов"),      "CAN_SEE_MANAGERS_TOOLBAR",  "CONST", roles.at(0) );

        addPromission( tr("Возможность работать с элементами управления плагина на уровне 0"), "CAN_SEE_MANAGER_CONROLS_LEVEL_0",     "CONST", roles.at(0) );
        addPromission( tr("Возможность работать с элементами управления плагина на уровне 1"), "CAN_SEE_MANAGER_CONROLS_LEVEL_1",     "CONST", roles.at(0) );
        addPromission( tr("Возможность работать с элементами управления плагина на уровне 2"), "CAN_SEE_MANAGER_CONROLS_LEVEL_2",     "CONST", roles.at(0) );

        addPromission( tr("Возможность работать с элементами управления плагина на уровне 0"), "CAN_SEE_MODULES_CONROLS_LEVEL_0",     "CONST", roles.at(0) );
        addPromission( tr("Возможность работать с элементами управления плагина на уровне 1"), "CAN_SEE_MODULES_CONROLS_LEVEL_1",     "CONST", roles.at(0) );
        addPromission( tr("Возможность работать с элементами управления плагина на уровне 2"), "CAN_SEE_MODULES_CONROLS_LEVEL_2",     "CONST", roles.at(0) );

        addPromission( tr("Возможность смотреть меню модулей приложения"),      "CAN_SEE_MODULES_MENU",            "CONST", roles.at(0) );
        addPromission( tr("Возможность смотреть настройки модулей приложения"), "CAN_SEE_MODULES_SETTINGS",        "CONST", roles.at(0) );
        addPromission( tr("Возможность смотреть панели модулей приложения"),    "CAN_SEE_MODULES_TOOLBAR",         "CONST", roles.at(0) );

        addPromission( tr("Возможность работать в отладочном режиме"), "DEBUG_MODE", "CONST", roles.at(0) );
    }
}

bool XmppServerPrivate::handleStanza(const QDomElement &element)
{
    const QString to = element.attribute("to");
    if (QXmppUtils::jidToDomain(to) != server()->domain())
        return false;

    if (element.tagName() == "iq" && PrivateStorageIq::isPrivateStorageIq(element))
    {
        PrivateStorageIq request;
        request.parse(element);

        if (request.type() == QXmppIq::Result)
            return true;

        // check the namespace is valid
        const QString xmlns = request.payload().attribute("xmlns");
        if (xmlns.isEmpty()) {
            QXmppIq response;
            response.setId(request.id());
            response.setTo(request.from());
            response.setType(QXmppIq::Error);
            server()->sendPacket(response);
            return true;
        }

        const QString bareFrom = QXmppUtils::jidToBareJid(request.from());
        QDjangoQuerySet<PrivateStorage> qs;
        qs = qs.filter(QDjangoWhere("jid", QDjangoWhere::Equals, bareFrom));

        if (request.type() == QXmppIq::Get) {
            PrivateStorageIq response;
            response.setId(request.id());
            response.setTo(request.from());
            response.setType(QXmppIq::Result);
 
            PrivateStorage storage;
            if (qs.get(QDjangoWhere("xmlns", QDjangoWhere::Equals, xmlns), &storage)) {
                QDomDocument doc;
                doc.setContent(storage.data());
                response.setPayload(doc.documentElement());
            } else {
                response.setPayload(request.payload());
            }
            server()->sendPacket(response);

        } else if (request.type() == QXmppIq::Set) {
            PrivateStorage storage;
            if (!qs.get(QDjangoWhere("xmlns", QDjangoWhere::Equals, xmlns), &storage)) {
                storage.setJid(bareFrom);
                storage.setXmlns(xmlns);
            }
            storage.setXml(request.payload());
            storage.save();

            // reply
            QXmppIq response;
            response.setId(request.id());
            response.setTo(request.from());
            response.setType(QXmppIq::Result);
            server()->sendPacket(response);
        }
        return true;
    }
    return false;
}