InformationServer/InformationServer/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)
	: ReferenceCounter()
{
	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));
	if (!datenbank->istOk())
	{
		std::cout << "IS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
		exit(1);
	}
	InitializeCriticalSection(&cs);
	Text befehl = "SELECT port, admin_port  FROM server WHERE id = ";
	befehl += zIni->zWert("ServerId")->getText();
	lock();
	datenbank->befehl(befehl);
	Result res = datenbank->getResult();
	unlock();
	if (res.zeilenAnzahl == 1)
	{
		zIni->addWert("ServerPort", res.values[0]);
		zIni->addWert("AdminServerPort", res.values[1]);
	}
	res.destroy();
}

// 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->append(name);
	befehl->append("' AND passwort = md5('");
	befehl->append(passwort);
	befehl->append("')");
	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->append(id);
	befehl->append(" AND rechte_id = ");
	befehl->append(recht);
	lock();
	datenbank->befehl(befehl->getText());
	int ret = datenbank->getZeilenAnzahl();
	unlock();
	befehl->release();
	return ret != 0;
}

bool ISDatenbank::proveKlient(int num, int sNum)
{
	Text* befehl = new Text("SELECT * FROM server_client WHERE server_id = ");
	befehl->append(sNum);
	befehl->append(" AND client_id = ");
	befehl->append(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::getKlientKey(int cId)
{
	lock();
	if (!datenbank->befehl(Text("SELECT schluessel FROM client 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_client WHERE client_id = ");
	befehl->append(num);
	befehl->append(" AND server_id = ");
	befehl->append(sNum);
	lock();
	datenbank->befehl(befehl->getText());
	int za = datenbank->getZeilenAnzahl();
	unlock();
	if (za == 1)
	{
		befehl->setText("UPDATE server SET tasks = tasks - 1 WHERE id = ");
		befehl->append(sNum);
		lock();
		datenbank->befehl(befehl->getText());
		unlock();
	}
	befehl->release();
}

bool ISDatenbank::setServerStatus(int id, int status)
{
	Text* befehl = new Text("UPDATE server 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 SET max_tasks = ");
	befehl->append(maxC);
	befehl->append(" WHERE id = ");
	befehl->append(id);
	lock();
	if (!datenbank->befehl(befehl->getText()))
	{
		unlock();
		befehl->release();
		return 0;
	}
	bool ret = datenbank->getZeilenAnzahl() > 0;
	unlock();
	befehl->release();
	return ret;
}

bool ISDatenbank::serverIstNichtPausiert(int id)
{
	Text* befehl = new Text("SELECT server_status_id FROM server WHERE id = ");
	befehl->append(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->append(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->append(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->append(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(const char* rufName)
{
	Text* befehl = new Text("SELECT id FROM account WHERE ruf_name = '");
	befehl->append(rufName);
	befehl->append("' 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->append(accountId);
	befehl->append(" AND spiel_art_id = ");
	befehl->append(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);
		res.destroy();
		return ret;
	}
	for (int i = 0; i < res.feldAnzahl; i++)
		ret->add(TextZuInt(res.values[i].getText(), 10));
	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->append(accountId);
	befehl->append(" AND a.karte_id = ");
	befehl->append(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 = (int)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->append(accountId);
	befehl->append(" AND a.karte_id = ");
	befehl->append(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 = (int)res.values[0];
	res.destroy();
	return ret;
}

Text* ISDatenbank::getKarteName(int karteId)
{
	Text* befehl = new Text("SELECT name FROM karte WHERE id = ");
	befehl->append(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->append(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->append(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(const char* name)
{
	Text* befehl = new Text("SELECT id FROM chatroom WHERE name = '");
	befehl->append(name);
	befehl->append("' 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->append(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(const char* name)
{
	Text* befehl = new Text("SELECT id FROM spiel_art WHERE name = '");
	befehl->append(name);
	befehl->append("'");
	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(const char* name)
{
	Text* befehl = new Text("SELECT id FROM karte WHERE name = '");
	befehl->append(name);
	befehl->append("'");
	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->append(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->append(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->append(spielId);
	befehl->append(" AND b.spiel_id = a.id AND b.account_id = ");
	befehl->append(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_client b "
		"WHERE a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = ");
	befehl->append(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->append(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_client b WHERE a.id = b.account_id AND b.client_id = ");
	befehl->append(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->append(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->append(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_client 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->append(cId);
	befehl->append(" AND c.spiel_art_id = ");
	befehl->append(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->append(karte);
	befehl->append(" AND account_id = ");
	befehl->append(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->append(spiel);
	befehl->append(" AND account_id = ");
	befehl->append(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->append(accountId);
	befehl->append(" AND c.spiel_art_id = ");
	befehl->append(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((int)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->append(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->add((int)res.values[i]);
	res.destroy();
	return ret;
}

int ISDatenbank::getDateiGruppeVonPfad(const char* pfad)
{
	Text* befehl = new Text("SELECT id FROM datei_gruppe WHERE pfad = '");
	befehl->append(pfad);
	befehl->append("'");
	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->append(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::getGruppeSpielerAdd(int gruppeId)
{
	Text* befehl = new Text("SELECT spiel_starten FROM gruppe WHERE id = ");
	befehl->append(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(const char* suche, int* seite, int* maxSeite, int sortStalte, bool backwords)
{
	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"
		"    FROM karte g, spiel h, spiel_spieler i "
		"    WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
		"   ( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_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->append(suche);
	befehl->append("' 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 entrys = (int)res.values[0];
	res.destroy();
	*maxSeite = entrys / 21;
	if (entrys % 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 "
		"  FROM karte g, spiel h, spiel_spieler i "
		"  WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
		"( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_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->append(suche);
	befehl->append("' 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->append(sortStalte + 2);
	if (backwords)
		befehl->append(" DESC");
	befehl->append(" OFFSET ");
	befehl->append(((*seite) - 1) * 21);
	befehl->append(" 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::getSpielerAktivity(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->add(beg->getDatum("d-m-y"));
		Text* b = beg->getDatum("y-m-d");
		Text* e = end->getDatum("y-m-d");
		stOnline->add(getOnlineSeconds(accountId, *b, *e) / (60.0 * 60));
		stGespielt->add(getGespieltSeconds(accountId, *b, *e) / (60.0 * 60));
		anzSpiele->add(getGespieltSpiele(accountId, *b, *e));
		anzGewonnen->add(getGewonnenSpiele(accountId, *b, *e));
		b->release();
		e->release();
		beg->plusTag(1);
		end->plusTag(1);
	}
	return 1;
}

int ISDatenbank::getOnlineSeconds(int accountId, const char* beg, const char* end)
{
	int sec = 0;
	Text* befehl = new Text("SELECT date_part( 'epoch', ( SELECT sum( now() - '");
	befehl->append(beg);
	befehl->append("' ) FROM account_online WHERE datum < '");
	befehl->append(beg);
	befehl->append("' AND now() < '");
	befehl->append(end);
	befehl->append("' AND now() > '");
	befehl->append(beg);
	befehl->append("' AND end_datum IS NULL AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' AND now() < '");
	befehl->append(end);
	befehl->append("' AND end_datum IS NULL AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("' - datum ) FROM account_online WHERE datum > '");
	befehl->append(beg);
	befehl->append("' AND datum < '");
	befehl->append(end);
	befehl->append("' AND now() > '");
	befehl->append(end);
	befehl->append("' AND end_datum IS NULL AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
	befehl->append(beg);
	befehl->append("' ) FROM account_online WHERE datum < '");
	befehl->append(beg);
	befehl->append("' AND now() > '");
	befehl->append(end);
	befehl->append("' AND end_datum IS NULL AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' ) FROM account_online WHERE datum < '");
	befehl->append(beg);
	befehl->append("' AND end_datum < '");
	befehl->append(end);
	befehl->append("' AND end_datum > '");
	befehl->append(beg);
	befehl->append("' AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' AND end_datum < '");
	befehl->append(end);
	befehl->append("' AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("' - datum ) FROM account_online WHERE datum > '");
	befehl->append(beg);
	befehl->append("' AND datum < '");
	befehl->append(end);
	befehl->append("' AND end_datum > '");
	befehl->append(end);
	befehl->append("' AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
	befehl->append(beg);
	befehl->append("' ) FROM account_online WHERE datum < '");
	befehl->append(beg);
	befehl->append("' AND end_datum > '");
	befehl->append(end);
	befehl->append("' AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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, const char* beg, const char* end)
{
	int sec = 0;
	Text* befehl = new Text("SELECT date_part( 'epoch', ( SELECT sum( now() - '");
	befehl->append(beg);
	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND now() < '");
	befehl->append(end);
	befehl->append("' AND now() > '");
	befehl->append(beg);
	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' AND now() < '");
	befehl->append(end);
	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
	befehl->append(beg);
	befehl->append("' AND a.beginn_datum < '");
	befehl->append(end);
	befehl->append("' AND now() > '");
	befehl->append(end);
	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
	befehl->append(beg);
	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND now() > '");
	befehl->append(end);
	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.end_datum > '");
	befehl->append(beg);
	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
	befehl->append(beg);
	befehl->append("' AND a.beginn_datum < '");
	befehl->append(end);
	befehl->append("' AND a.end_datum > '");
	befehl->append(end);
	befehl->append("' AND a.id = b.spiel_id AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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->append(end);
	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
	befehl->append(beg);
	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND a.end_datum > '");
	befehl->append(end);
	befehl->append("' AND a.id = b.spiel_id AND account_id = ");
	befehl->append(accountId);
	befehl->append(" )::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, const char* beg, const char* end)
{
	int anz = 0;
	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.end_datum > '");
	befehl->append(beg);
	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(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->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
	befehl->append(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, const char* beg, const char* end)
{
	int anz = 0;
	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
	befehl->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.end_datum > '");
	befehl->append(beg);
	befehl->append("' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = ");
	befehl->append(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->append(beg);
	befehl->append("' AND a.end_datum < '");
	befehl->append(end);
	befehl->append("' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = ");
	befehl->append(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->append(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 backwords)
{
	Text* befehl = new Text("SELECT count( spiel_art_id ) FROM spiel_statistik WHERE account_id = ");
	befehl->append(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 entrys = (int)res.values[0];
	res.destroy();
	*maxSeite = entrys / 21;
	if (entrys % 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->append(accountId);
	befehl->append(" ORDER BY ");
	befehl->append(sortStalte + 2);
	if (backwords)
		befehl->append(" DESC");
	befehl->append(" OFFSET ");
	befehl->append(((*seite) - 1) * 18);
	befehl->append(" 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((int)spielListe.values[1 + i * spielListe.feldAnzahl], is);
		if (!reader->ladeSpielerTeamStruktur(sts))
			stsOK = 0;
		reader->release();
		AHSpielDaten* spiel = new AHSpielDaten();
		spiel->id = (int)spielListe.values[i * spielListe.feldAnzahl];
		spiel->karteId = (int)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 = (int)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].getLength())
				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].getLength() && sts->teamName->z((int)team.values[0]))
				{
					spiel->gewinner->setText(sts->teamName->z((int)team.values[0])->getText());
					gewinnerTeam = (int)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 = (int)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->add(team);
				}
				AHSpielSpielerDaten* spieler = new AHSpielSpielerDaten();
				spieler->name->setText(spielerListe.values[j * spielerListe.feldAnzahl]);
				spieler->punkte = (int)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->add(spiel);
	}
	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 a, server_historie_spiel b "
		"WHERE a.id = b.server_historie_id AND a.tasks < a.max_tasks - 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 = (int)res.values[0];
	*port = (int)res.values[1];
	*ip = res.values[2].getText();
	res.destroy();
	Text* befehl = new Text("INSERT INTO server_client( client_id, server_id ) VALUES ( ");
	befehl->append(clientId);
	befehl->append(", ");
	befehl->append(id);
	befehl->append(" )");
	bool ret = 1;
	lock();
	ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.server_typ_name = 'historie' AND b.id = a.server_id AND a.client_id = ") += clientId);
	ret &= datenbank->befehl(*befehl);
	unlock();
	befehl->release();
	return ret;
}

bool ISDatenbank::hatKlientRecht(int kId, int recht)
{
	Text befehl = "SELECT a.* FROM account_user_rechte a, account_client 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, const 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_client 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 a, karte b, account_client 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();
		return 0;
	}
	Result res = datenbank->getResult();
	unlock();
	*port = (int)res.values[0];
	ip->setText(res.values[1]);
	int id = (int)res.values[2];
	res.destroy();
	befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
	befehl += clientId;
	befehl += ", ";
	befehl += id;
	befehl += " )";
	bool ret = 1;
	lock();
	ret &= datenbank->befehl(Text("SELECT a.server_id FROM server_client a, server b WHERE a.server_id = b.id AND b.server_typ_name = 'editor' AND a.client_id = ") += clientId);
	ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'editor' AND a.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 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, id FROM server WHERE server_typ_name = 'karten' AND 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 = (int)res.values[0];
	ip->setText(res.values[1]);
	int id = (int)res.values[2];
	res.destroy();
	if (clientId)
	{
		befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
		befehl += clientId;
		befehl += ", ";
		befehl += id;
		befehl += " )";
		bool ret = 1;
		lock();
		ret &= datenbank->befehl(Text("SELECT a.server_id FROM server_client a, server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = ") += clientId);
		ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = ") += clientId);
		ret &= datenbank->befehl(befehl);
		unlock();
	}
	return 1;
}

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