Beispiel #1
0
void Buddies::countOnlineUsers()
{

	QSqlQuery query;


	query.exec("select count(*) from b_main where b_status='Online'");

	if (!query.isActive())
	    QMessageBox::warning(this, tr("Database Error"),
	                         query.lastError().text());
	while (query.next()) {
	QString Penguins = query.value(0).toString();

	qDebug("=> Online users");

	ui.statusbar->showMessage(tr("Currently "+Penguins+" Buddies online"), 2000);

	}

}
Beispiel #2
0
void DataBase::createTablesOfTheRegisters(QList<FRegister *> &registers)
{
    QSqlQuery query;
    QString queryString = "";
    for(int i=0; i<registers.size(); i++){
        queryString = "create table _InfoReg" + registers[i]->attributes().value("name").toString() + " (reference text, ";
        QMapIterator<QString, QVariant> iter(registers[i]->attributes());
        while(iter.hasNext()){
            iter.next();
            queryString += iter.key() +" text, ";
        }
        queryString.remove(queryString.size() - 2, 2);
        queryString += ")";
        query.exec(queryString);
        qDebug()<<queryString;
        if(!query.isActive()){
            qDebug()<<query.lastError();
        }
        queryString = "";
    }
}
Beispiel #3
0
//=============================================================================
// SLOT: Delete the line with the given ID.
//=============================================================================
void CAddress::slotDeleteLine (QString id)
{
  //----------------------------------------------------------------------------
  // If ID is an empty string, the line was not saved already, so nothing has
  // to bo done.
  //----------------------------------------------------------------------------
  if (id != "")
  {
    QSqlQuery query ("DELETE FROM contacts_addresses WHERE address_id = " + id);

    if (!query.isActive())
    {
      SHOW_DB_ERROR(tr ("Error during deleting the data"), query);
      return;
    }

    mDB->commit();
  }
  
  loadData (mCurrent, mReadonly);
}
Beispiel #4
0
void DataBase::createTablesOfTheCatalogs(QList<FCatalog *> &catalogs)
{
    QSqlQuery query;
    QString queryString = "";
    for(int i=0; i<catalogs.size(); i++){
        queryString = "create table _Reference" + catalogs[i]->attributes().value("name").toString() + " (reference text, parent text, master text, mark_removal text, predefined text, ";
        QMapIterator<QString, QVariant> iter(catalogs[i]->attributes());
        while(iter.hasNext()){
            iter.next();
            queryString += iter.key() +" text, ";
        }
        queryString.remove(queryString.size() - 2, 2);
        queryString += ")";
        query.exec(queryString);
        qDebug()<<queryString;
        if(!query.isActive()){
            qDebug()<<query.lastError();
        }
        queryString = "";
    }
}
Beispiel #5
0
bool CatalogClass::isExist(QString _catalogName)
{
	QSqlQuery *q = NULL;
	bool result = false;
	q = new QSqlQuery(db);
	if (!q)
		return result;
	QString sql = "SELECT id, name FROM Catalogs Where name='%1'";
	sql = sql.arg(_catalogName);
            
	q->exec(sql);
	if (q->isActive())
	{
		q->first();
/*        if (q->isValid())
		printQS(QString("Catalog with name %1 exists").arg(_catalogName));*/
		result = q->isValid();
	}
	delete q;
	return result;
}
Beispiel #6
0
void DataBase::createTablesOfTheDocuments(QList<FDocument *>& documents)
{
    QSqlQuery query;
    QString queryString = "";
    for(int i=0; i<documents.size(); i++){
        queryString = "create table _Document" + documents[i]->attributes().value("name").toString() + " (reference text, mark_removal text, is_post text, ";
        QMapIterator<QString, QVariant> iter(documents[i]->attributes());
        while(iter.hasNext()){
            iter.next();
            queryString += iter.key() +" text, ";
        }
        queryString.remove(queryString.size() - 2, 2);
        queryString += ")";
        query.exec(queryString);
        qDebug()<<queryString;
        if(!query.isActive()){
            qDebug()<<query.lastError();
        }
        queryString = "";
    }
}
Beispiel #7
0
bool Database::insertMessage(QVariantMap message)
{
    QSqlQuery query;
    query.prepare(
            "INSERT INTO messagesTab (id,date,fromId,toId,fwdDate,fwdFromId,message,read,mediaType,attachmentId) "
                    "VALUES (?,?,?,?,?,?,?,?,?,?)");
    query.bindValue(0, message.value("id"));
    query.bindValue(1, message.value("date"));
    query.bindValue(2, message.value("fromId"));
    query.bindValue(3, message.value("toId"));
    query.bindValue(4, message.value("fwDate"));
    query.bindValue(5, message.value("fwdFromId"));
    query.bindValue(6, message.value("message"));
    query.bindValue(7, message.value("read"));
    query.bindValue(8, message.value("type"));
    query.bindValue(9, message.value("attachmentId"));
    query.exec();
    if (query.isActive())
        return true;
    return false;
}
Beispiel #8
0
  void UrlRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    ObjectRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(UrlRecord::ColumnsType::parentDatabaseTableName);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastParentDatabaseTableName = value.toString().toStdString();

    value = query.value(UrlRecord::ColumnsType::parentRecordId);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastParentRecordId = value.toInt();

    value = query.value(UrlRecord::ColumnsType::url);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastUrl = openstudio::Url(value.toString());
  }
Beispiel #9
0
void DbManager::createNewExcelDatabase(const QString& path)
{
    QXlsx::Document sns_new(path);

    QSqlQuery query;
    QString query_string =
            "SELECT                 people.id, "
                                   "people.first_name, "
                                   "people.last_name, "
                                   "people.personal_code, "
                                   "people.job, "
                                   "people.email, "
                                   "people.phone, "
                                   "address.street_name, "
                                   "address.municipality, "
                                   "address.zip, "
                                   "address.province, "
                                   "address.state, "
                                   "license.license_name "
            "FROM people "
            "INNER JOIN address ON people.id = address.person "
            "INNER JOIN people_license ON people_license.id_person = people.id "
            "INNER JOIN license ON   license.id = people_license.id_license ";

    query.prepare(query_string);
    if(query.exec()) {
        if(query.isActive()) {
            if(query.first()) {
                int row = 3;
                while(query.next()) {
                    for(int i = 1; i < 14; i++) {
                        sns_new.write(row, i , query.value(i - 1));
                    }
                    ++row;
                }
            }
        }
    }
    sns_new.save();
}
Beispiel #10
0
QQueue<CustomerSite> ControlThread::buildCustomerList()
{
	QQueue<CustomerSite>  newCustomerSiteQueue;
	QSqlQuery customersitequery;
	customersitequery.prepare("SELECT customer_sites.* FROM customer_sites INNER JOIN users ON customer_sites.user=users.id WHERE customer_sites.site=? AND active=1");
	customersitequery.addBindValue(site_id);
	customersitequery.exec();
	if(customersitequery.isActive())
	{
		while(customersitequery.next()) {
			CustomerSite site;
			site.setId(customersitequery.record().value("id").toULongLong());
			site.setUserId(customersitequery.record().value("user").toULongLong());
			site.setRepeatTime(customersitequery.record().value("repeat_time").toUInt());
			site.setLogSuccessful(customersitequery.record().value("log_successful").toBool());
			site.setFullPage(customersitequery.record().value("full_page").toBool());
			site.setName(customersitequery.record().value("name").toString());
			site.setUrl(customersitequery.record().value("url").toString());
			site.setMaxTimeOut(customersitequery.record().value("max_timeout").toUInt());
			if(customersitequery.record().value("host").toString() != "")
			{
				site.setHost(customersitequery.record().value("host").toString());
			}
			else
			{
				site.setHost(QUrl(site.getUrl()).host());
			}
				
			site.setFetchRemote(customersitequery.record().value("fetch_remote").toBool());
			site.setMonitorSiteId(site_id);
			
			newCustomerSiteQueue.enqueue(site);
		}
	}
	else {
// 		qDebug() << "ControlThread::BuildSiteList - Query Failed" << customersitequery.lastError().text();
	}
	
	return newCustomerSiteQueue;
}
Beispiel #11
0
bool AWSSessionRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = CloudSessionRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(AWSSessionRecord::ColumnsType::numServerProcessors);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_numServerProcessors == value.toUInt());

    value = query.value(AWSSessionRecord::ColumnsType::numWorkerProcessors);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_numWorkerProcessors == value.toUInt());

    value = query.value(AWSSessionRecord::ColumnsType::privateKey);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_privateKey == value.toString().toStdString());

    value = query.value(AWSSessionRecord::ColumnsType::timestamp);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_timestamp == value.toString().toStdString());

    value = query.value(AWSSessionRecord::ColumnsType::region);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_region == value.toString().toStdString());

    value = query.value(AWSSessionRecord::ColumnsType::serverInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_serverInstanceType == value.toString().toStdString());

    value = query.value(AWSSessionRecord::ColumnsType::workerInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_workerInstanceType == value.toString().toStdString());

    return result;
}
void SizPostForm::deleteRecordOfTablePost()
{
    QTextStream stream(&exchangeFile);
    QString line;
    while(!stream.atEnd()){
        stream.readLine();
    }

    int k = QMessageBox::question(this,trUtf8("Attention!!"),
                              trUtf8("Really delete?"),
                                  QMessageBox::Yes|QMessageBox::No,QMessageBox::No);
    if(k == QMessageBox::Yes){
        QSqlQuery query;
        query.prepare("DELETE FROM postsizlist WHERE (postid = :postid AND postsizid = :postsizid)");
        query.bindValue(":postsizid",indexTemp);
        QSqlQuery queryID;
        queryID.prepare("SELECT postid FROM post WHERE postname = :postname");
        queryID.bindValue(":postname",postView->item(postView->currentRow(),2)->text());
        queryID.exec();
        queryID.next();
        query.bindValue(":postid",queryID.value(0).toString());
        query.exec();

        if(!query.isActive()){
            QMessageBox::warning(this,QObject::trUtf8("Post Siz Table, DELETE ERROR!"),
                                 query.lastError().text());
            return;
        }
        line += "DELETE FROM postsizlist WHERE (postid = '";
        line += queryID.value(0).toString().toUtf8();
        line += "' AND postsizid = '";
        line += indexTemp.toUtf8();
        line += "')";
        line += "\r\n";
        stream<<line;
        postView->removeRow(postView->currentRow());
        postView->repaint();
    }
}
Beispiel #13
0
QSqlRecord QMYSQLDriver::record( const QSqlQuery& query ) const
{
    QSqlRecord fil;
    if ( !isOpen() )
	return fil;
    if ( query.isActive() && query.isSelect() && query.driver() == this ) {
	QMYSQLResult* result =  (QMYSQLResult*)query.result();
	QMYSQLResultPrivate* p = result->d;
	if ( !mysql_errno( p->mysql ) ) {
	    for ( ;; ) {
		MYSQL_FIELD* f = mysql_fetch_field( p->result );
		if ( f ) {
		    QSqlField fi( QString((const char*)f->name), qDecodeMYSQLType( f->type, f->flags ) );
		    fil.append( fi  );
		} else
		    break;
	    }
	}
	mysql_field_seek( p->result, 0 );
    }
    return fil;
}
void QgsMssqlProvider::loadMetadata()
{
  mSRId = 0;
  mWkbType = QGis::WKBUnknown;

  QSqlQuery query = QSqlQuery( mDatabase );
  query.setForwardOnly( true );
  if ( !query.exec( QString( "select f_geometry_column, coord_dimension, srid, geometry_type from geometry_columns where f_table_schema = '%1' and f_table_name = '%2'" ).arg( mSchemaName ).arg( mTableName ) ) )
  {
    QString msg = query.lastError().text();
    QgsDebugMsg( msg );
  }
  if ( query.isActive() )
  {
    if ( query.next() )
    {
      mGeometryColName = query.value( 0 ).toString();
      mSRId = query.value( 2 ).toInt();
      mWkbType = getWkbType( query.value( 3 ).toString(), query.value( 1 ).toInt() );
    }
  }
}
  void FSUDaceAlgorithmRecord_Impl::setLastValues(const QSqlQuery& query,
                          ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    DakotaAlgorithmRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastAlgorithmType = analysis::FSUDaceAlgorithmType(value.toInt());

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceTrialType);
    if (value.isValid() && !value.isNull()) {
      m_lastTrialType = analysis::FSUDaceCvtTrialType(value.toInt());
    }
    else {
      m_lastTrialType.reset();
    }
  }
  CloudSessionRecord_Impl::CloudSessionRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : ObjectRecord_Impl(database, query)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(CloudSessionRecord::ColumnsType::cloudSessionRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_cloudSessionRecordType = CloudSessionRecordType(value.toInt());

    value = query.value(CloudSessionRecord::ColumnsType::sessionId);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_sessionId = value.toString().toStdString();

    value = query.value(CloudSessionRecord::ColumnsType::serverUrlRecordId);
    if (value.isValid() && !value.isNull()) {
      m_serverUrlRecordId = value.toInt();
    }
  }
  WorkflowRecord_Impl::WorkflowRecord_Impl(const QSqlQuery& query, const ProjectDatabase& projectDatabase)
    : ObjectRecord_Impl(projectDatabase, query)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(WorkflowRecordColumns::runManagerWorkflowKey);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_runManagerWorkflowKey = value.toString().toStdString();

    value = query.value(WorkflowRecordColumns::problemRecordId);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_problemRecordId = value.toInt();

    value = query.value(WorkflowRecordColumns::workflowIndex);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_workflowIndex = value.toInt();

  }
  bool AWSSettingsRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = CloudSettingsRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(AWSSettingsRecord::ColumnsType::userAgreementSigned);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_userAgreementSigned == value.toBool());

    value = query.value(AWSSettingsRecord::ColumnsType::numWorkers);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_numWorkers == value.toUInt());

    value = query.value(AWSSettingsRecord::ColumnsType::terminationDelayEnabled);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_terminationDelayEnabled == value.toBool());

    value = query.value(AWSSettingsRecord::ColumnsType::terminationDelay);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_terminationDelay == value.toUInt());

    value = query.value(AWSSettingsRecord::ColumnsType::region);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_region == value.toString().toStdString());

    value = query.value(AWSSettingsRecord::ColumnsType::serverInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_serverInstanceType == value.toString().toStdString());

    value = query.value(AWSSettingsRecord::ColumnsType::workerInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_workerInstanceType == value.toString().toStdString());

    return result;
  }
  bool DakotaAlgorithmRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = AlgorithmRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaAlgorithmRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_dakotaAlgorithmRecordType == DakotaAlgorithmRecordType(value.toInt()));

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaRestartFileRecordId);
    if (value.isValid() && !value.isNull()) {
      result = result && m_dakotaRestartFileRecordId && (*m_dakotaRestartFileRecordId == value.toInt());
    }
    else {
      result = result && !m_dakotaRestartFileRecordId;
    }

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaOutFileRecordId);
    if (value.isValid() && !value.isNull()) {
      result = result && m_dakotaOutFileRecordId && (*m_dakotaOutFileRecordId == value.toInt());
    }
    else {
      result = result && !m_dakotaOutFileRecordId;
    }

    value = query.value(DakotaAlgorithmRecord::ColumnsType::jobUUID);
    if (value.isValid() && !value.isNull() && !value.toString().isEmpty()) {
      openstudio::UUID testUUID(value.toString());
      result = result && m_lastJobUUID && (m_lastJobUUID.get() == testUUID);
    }else{
      result = result && !m_lastJobUUID;
    }

    return result;
  }
Beispiel #20
0
QList<WifiNetwork*> DatabaseSQLite::getNetworks()
{
    if (!_db.isOpen())
    {
        throw Exception("Database is closed, can't retrieve networks.");
    }

    QList<WifiNetwork*> networks;
    QString getQuery = "SELECT * FROM WiFi";
    QSqlQuery query = QSqlQuery(_db);
    if (!query.exec(getQuery))
    {
        throw Exception("Failed to execute SQLite select query.");
    }
    if (query.isActive())
    {
        while (query.next())
        {
            int32_t id = query.value(0).toInt();
            QString ssid = query.value(1).toString();
            QString bssid = query.value(2).toString();
            QDateTime firstSeen = query.value(3).toDateTime();
            QDateTime lastSeen = query.value(4).toDateTime();
            uint32_t frequency = query.value(5).toUInt();
            SecurityFlags wpaFlags = (SecurityFlags)query.value(6).toUInt();
            SecurityFlags rsnFlags = (SecurityFlags)query.value(7).toUInt();
            uint32_t bitrate = query.value(8).toUInt();
            QString text = "Wifi %1 loaded from DB: %2 %3 (first  %4) (last  %5) %6 %7 %8 %9";
            text = text.arg(QString::number(id), ssid, bssid, firstSeen.toString(_datetimeFormat), lastSeen.toString(_datetimeFormat),
                            QString::number(frequency), QString::number(wpaFlags), QString::number(rsnFlags), QString::number(bitrate));
            networks.append(new WifiNetwork(id, ssid, bssid, firstSeen, lastSeen, frequency, wpaFlags, rsnFlags, bitrate));
        }
    }
    else
    {
        throw Exception("SQLite select query didn't execute correctly.");
    }
    return networks;
}
QSharedPointer<CompositeFood>
  MySQLBackEnd::createCompositeFoodFromQueryResults
    (QSqlQuery& query)
{
  QSharedPointer<CompositeFoodImpl> food_impl;

  if (query.first()) {

    const QSqlRecord& record = query.record();
    int id = record.field("Composite_Id").value().toInt();

    food_impl = QSharedPointer<CompositeFoodImpl>
      (new CompositeFoodImpl(id,
                             record.field("Description").value().toString(),
                             record.field("User_Id").value().toInt(),
                             record.field("Weight_g").value().toDouble(),
                             record.field("Volume_floz").value().toDouble(),
                             record.field("Quantity").value().toDouble(),
                             record.field("Servings").value().toDouble(),
                             record.field("CreationDate").value().toDate(),
                             record.field("ExpiryDate").value().toDate(),
                             record.field("IsNonce").value().toBool()));

    DataCache<CompositeFood>::getInstance().insert(id, food_impl);
  }

  if (food_impl && query.isActive()) {
    query.seek(-1); // Reset to before first record
    food_impl->setComponents
      (createComponentsFromQueryResults
         (query, food_impl, "CompositeLink_Id", "IntrafoodOrder"));
    if (food_impl->needsToBeReSaved()) {
      food_impl->saveToDatabase();
    }
  }

  return food_impl;
}
QStringList DBManager::GetChannelsURLs()
{ 
    qDebug("in GetChannelsURLs(), dbmanager");
    QStringList channelsList;
    if (! m_pConnector){
        m_pConnector = new DBConnector(this);
        AddDBConnectorSignals();
    }
    QString channelsURLsQuery = "select channel_link from channel_table";
    QSqlQuery result = m_pConnector->RetreiveData(channelsURLsQuery);
    if ( ! result.isValid() ||
            !result.isActive() || !result.first()){
        //the query result is null , damn it
        qDebug("the query result is null , i am in DBManager");
        //return channelsList; // which is an empty list
    }
    //else, the query result is OK
    while (result.next()){
        channelsList.append(result.value(0).toString());
    }
    qDebug("the size of the list: %d",channelsList.size());
    return channelsList;
}
Beispiel #23
0
  bool UrlRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = ObjectRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(UrlRecord::ColumnsType::parentDatabaseTableName);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_parentDatabaseTableName == value.toString().toStdString());

    value = query.value(UrlRecord::ColumnsType::parentRecordId);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_parentRecordId == value.toInt());

    value = query.value(UrlRecord::ColumnsType::url);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_url == openstudio::Url(value.toString()));

    return result;
  }
  InputVariableRecord_Impl::InputVariableRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : VariableRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(VariableRecordColumns::problemRecordId);
    if (value.isValid() && !value.isNull()) {
      m_problemRecordId = value.toInt();
    }

    value = query.value(VariableRecordColumns::inputVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_inputVariableRecordType = InputVariableRecordType(value.toInt());

    value = query.value(VariableRecordColumns::uncertaintyDescriptionType);
    if (value.isValid() && !value.isNull()) {
      m_uncertaintyDescriptionType = analysis::UncertaintyDescriptionType(value.toInt());
    }
  }
Beispiel #25
0
void IconManager::readGlobalIcons()
{
	QString sql = "SELECT name, iconData FROM Icons WHERE catId = 0";
    QSqlQuery *q = new QSqlQuery(db);
    if (!q)
        return;
    if (q->exec(sql))
    {
        if (q->isActive())
        {
            while (q->next())
            {
                QPixmap *pix = 0;
                QByteArray bytes = q->value(1).toByteArray();
                pix = new QPixmap;
                pix->loadFromData(bytes);
                globalIcons[q->value(0).toString()] = pix;
            }
        }
    }
    delete q;
    
}
  bool FSUDaceAlgorithmRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = DakotaAlgorithmRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_algorithmType == analysis::FSUDaceAlgorithmType(value.toInt()));

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceTrialType);
    if (value.isValid() && !value.isNull()) {
      result = result && m_trialType && (*m_trialType == analysis::FSUDaceCvtTrialType(value.toInt()));
    }
    else {
      result = result && !m_trialType;
    }

    return result;
  }
  AWSSettingsRecord_Impl::AWSSettingsRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : CloudSettingsRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(AWSSettingsRecord::ColumnsType::userAgreementSigned);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_userAgreementSigned = value.toBool();

    value = query.value(AWSSettingsRecord::ColumnsType::numWorkers);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_numWorkers = value.toUInt();

    value = query.value(AWSSettingsRecord::ColumnsType::terminationDelayEnabled);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_terminationDelayEnabled = value.toBool();

    value = query.value(AWSSettingsRecord::ColumnsType::terminationDelay);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_terminationDelay = value.toUInt();

    value = query.value(AWSSettingsRecord::ColumnsType::region);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_region = value.toString().toStdString();

    value = query.value(AWSSettingsRecord::ColumnsType::serverInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_serverInstanceType = value.toString().toStdString();

    value = query.value(AWSSettingsRecord::ColumnsType::workerInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_workerInstanceType = value.toString().toStdString();
  }
Beispiel #28
0
int CatalogClass::createCatalog(catalogNode &data)
{
	QSqlQuery *q = NULL;
	int result = -1; // catalog is not created;
	if (data.catName.isEmpty())
		return result;
	q = new QSqlQuery(db);
	if (!q)
		return result;
	if (isExist(data.catName))
	{
		delete q;
		return result;
	}
	QString sql = "INSERT INTO Catalogs(name, description, iconId, catSize, numFiles, numDirs, numGroups, numCD, numDVD, numNetDrives, numFlash, numHDD, numFDD, flags, readPass, writePass, datetime) VALUES('" +
			data.catName + "', '" + data.catDescription + "', '"  +
			QString::number(data.iconId) + "', '" + QString::number(data.catSize)  + "', '" + QString::number(data.numFiles)  + "', '" + QString::number(data.numDirs)  + "', '" + QString::number(data.numGroups) + "', '" +  
			QString::number(data.numCD)  + "', '" + QString::number(data.numDVD) + "', '" + QString::number(data.numNetDrives) + "', '" + QString::number(data.numFlash) + "', '" + QString::number(data.numHDD) + "', '" + 
			QString::number(data.numFDD) + "', '" + QString::number(data.catFlags) + "', '" + data.catReadPass + "', '" + data.catWritePass + "', '" + QString::number(data.dateTime) + "')";
            
            
	//printQS(sql);
	q->exec(sql);
	if (!q->isActive()){
		delete q;
		return result;   
	}
	if (readCatalog(data.catName, data))
		result = data.catId;
	else
		result = 0;
	//printQS("Cat id = " + QString::number(result));
	createCatalogTable(data.catId);
	delete q;
	return result;
        
}
Beispiel #29
0
AWSSessionRecord_Impl::AWSSessionRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : CloudSessionRecord_Impl(query, database)
{
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(AWSSessionRecord::ColumnsType::numServerProcessors);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_numServerProcessors = value.toUInt();

    value = query.value(AWSSessionRecord::ColumnsType::numWorkerProcessors);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_numWorkerProcessors = value.toUInt();

    value = query.value(AWSSessionRecord::ColumnsType::privateKey);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_privateKey = value.toString().toStdString();

    value = query.value(AWSSessionRecord::ColumnsType::timestamp);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_timestamp = value.toString().toStdString();

    value = query.value(AWSSessionRecord::ColumnsType::region);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_region = value.toString().toStdString();

    value = query.value(AWSSessionRecord::ColumnsType::serverInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_serverInstanceType = value.toString().toStdString();

    value = query.value(AWSSessionRecord::ColumnsType::workerInstanceType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_workerInstanceType = value.toString().toStdString();
}
  void DakotaAlgorithmRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    AlgorithmRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaAlgorithmRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastDakotaAlgorithmRecordType = DakotaAlgorithmRecordType(value.toInt());

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaRestartFileRecordId);
    if (value.isValid() && !value.isNull()) {
      m_lastDakotaRestartFileRecordId = value.toInt();
    }
    else {
      m_lastDakotaRestartFileRecordId.reset();
    }

    value = query.value(DakotaAlgorithmRecord::ColumnsType::dakotaOutFileRecordId);
    if (value.isValid() && !value.isNull()) {
      m_lastDakotaOutFileRecordId = value.toInt();
    }
    else {
      m_lastDakotaOutFileRecordId.reset();
    }

    value = query.value(DakotaAlgorithmRecord::ColumnsType::jobUUID);
    if (value.isValid() && !value.isNull() && !value.toString().isEmpty()) {
      m_lastJobUUID = openstudio::UUID(value.toString());
    }else{
      m_lastJobUUID.reset();
    }
  }