InformationServer/Information Server/Datenbank.cpp

#include "Datenbank.h"
#include <Zeit.h>
#include "AccountHistorieDaten.h"
#include "KartenLeser.h"

// Inhalt der LSDatenbank Klasse aus Datenbank.h
// Konstruktor
ISDatenbank::ISDatenbank( InitDatei *zIni )
{
	if( !zIni->wertExistiert( "DBBenutzer" ) )
		zIni->addWert( "DBBenutzer", "informationserveru" );
	if( !zIni->wertExistiert( "DBPasswort" ) )
		zIni->addWert( "DBPasswort", "LTInformationServerPW" );
	if( !zIni->wertExistiert( "DBName" ) )
		zIni->addWert( "DBName", "lenck_tech_db" );
	if( !zIni->wertExistiert( "DBIP" ) )
		zIni->addWert( "DBIP", "127.0.0.1" );
	if( !zIni->wertExistiert( "DBPort" ) )
		zIni->addWert( "DBPort", "5432" );
	datenbank = new Datenbank( zIni->zWert( "DBBenutzer" )->getText(), zIni->zWert( "DBPasswort" )->getText(),
							   zIni->zWert( "DBName" )->getText(), zIni->zWert( "DBIP" )->getText(),
							   (unsigned short)TextZuInt( zIni->zWert( "DBPort" )->getText(), 10 ) );
	InitializeCriticalSection( &cs );
	ref = 1;
}

// Destruktor
ISDatenbank::~ISDatenbank()
{
	datenbank->release();
	DeleteCriticalSection( &cs );
}

// nicht constant
void ISDatenbank::lock()
{
	EnterCriticalSection( &cs );
}

void ISDatenbank::unlock()
{
	LeaveCriticalSection( &cs );
}

int ISDatenbank::istAdministrator( const char *name, const char *passwort )
{
	Text *befehl = new Text( "SELECT id FROM benutzer WHERE name = '" );
	befehl->anhängen( name );
	befehl->anhängen( "' AND passwort = '" );
	befehl->anhängen( passwort );
	befehl->anhängen( "'" );
	lock();
	datenbank->befehl( befehl->getText() );
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	int ret = 0;
	if( res.zeilenAnzahl > 0 )
		ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

bool ISDatenbank::adminHatRecht( int id, int recht )
{
	Text *befehl = new Text( "SELECT * FROM benutzer_rechte WHERE benutzer_id = " );
	befehl->anhängen( id );
	befehl->anhängen( " AND rechte_id = " );
	befehl->anhängen( recht );
	lock();
	datenbank->befehl( befehl->getText() );
	int ret = datenbank->getZeilenAnzahl();
	unlock();
	befehl->release();
	return ret != 0;
}

bool ISDatenbank::prüfKlient( int num, int sNum )
{
	Text *befehl = new Text( "SELECT * FROM server_information_clients WHERE server_information_id = " );
	befehl->anhängen( sNum );
	befehl->anhängen( " AND client_id = " );
	befehl->anhängen( num );
	lock();
	datenbank->befehl( befehl->getText() );
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	bool ret = 0;
	if( res.zeilenAnzahl == 1 )
		ret = 1;
	res.destroy();
	return ret;
}

Text *ISDatenbank::getKlientSchlüssel( int cId )
{
	lock();
	if( !datenbank->befehl( Text( "SELECT schluessel FROM clients WHERE id = " ) += cId ) )
	{
		unlock();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

void ISDatenbank::unregisterKlient( int num, int sNum )
{
	Text *befehl = new Text( "DELETE FROM server_information_clients WHERE client_id = " );
	befehl->anhängen( num );
	befehl->anhängen( " AND server_information_id = " );
	befehl->anhängen( sNum );
	lock();
	datenbank->befehl( befehl->getText() );
	int za = datenbank->getZeilenAnzahl();
	unlock();
	if( za == 1 )
	{
		befehl->setText( "UPDATE server_information SET clients = clients - 1 WHERE id = " );
		befehl->anhängen( sNum );
		lock();
		datenbank->befehl( befehl->getText() );
		unlock();
	}
	befehl->release();
}

bool ISDatenbank::serverAnmelden( InitDatei *zIni )
{
	if( !zIni->wertExistiert( "ServerId" ) )
		zIni->addWert( "ServerId", "0" );
	if( !zIni->wertExistiert( "ServerName" ) )
		zIni->addWert( "ServerName", "Name" );
	if( !zIni->wertExistiert( "ServerPort" ) )
		zIni->addWert( "ServerPort", "49144" );
	if( !zIni->wertExistiert( "ServerIP" ) )
		zIni->addWert( "ServerIP", "127.0.0.1" );
	if( !zIni->wertExistiert( "AdminServerPort" ) )
		zIni->addWert( "AdminServerPort", "49143" );
	if( !zIni->wertExistiert( "Aktiv" ) )
		zIni->addWert( "Aktiv", "FALSE" );
	if( !zIni->wertExistiert( "MaxClients" ) )
		zIni->addWert( "MaxClients", "50" );
	bool insert = 0;
	int id = *zIni->zWert( "ServerId" );
	if( id )
	{
		lock();
		if( !datenbank->befehl( Text( "SELECT id FROM server_information WHERE id = " ) += id ) )
		{
			unlock();
			return 0;
		}
		int anz = datenbank->getZeilenAnzahl();
		unlock();
		insert = anz == 0;
		if( !insert )
		{
			lock();
			if( !datenbank->befehl( Text( "SELECT id FROM server_information WHERE server_status_id = 1 AND id = " ) += id ) )
			{
				unlock();
				return 0;
			}
			int anz = datenbank->getZeilenAnzahl();
			unlock();
			if( !anz ) // Server läuft bereits
				return 0;
		}
	}
	if( insert || !id )
	{ // Neuer Eintrag in Tabelle server_information
		Text *befehl = new Text( "INSERT INTO server_information( " );
		if( id )
			*befehl += "id, ";
		*befehl += "name, ip, port, admin_port, server_status_id, max_clients ) VALUES( ";
		if( id )
		{
			*befehl += id;
			*befehl += ", ";
		}
		*befehl += "'";
		*befehl += zIni->zWert( "ServerName" )->getText();
		*befehl += "', '";
		*befehl += zIni->zWert( "ServerIP" )->getText();
		*befehl += "', ";
		*befehl += zIni->zWert( "ServerPort" )->getText();
		*befehl += ", ";
		*befehl += zIni->zWert( "AdminServerPort" )->getText();
		*befehl += ", 1, ";
		*befehl += zIni->zWert( "MaxClients" )->getText();
		*befehl += " ) RETURNING id";
		lock();
		if( !datenbank->befehl( *befehl ) )
		{
			unlock();
			befehl->release();
			return 0;
		}
		Result res = datenbank->getResult();
		unlock();
		befehl->release();
		if( !res.zeilenAnzahl )
		{
			res.destroy();
			return 0;
		}
		zIni->setWert( "ServerId", res.values[ 0 ] );
		return 1;
	}
	else
	{ // Alten Eintrag aus Tabelle server_information ändern
		Text *befehl = new Text( "UPDATE server_information SET name = '" );
		*befehl += zIni->zWert( "ServerName" )->getText();
		*befehl += "', port = ";
		*befehl += zIni->zWert( "ServerPort" )->getText();
		*befehl += ", ip = '";
		*befehl += zIni->zWert( "ServerIP" )->getText();
		*befehl += "', max_clients = ";
		*befehl += zIni->zWert( "MaxClients" )->getText();
		*befehl += ", admin_port = ";
		*befehl += zIni->zWert( "AdminServerPort" )->getText();
		*befehl += " WHERE id = ";
		*befehl += id;
		lock();
		bool ret = datenbank->befehl( *befehl );
		unlock();
		befehl->release();
		return ret;
	}
}

bool ISDatenbank::setServerStatus( int id, int status )
{
	Text *befehl = new Text( "UPDATE server_information SET server_status_id = " );
	*befehl += status;
	*befehl += "WHERE id = ";
	*befehl += id;
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	bool ret = datenbank->getZeilenAnzahl() != 0;
	unlock();
	befehl->release();
	return ret;
}

bool ISDatenbank::setMaxClients( int id, int maxC )
{
	Text *befehl = new Text( "UPDATE server_information SET max_clients = " );
	befehl->anhängen( maxC );
	befehl->anhängen( " WHERE id = " );
	befehl->anhängen( id );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	bool ret = datenbank->getZeilenAnzahl() > 0;
	unlock();
	befehl->release();
	return ret;
}

int ISDatenbank::getAdminPort( int id )
{
	Text *befehl = new Text( "SELECT admin_port FROM server_information WHERE id = " );
	befehl->anhängen( id );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

bool ISDatenbank::serverIstNichtPausiert( int id )
{
	Text *befehl = new Text( "SELECT server_status_id FROM server_information WHERE id = " );
	befehl->anhängen( id );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	bool ret = (int)res.values[ 0 ] == 3;
	res.destroy();
	return ret;
}

Text *ISDatenbank::getInformationsText( char *typ )
{
	lock();
	if( !datenbank->befehl( "SELECT text, typ FROM info_text ORDER BY insert_datum DESC LIMIT 1" ) )
	{
		unlock();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		*typ = 0;
		return 0;
	}
	*typ = (char)TextZuInt( res.values[ 1 ].getText(), 10 );
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

bool ISDatenbank::istSpielErlaubt( int spielId )
{
	Text *befehl = new Text( "SELECT erlaubt FROM spiel_art WHERE id = " );
	befehl->anhängen( spielId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	bool ret = 0;
	if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
		ret = 1;
	res.destroy();
	return ret;
}

bool ISDatenbank::istKarteErlaubt( int karteId )
{
	Text *befehl = new Text( "SELECT erlaubt FROM karte WHERE id = " );
	befehl->anhängen( karteId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	bool ret = 0;
	if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
		ret = 1;
	res.destroy();
	return ret;
}

Text *ISDatenbank::getAccountRufName( int accountId )
{
	Text *befehl = new Text( "SELECT ruf_name FROM account WHERE id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

int ISDatenbank::getAccountId( char *rufName )
{
	Text *befehl = new Text( "SELECT id FROM account WHERE ruf_name = '" );
	befehl->anhängen( rufName );
	befehl->anhängen( "' LIMIT 1" );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

Array< int > *ISDatenbank::getAccountSpielStatistik( int accountId, int spielId )
{
	Text *befehl = new Text( "SELECT gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5 FROM spiel_statistik WHERE account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " AND spiel_art_id = " );
	befehl->anhängen( spielId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	Array< int > *ret = new Array< int >();
	if( !res.zeilenAnzahl )
	{
		for( int i = 0; i < res.feldAnzahl; i++ )
			ret->add( 0, i );
		res.destroy();
		return ret;
	}
	for( int i = 0; i < res.feldAnzahl; i++ )
		ret->add( TextZuInt( res.values[ i ].getText(), 10 ), i );
	res.destroy();
	return ret;
}

int ISDatenbank::getAccountKarteSpiele( int accountId, int karteId )
{
	Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " AND a.karte_id = " );
	befehl->anhängen( karteId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = res.values[ 0 ];
	res.destroy();
	return ret;
}

int ISDatenbank::getAccountKarteSpieleGewonnen( int accountId, int karteId )
{
	Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id "
							 "AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " AND a.karte_id = " );
	befehl->anhängen( karteId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = res.values[ 0 ];
	res.destroy();
	return ret;
}

Text *ISDatenbank::getKarteName( int karteId )
{
	Text *befehl = new Text( "SELECT name FROM karte WHERE id = " );
	befehl->anhängen( karteId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

Text *ISDatenbank::getSpielName( int spielId )
{
	Text *befehl = new Text( "SELECT name FROM spiel_art WHERE id = " );
	befehl->anhängen( spielId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

Text *ISDatenbank::getChatroomName( int chatroomId )
{
	Text *befehl = new Text( "SELECT name FROM chatroom WHERE id = " );
	befehl->anhängen( chatroomId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

int ISDatenbank::getChatroomId( char *name )
{
	Text *befehl = new Text( "SELECT id FROM chatroom WHERE name = '" );
	befehl->anhängen( name );
	befehl->anhängen( "' LIMIT 1" );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getSpielId( int karteId )
{
	Text *befehl = new Text( "SELECT spiel_art_id FROM karte WHERE id = " );
	befehl->anhängen( karteId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getSpielId( char *name )
{
	Text *befehl = new Text( "SELECT id FROM spiel_art WHERE name = '" );
	befehl->anhängen( name );
	befehl->anhängen( "'" );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getKarteId( char *name )
{
	Text *befehl = new Text( "SELECT id FROM karte WHERE name = '" );
	befehl->anhängen( name );
	befehl->anhängen( "'" );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getGruppenKarteId( int gruppeId )
{
	Text *befehl = new Text( "SELECT karte_id FROM gruppe WHERE id = " );
	befehl->anhängen( gruppeId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getGruppeAdminId( int gruppeId )
{
	Text *befehl = new Text( "SELECT admin_account_id FROM gruppe WHERE id = " );
	befehl->anhängen( gruppeId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getSpielerPunkte( int spielId, int accountId )
{
	Text *befehl = new Text( "SELECT sum( b.punkte ) FROM spiel a, spiel_spieler b, karte c WHERE a.karte_id = c.id "
							 "AND a.spiel_status_id = 5 AND c.spiel_art_id = " );
	befehl->anhängen( spielId );
	befehl->anhängen( " AND b.spiel_id = a.id AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

Array< int > *ISDatenbank::getAccountSpielArtListe( int cId )
{
	Text *befehl = new Text( "SELECT a.spiel_art_id FROM spiel_art_account a, account_clients b "
							 "WHERE a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
	befehl->anhängen( cId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	Array< int > *ret = new Array< int >();
	for( int i = 0; i < res.zeilenAnzahl; i++ )
		ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
	res.destroy();
	return ret;
}

int ISDatenbank::getNeusteSpielVersion( int sId )
{
	Text *befehl = new Text( "SELECT a.version FROM datei_gruppe a, spiel_art b WHERE a.id = b.datei_gruppe_id AND b.id = " );
	befehl->anhängen( sId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getKupfer( int cId )
{
	Text *befehl = new Text( "SELECT a.kupfer FROM account a, account_clients b WHERE a.id = b.account_id AND b.client_id = " );
	befehl->anhängen( cId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getDateiGruppeVonSpiel( int sId )
{
	Text *befehl = new Text( "SELECT datei_gruppe_id FROM spiel_art WHERE id = " );
	befehl->anhängen( sId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

Text *ISDatenbank::getDateiGruppePfad( int dgId )
{
	Text *befehl = new Text( "SELECT pfad FROM datei_gruppe WHERE id = " );
	befehl->anhängen( dgId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	Text *ret = new Text( res.values[ 0 ].getText() );
	res.destroy();
	return ret;
}

Array< int > *ISDatenbank::getAccountKarteListe( int cId, int sId )
{
	Text *befehl = new Text( "SELECT a.karte_id FROM karte_account a, account_clients b, karte c "
							 "WHERE c.id = a.karte_id AND a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
	befehl->anhängen( cId );
	befehl->anhängen( " AND c.spiel_art_id = " );
	befehl->anhängen( sId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	Array< int > *ret = new Array< int >();
	for( int i = 0; i < res.zeilenAnzahl; i++ )
		ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
	res.destroy();
	return ret;
}

bool ISDatenbank::hatAccountKarte( int account, int karte )
{
	Text *befehl = new Text( "SELECT karte_id FROM karte_account WHERE end_dat IS NULL AND karte_id = " );
	befehl->anhängen( karte );
	befehl->anhängen( " AND account_id = " );
	befehl->anhängen( account );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	bool ret = datenbank->getZeilenAnzahl() != 0;
	unlock();
	befehl->release();
	return ret;
}

bool ISDatenbank::hatAccountSpiel( int account, int spiel )
{
	Text *befehl = new Text( "SELECT spiel_art_id FROM spiel_art_account WHERE end_dat IS NULL AND spiel_art_id = " );
	befehl->anhängen( spiel );
	befehl->anhängen( " AND account_id = " );
	befehl->anhängen( account );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	bool ret = datenbank->getZeilenAnzahl() != 0;
	unlock();
	befehl->release();
	return ret;
}

Array< int > *ISDatenbank::getAccountKarteGespieltListe( int accountId, int spielArt )
{
	Text *befehl = new Text( "SELECT distinct( c.id ) FROM spiel a, spiel_spieler b, karte c WHERE "
							 "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " AND c.spiel_art_id = " );
	befehl->anhängen( spielArt );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	Array< int > *ret = new Array< int >();
	for( int i = 0; i < res.zeilenAnzahl; i++ )
		ret->set( res.values[ i ], i );
	res.destroy();
	return ret;
}

Array< int > *ISDatenbank::getAccountSpielGespieltListe( int accountId )
{
	Text *befehl = new Text( "SELECT distinct( c.spiel_art_id ) FROM spiel a, spiel_spieler b, karte c WHERE "
							 "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	Array< int > *ret = new Array< int >();
	for( int i = 0; i < res.zeilenAnzahl; i++ )
		ret->set( res.values[ i ], i );
	res.destroy();
	return ret;
}

int ISDatenbank::getDateiGruppeVonPfad( char *pfad )
{
	Text *befehl = new Text( "SELECT id FROM datei_gruppe WHERE pfad = '" );
	befehl->anhängen( pfad );
	befehl->anhängen( "'" );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

int ISDatenbank::getNeusteDateiGruppe( int dg )
{
	Text *befehl = new Text( "SELECT version FROM datei_gruppe WHERE id = " );
	befehl->anhängen( dg );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
	res.destroy();
	return ret;
}

bool ISDatenbank::getGruppeSpielerHinzufügen( int gruppeId )
{
	Text *befehl = new Text( "SELECT spiel_starten FROM gruppe WHERE id = " );
	befehl->anhängen( gruppeId );
	lock();
	if( !datenbank->befehl( befehl->getText() ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	bool ret = res.values[ 0 ].istGleich( "f" );
	res.destroy();
	return ret;
}

Result ISDatenbank::getSpielerListe( char *suche, int *seite, int *maxSeite, int sortStalte, bool rückwärts )
{
	Text *befehl = new Text( "SELECT count( a.id ) FROM account a, "
							 "( SELECT a.id, max( b.datum ) "
							 "  FROM account a LEFT JOIN "
							 "  ( SELECT g.spiel_art_id, i.account_id, max( h.beginn_datum ) "
							 "    FROM karte g, spiel h, spiel_spieler i "
							 "    WHERE i.spiel_id = h.id AND h.karte_id = g.id "
							 "    GROUP BY g.spiel_art_id, i.account_id ) f ON a.id = f.account_id "
							 "  LEFT JOIN account_online b ON b.account_id = a.id "
							 "  LEFT JOIN spiel_statistik e ON e.account_id = a.id "
							 "  LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
							 "  LEFT JOIN karte d ON c.id = d.spiel_art_id "
							 "  WHERE a.name LIKE '" );
	befehl->anhängen( suche );
	befehl->anhängen( "' AND d.spiel_art_id = c.id "
					  "  AND e.spiel_art_id = f.spiel_art_id "
					  "  GROUP BY a.id ) b "
					  "WHERE a.id = b.id" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	Result res = datenbank->getResult();
	unlock();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	int einträge = res.values[ 0 ];
	res.destroy();
	*maxSeite = einträge / 21;
	if( einträge % 21 )
		( *maxSeite )++;
	if( *seite > *maxSeite )
		*seite = *maxSeite;
	if( !( *seite ) )
	{
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	befehl->setText( "SELECT a.id, a.ruf_name, max( b.datum ), c.name, d.name, e.punkte "
					 "FROM account a LEFT JOIN "
					 "( SELECT g.spiel_art_id, i.account_id, max( h.beginn_datum ) "
					 "  FROM karte g, spiel h, spiel_spieler i "
					 "  WHERE i.spiel_id = h.id AND h.karte_id = g.id "
					 "  GROUP BY g.spiel_art_id, i.account_id ) f ON a.id = f.account_id "
					 "LEFT JOIN account_online b ON b.account_id = a.id "
					 "LEFT JOIN spiel_statistik e ON e.account_id = a.id "
					 "LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
					 "LEFT JOIN karte d ON c.id = d.spiel_art_id "
					 "WHERE a.name LIKE '" );
	befehl->anhängen( suche );
	befehl->anhängen( "' AND ( d.spiel_art_id = c.id "
					  "AND e.spiel_art_id = f.spiel_art_id ) "
					  "OR d.spiel_art_id IS NULL "
					  "GROUP BY a.id, a.ruf_name, c.name, d.name, e.punkte ORDER BY " );
	befehl->anhängen( sortStalte + 2 );
	if( rückwärts )
		befehl->anhängen( " DESC" );
	befehl->anhängen( " OFFSET " );
	befehl->anhängen( ( ( *seite ) - 1 ) * 21 );
	befehl->anhängen( " LIMIT 21" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	res = datenbank->getResult();
	unlock();
	befehl->release();
	return res;
}

bool ISDatenbank::getSpielerAktivität( int accountId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt,
									   Array< int > *anzSpiele, Array< int > *anzGewonnen )
{
	Datum *beg = getDatum();
	Datum *end = getDatum();
	beg->minusTag( 29 );
	end->minusTag( 29 );
	end->plusTag( 1 );
	for( int i = 0; i < 30; i++ )
	{ // 30 Tage Rückblick
		datum->set( beg->getDatum( "d-m-y" ), i );
		Text *b = beg->getDatum( "y-m-d" );
		Text *e = end->getDatum( "y-m-d" );
		stOnline->set( getOnlineSeconds( accountId, *b, *e ) / ( 60.0 * 60 ), i );
		stGespielt->set( getGespieltSeconds( accountId, *b, *e ) / ( 60.0 * 60 ), i );
		anzSpiele->set( getGespieltSpiele( accountId, *b, *e ), i );
		anzGewonnen->set( getGewonnenSpiele( accountId, *b, *e ), i );
		b->release();
		e->release();
		beg->plusTag( 1 );
		end->plusTag( 1 );
	}
	return 1;
}

int ISDatenbank::getOnlineSeconds( int accountId, char *beg, char *end )
{
	int sec = 0;
	Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM account_online WHERE datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND end_datum IS NULL AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - datum ) FROM account_online WHERE datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND end_datum IS NULL AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "' - datum ) FROM account_online WHERE datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND end_datum IS NULL AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "'::TIMESTAMP WITH TIME ZONE - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM account_online WHERE datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND end_datum IS NULL AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM account_online WHERE datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND end_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - datum ) FROM account_online WHERE datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "' - datum ) FROM account_online WHERE datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND end_datum > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "'::TIMESTAMP WITH TIME ZONE - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM account_online WHERE datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND end_datum > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->release();
	return sec;
}

int ISDatenbank::getGespieltSeconds( int accountId, char *beg, char *end )
{
	int sec = 0;
	Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.beginn_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "'::TIMESTAMP WITH TIME ZONE - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND now() > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.beginn_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.id = b.spiel_id AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
	befehl->anhängen( end );
	befehl->anhängen( "'::TIMESTAMP WITH TIME ZONE - '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum > '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.id = b.spiel_id AND account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " )::INTERVAL )" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		sec += (int)res.values[ 0 ];
	res.destroy();
	befehl->release();
	return sec;
}

int ISDatenbank::getGespieltSpiele( int accountId, char *beg, char *end )
{
	int anz = 0;
	Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		anz += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		anz += (int)res.values[ 0 ];
	res.destroy();
	befehl->release();
	return anz;
}

int ISDatenbank::getGewonnenSpiele( int accountId, char *beg, char *end )
{
	int anz = 0;
	Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.end_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		anz += (int)res.values[ 0 ];
	res.destroy();
	befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
	befehl->anhängen( beg );
	befehl->anhängen( "' AND a.end_datum < '" );
	befehl->anhängen( end );
	befehl->anhängen( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	res = datenbank->getResult();
	unlock();
	if( res.zeilenAnzahl )
		anz += (int)res.values[ 0 ];
	res.destroy();
	befehl->release();
	return anz;
}

Result ISDatenbank::getSpielPartnerListe( int accountId )
{
	Text *befehl = new Text( "SELECT account_id_b, anzahl, karte_id FROM account_mitspieler WHERE account_id_a = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	Result res = datenbank->getResult();
	unlock();
	befehl->release();
	return res;
}

Result ISDatenbank::getSpielStatistikListe( int accountId, int *seite, int *maxSeite, int sortStalte, bool rückwärts )
{
	Text *befehl = new Text( "SELECT count( spiel_art_id ) FROM spiel_statistik WHERE account_id = " );
	befehl->anhängen( accountId );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	Result res = datenbank->getResult();
	unlock();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	int einträge = res.values[ 0 ];
	res.destroy();
	*maxSeite = einträge / 21;
	if( einträge % 21 )
		( *maxSeite )++;
	if( *seite > *maxSeite )
		*seite = *maxSeite;
	if( !( *seite ) )
	{
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	befehl->setText( "SELECT a.id, a.name, b.gespielt, b.gewonnen, b.verloren, b.punkte, b.bw0, b.bw1, b.bw2, b.bw3, "
					 "b.bw4, b.bw5 FROM spiel_art a, spiel_statistik b WHERE a.id = b.spiel_art_id AND b.account_id = " );
	befehl->anhängen( accountId );
	befehl->anhängen( " ORDER BY " );
	befehl->anhängen( sortStalte + 2 );
	if( rückwärts )
		befehl->anhängen( " DESC" );
	befehl->anhängen( " OFFSET " );
	befehl->anhängen( ( ( *seite ) - 1 ) * 18 );
	befehl->anhängen( " LIMIT 18" );
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	res = datenbank->getResult();
	unlock();
	befehl->release();
	return res;
}

AHDaten *ISDatenbank::getSpielHistorie( int accountId, InformationServer *is )
{
	Text *befehl = new Text( "SELECT a.id, a.karte_id, c.name, d.name, substring( a.beginn_datum::CHARACTER VARYING FOR 16 ), "
							 "b.spiel_spieler_status_id, a.spiel_status_id, count( e.spiel_id ) "
							 "FROM spiel a, spiel_spieler b, spiel_art c, karte d, (SELECT spiel_id FROM spiel_spieler) e "
							 "WHERE a.id = e.spiel_id AND a.karte_id = d.id AND d.spiel_art_id = c.id "
							 "AND a.id = b.spiel_id AND b.account_id = " );
	*befehl += accountId;
	*befehl += " GROUP BY a.id, a.karte_id, c.name, d.name, a.beginn_datum, b.spiel_spieler_status_id, a.spiel_status_id "
			   "ORDER BY beginn_datum DESC LIMIT 20";
	lock();
	if( !datenbank->befehl( *befehl ) )
	{
		unlock();
		befehl->release();
		return 0;
	}
	Result spielListe = datenbank->getResult();
	unlock();
	AHDaten *ret = new AHDaten();
	for( int i = 0; i < spielListe.zeilenAnzahl; i++ )
	{
		SpielerTeamStruktur *sts = new SpielerTeamStruktur();
		bool stsOK = 1;
		KartenLeser *reader = new KartenLeser( spielListe.values[ 1 + i * spielListe.feldAnzahl ], is );
		if( !reader->ladeSpielerTeamStruktur( sts ) )
			stsOK = 0;
		reader->release();
		AHSpielDaten *spiel = new AHSpielDaten();
		spiel->id = spielListe.values[ i * spielListe.feldAnzahl ];
		spiel->karteId = spielListe.values[ 1 + i * spielListe.feldAnzahl ];
		spiel->spiel->setText( spielListe.values[ 2 + i * spielListe.feldAnzahl ] );
		spiel->karte->setText( spielListe.values[ 3 + i * spielListe.feldAnzahl ] );
		spiel->datum->setText( spielListe.values[ 4 + i * spielListe.feldAnzahl ] );
		switch( (int)spielListe.values[ 5 + i * spielListe.feldAnzahl ] )
		{
		case 1:
			spiel->status->setText( "Verloren" );
			break;
		case 2:
			spiel->status->setText( "Gewonnen" );
			break;
		case 3:
			spiel->status->setText( "Nicht Anwesend" );
			break;
		case 4:
			spiel->status->setText( "Beobachter" );
			break;
		case 5:
			spiel->status->setText( "Unentschieden" );
			break;
		}
		switch( (int)spielListe.values[ 6 + i * spielListe.feldAnzahl ] )
		{
		case 1:
			spiel->spielStatus->setText( "Beginnt" );
			break;
		case 2:
			spiel->spielStatus->setText( "Läuft" );
			break;
		case 3:
			spiel->spielStatus->setText( "Abgebrochen" );
			break;
		case 4:
			spiel->spielStatus->setText( "Fehlerhaft" );
			break;
		case 5:
			spiel->spielStatus->setText( "Beendet" );
			break;
		case 6:
			spiel->spielStatus->setText( "Unbewertet" );
			break;
		}
		spiel->sAnzahl = spielListe.values[ 7 + i * spielListe.feldAnzahl ];
		*befehl = "SELECT substring( (end_datum - beginn_datum)::CHARACTER VARYING FOR 8) FROM spiel WHERE id = ";
		*befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
		lock();
		if( datenbank->befehl( *befehl ) )
		{
			Result dauer = datenbank->getResult();
			unlock();
			if( dauer.zeilenAnzahl && dauer.values[ 0 ].getLänge() )
				spiel->dauer->setText( dauer.values[ 0 ] );
		}
		else
			unlock();
		int gewinnerTeam = -1;
		if( stsOK )
		{
			*befehl = "SELECT team_id FROM spiel_spieler WHERE spiel_spieler_status_id = 2 AND spiel_id = ";
			*befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
			lock();
			if( datenbank->befehl( *befehl ) )
			{
				Result team = datenbank->getResult();
				unlock();
				if( team.zeilenAnzahl && team.values[ 0 ].getLänge() && sts->teamName->z( team.values[ 0 ] ) )
				{
					spiel->gewinner->setText( sts->teamName->z( team.values[ 0 ] )->getText() );
					gewinnerTeam = team.values[ 0 ];
				}
			}
			else
				unlock();
		}
		*befehl = "SELECT a.ruf_name, b.team_id, b.punkte, b.spiel_spieler_status_id, b.spieler_nummer FROM account a, spiel_spieler b WHERE b.account_id = a.id AND spiel_id = ";
		*befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
		*befehl += " ORDER BY team_id";
		lock();
		if( datenbank->befehl( *befehl ) )
		{
			Result spielerListe = datenbank->getResult();
			unlock();
			for( int j = 0; j < spielerListe.zeilenAnzahl; j++ )
			{
				int tAnz = spiel->teams->getEintragAnzahl();
				int index = -1;
				for( int k = 0; k < tAnz; k++ )
				{
					if( spiel->teams->z( k )->id == (int)spielerListe.values[ 1 + j * spielerListe.feldAnzahl ] )
					{
						index = k;
						break;
					}
				}
				if( index < 0 )
				{
					index = tAnz;
					AHSpielTeamDaten *team = new AHSpielTeamDaten();
					team->id = spielerListe.values[ 1 + j * spielerListe.feldAnzahl ];
					if( sts->teamName->z( team->id ) )
						team->name->setText( sts->teamName->z( team->id )->getText() );
					team->sAnzahl = 0;
					if( team->id == gewinnerTeam )
						team->status->setText( "Gewonnen" );
					else
						team->status->setText( "Verloren" );
					if( sts->teamFarbe->hat( team->id ) )
						team->farbe = sts->teamFarbe->get( team->id );
					else
						team->farbe = 0;
					spiel->teams->set( team, index );
				}
				AHSpielSpielerDaten *spieler = new AHSpielSpielerDaten();
				spieler->name->setText( spielerListe.values[ j * spielerListe.feldAnzahl ] );
				spieler->punkte = spielerListe.values[ 2 + j * spielerListe.feldAnzahl ];
				if( sts->spielerFarbe->hat( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 ) )
					spieler->farbe = sts->spielerFarbe->get( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 );
				else
					spieler->farbe = 0;
				switch( (int)spielerListe.values[ 3 + j * spielerListe.feldAnzahl ] )
				{
				case 1:
					spieler->status->setText( "Verloren" );
					break;
				case 2:
					spieler->status->setText( "Gewonnen" );
					break;
				case 3:
					spieler->status->setText( "Nicht Anwesend" );
					break;
				case 4:
					spieler->status->setText( "Beobachter" );
					break;
				case 5:
					spieler->status->setText( "Unentschieden" );
					break;
				}
				spiel->teams->z( index )->sAnzahl++;
				spiel->teams->z( index )->spieler->add( spieler );
			}
		}
		else
			unlock();
		sts->release();
		ret->spiele->set( spiel, i );
	}
	return ret;
}

bool ISDatenbank::getHistorieServerPortIp( int clientId, int spielId, int *port, Text *ip )
{
	lock();
	if( !datenbank->befehl( Text( "SELECT a.id, a.port, a.ip FROM server_historie a, server_historie_spiel b "
								  "WHERE a.id = b.server_historie_id AND a.clients < a.max_clients - 1 AND "
								  "a.server_status_id = 3 AND b.spiel_id = " ) += spielId ) )
	{
		unlock();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	if( !res.zeilenAnzahl )
	{
		res.destroy();
		return 0;
	}
	int id = res.values[ 0 ];
	*port = res.values[ 1 ];
	*ip = res.values[ 2 ].getText();
	res.destroy();
	Text *befehl = new Text( "INSERT INTO server_historie_clients( client_id, server_historie_id ) VALUES ( " );
	befehl->anhängen( clientId );
	befehl->anhängen( ", " );
	befehl->anhängen( id );
	befehl->anhängen( " )" );
	bool ret = 1;
	lock();
	ret &= datenbank->befehl( Text( "SELECT server_historie_id FROM server_historie_clients WHERE client_id = " ) += clientId );
	res = datenbank->getResult();
	if( res.zeilenAnzahl )
		ret &= datenbank->befehl( Text( "UPDATE server_historie SET clients = clients - 1 WHERE id = " ) += res.values[ 0 ] );
	res.destroy();
	ret &= datenbank->befehl( Text( "DELETE FROM server_historie_clients WHERE client_id = " ) += clientId );
	ret &= datenbank->befehl( *befehl );
	ret &= datenbank->befehl( Text( "UPDATE server_historie SET clients = clients + 1 WHERE id = " ) += id );
	unlock();
	befehl->release();
	return ret;
}

bool ISDatenbank::hatKlientRecht( int kId, int recht )
{
	Text befehl = "SELECT a.* FROM account_user_rechte a, account_clients b WHERE a.account_id = b.account_id AND b.client_id = ";
	befehl += kId;
	befehl += " AND a.user_rechte_id = ";
	befehl += recht;
	lock();
	datenbank->befehl( befehl );
	int num = datenbank->getZeilenAnzahl();
	unlock();
	return num == 1;
}

Result ISDatenbank::getKartenListe( int kId, char *suchFilter, char sortSpalte, char sortRichtung )
{
	Text befehl = "SELECT a.id, a.name, b.name, c.kupfer, a.verkauft, a.max_spieler FROM karte a ";
	befehl += "INNER JOIN spiel_art b ON a.spiel_art_id = b.id ";
	befehl += "LEFT JOIN karte_kauf_erlaubt c ON a.id = c.karte_id ";
	befehl += "INNER JOIN account_clients d ON d.account_id = a.account_id ";
	befehl += "WHERE d.client_id = ";
	befehl += kId;
	befehl += " AND a.name LIKE'%";
	befehl += suchFilter;
	befehl += "%' ORDER BY ";
	befehl += sortSpalte + 2;
	if( sortRichtung ) // absteigend
		befehl += " DESC";
	lock();
	if( !datenbank->befehl( befehl ) )
	{
		unlock();
		Result res = { 0, 0, 0, 0 };
		return res;
	}
	Result res = datenbank->getResult();
	unlock();
	return res;
}

bool ISDatenbank::getEditorServerPortIp( int clientId, int karteId, int *port, Text *ip )
{
	Text befehl = "SELECT a.port, a.ip, a.id FROM server_editor a, karte b, account_clients c ";
	befehl += "WHERE a.id = b.server_editor_id AND b.account_id = c.account_id AND a.server_status_id = 3 AND c.client_id = ";
	befehl += clientId;
	befehl += " AND b.id = ";
	befehl += karteId;
	lock();
	if( !datenbank->befehl( befehl ) )
	{
		unlock();
		Result res = { 0, 0, 0, 0 };
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	*port = res.values[ 0 ];
    ip->setText( res.values[ 1 ] );
    int id = res.values[ 2 ];
    res.destroy();
    befehl = "INSERT INTO server_editor_clients( client_id, server_editor_id ) VALUES ( ";
    befehl += clientId;
    befehl += ", ";
    befehl += id;
    befehl += " )";
    bool ret = 1;
    lock();
    ret &= datenbank->befehl( Text( "SELECT server_editor_id FROM server_editor_clients WHERE client_id = " ) += clientId );
    ret &= datenbank->befehl( Text( "DELETE FROM server_editor_clients WHERE client_id = " ) += clientId );
    ret &= datenbank->befehl( befehl );
    unlock();
	return 1;
}

bool ISDatenbank::getKartenServerPortIp( int clientId, int karteId, int *port, Text *ip )
{
    Text befehl = "SELECT a.port, a.ip, a.id FROM server_karten a, karte b ";
    befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
    befehl += karteId;
    if( !karteId )
        befehl = "SELECT port, ip, a.id FROM server_karten WHERE server_status_id = 3 LIMIT 1";
    lock();
    if( !datenbank->befehl( befehl ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
        return 0;
    *port = res.values[ 0 ];
    ip->setText( res.values[ 1 ] );
    int id = res.values[ 2 ];
    res.destroy();
    if( clientId )
    {
        befehl = "INSERT INTO server_karten_clients( client_id, server_karten_id ) VALUES ( ";
        befehl += clientId;
        befehl += ", ";
        befehl += id;
        befehl += " )";
        bool ret = 1;
        lock();
        ret &= datenbank->befehl( Text( "SELECT server_karten_id FROM server_karten_clients WHERE client_id = " ) += clientId );
        ret &= datenbank->befehl( Text( "DELETE FROM server_karten_clients WHERE client_id = " ) += clientId );
        ret &= datenbank->befehl( befehl );
        unlock();
    }
    return 1;
}

// constant
Text *ISDatenbank::getLetzterFehler() const
{
	return datenbank->getLetzterFehler();
}

// Reference Counting
ISDatenbank *ISDatenbank::getThis()
{
	ref++;
	return this;
}

ISDatenbank *ISDatenbank::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}