private static void SpielPunkteSpeichern(int turnierID, int spielNr)
{
try
{
TSpiele spiel = ClsTurnierControler.Spiel(turnierID, spielNr);
// Feststellen wer gewinner ist und Punkte verteilen
int sPunkte = Convert.ToInt32(ClsOptionsControler.Options3("Siegerpunkte").Value);
int vPunkte = Convert.ToInt32(ClsOptionsControler.Options3("Verliererpunkte").Value);
int uPunkte = Convert.ToInt32(ClsOptionsControler.Options3("Unentschiedenpunkte").Value);
if (spiel.ToreA == spiel.ToreB)
{
spiel.PunkteA = uPunkte;
spiel.PunkteB = uPunkte;
}
else if (spiel.ToreA < spiel.ToreB)
{
spiel.PunkteA = vPunkte;
spiel.PunkteB = sPunkte;
}
else if (spiel.ToreA > spiel.ToreB)
{
spiel.PunkteA = sPunkte;
spiel.PunkteB = vPunkte;
}
ClsTurnierControler.SaveSpiel(spiel);
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
/// <summary>
/// aktuelle Runde ermitteln
/// </summary>
/// <param name="turnierID"></param>
/// <returns></returns>
private static int GetActualRoundNo(int turnierID)
{
List <TRunden> runden = ClsTurnierControler.Runden(turnierID);
int runde = (from r in runden
where r.status == 1
select r.Runde).FirstOrDefault();
return(runde);
}
private static ClsTurnier LoadFromDB(int TurnierID)
{
ClsTurnier Turnier = new ClsTurnier();
Turnier.TKopf = ClsTurnierControler.Turnier(TurnierID);
Turnier.TRunden = ClsTurnierControler.Runden(TurnierID);
Turnier.TGruppen = ClsTurnierControler.Gruppen(TurnierID);
Turnier.TSpiele = ClsTurnierControler.Spiele(TurnierID);
Turnier.TTabellen = ClsTurnierControler.Tabellen(TurnierID);
Turnier.TEreignisse = ClsTurnierControler.Ereignisse(TurnierID);
return(Turnier);
}
public static void TurnierSpeichern(ClsTurnier Turnier)
{
try
{
int turnierID = ClsTurnierControler.AddTurnierKopf(Turnier.Kopf);
for (int i = 0; i < Turnier.Runden.Count; i++)
{
TRunden t = Turnier.Runden[i];
t.TurnierID = turnierID;
if (t.Runde == 1)
{
t.status = 1;
}
ClsTurnierControler.AddRunden(t);
}
for (int i = 0; i < Turnier.Tabellen.Count; i++)
{
TTabellen et = Turnier.Tabellen[i];
et.TurnierID = turnierID;
ClsTurnierControler.AddTabellen(et);
}
for (int i = 0; i < Turnier.Spiele.Count; i++)
{
TSpiele er = Turnier.Spiele[i];
er.TurnierID = turnierID;
er.Datum = "";
er.Uhrzeit = "";
ClsTurnierControler.AddSpiele(er);
}
List <string> grp = (from x in Turnier.Tabellen select x.Gruppe).Distinct().ToList();
for (int i = 0; i < grp.Count; i++)
{
TGruppen gr = new TGruppen();
gr.TurnierID = turnierID;
gr.TurnierNr = 0;
gr.Gruppe = grp[i];
gr.status = 0;
gr.Runde = Convert.ToInt32(grp[i].Substring(0, grp[i].Length - 1));
ClsTurnierControler.AddGruppen(gr);
}
}
catch (Exception ex)
{
ClsError.CoreError(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
private static void SaveToDB(ClsTurnier Turnier)
{
int TurnierID = ClsTurnierControler.AddTurnierKopf(Turnier.TKopf);
if (Turnier.TRunden.Any())
{
for (int i = 0; i < Turnier.TRunden.Count; i++)
{
Turnier.TRunden[i].TurnierID = TurnierID;
ClsTurnierControler.AddRunden(Turnier.TRunden[i]);
}
}
if (Turnier.TGruppen.Any())
{
for (int i = 0; i < Turnier.TGruppen.Count; i++)
{
Turnier.TGruppen[i].TurnierID = TurnierID;
ClsTurnierControler.AddGruppen(Turnier.TGruppen[i]);
}
}
if (Turnier.TSpiele.Any())
{
for (int i = 0; i < Turnier.TSpiele.Count; i++)
{
Turnier.TSpiele[i].TurnierID = TurnierID;
ClsTurnierControler.AddSpiele(Turnier.TSpiele[i]);
}
}
if (Turnier.TTabellen.Any())
{
for (int i = 0; i < Turnier.TTabellen.Count; i++)
{
Turnier.TTabellen[i].TurnierID = TurnierID;
ClsTurnierControler.AddTabellen(Turnier.TTabellen[i]);
}
}
if (Turnier.TEreignisse.Any())
{
for (int i = 0; i < Turnier.TEreignisse.Count; i++)
{
Turnier.TEreignisse[i].TurnierID = TurnierID;
ClsTurnierControler.AddEreignis(Turnier.TEreignisse[i]);
}
}
}
private void LoadSpieleToTE()
{
try
{
List <TSpiele> tee = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID);
if (!tee.Any())
{
return;
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
public static void TurnierLoeschen(int TurnierID)
{
try
{
ClsTurnierControler.DelTabellen(TurnierID);
ClsTurnierControler.DelSpiele(TurnierID);
ClsTurnierControler.DelGruppen(TurnierID);
ClsTurnierControler.DelRunden(TurnierID);
ClsEreignisControler.DelEreignisse(TurnierID);
ClsTurnierControler.DelTurnierKopf(TurnierID);
}
catch (Exception ex)
{
ClsError.CoreError(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
private static void SaveTabellenplatz(string Gruppe, string mannschaft, int platz)
{
try
{
List <TTabellen> e1 = ClsTurnierControler.Tabellen(ClsGlobal.Instance.TurnierID, Gruppe);
TTabellen e = (from t in e1
where t.Mannschaft == mannschaft
select t).FirstOrDefault();
e.fixPlatz = platz;
ClsTurnierControler.SaveTabellen(e);
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
/// <summary>
/// findet das nächste Spiel
/// </summary>
/// <param name="pos"></param>
/// <param name="turnierID"></param>
/// <returns></returns>
public static TSpiele FindNext(int pos, int turnierID)
{
try
{
TKopf turnierk = ClsTurnierControler.Turnier(turnierID);
if (turnierk.status == 3)
{
return(null);
}
List <TSpiele> spiele1;
if (turnierk.Matrix != "AdHoc")
{
spiele1 = ClsTurnierControler.Spiele(turnierID, GetActualRoundNo(turnierID));
}
else
{
spiele1 = ClsTurnierControler.Spiele(turnierID);
}
List <TSpiele> spiele2 = (from x in spiele1 where x.Status == 2 select x).ToList();
if (!spiele2.Any())
{
// MessageBox.Show("Es ist kein Spiel mehr offen.", "Meldung...");
////ClsTranslateControls.ShowMessage("M0018", "Meldung", new object[] { "\n" }, MessageBoxButtons.OK);
return(null);
}
if (pos >= spiele2.Count)
{
return(null);
}
else
{
return(spiele2[pos]);
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(new TSpiele());
}
}
/// <summary>
/// manuelles setzen von Toren und/oder beenden des Spiels
/// </summary>
public static void SetMatch(int SpielID, int ToreA, int ToreB, string SpielendeOpt)
{
TSpiele spiel = ClsTurnierControler.Spiel(SpielID);
spiel.ToreA = ToreA;
spiel.ToreB = ToreB;
ClsTurnierControler.SaveSpiel(spiel);
if (SpielendeOpt == "1")
{
Spiel_beenden(spiel);
}
if (SpielendeOpt == "2")
{
// nichts notwendig da Spiel offen bleiben muss
}
if (SpielendeOpt == "3")
{
Spiel_beenden(spiel, true);
}
}
public static int LoadTurnier(int turnierID)
{
try
{
TKopf k = ClsTurnierControler.Turnier(turnierID);
if (k == null)
{
k = new TKopf();
k.TurnierNr = 0;
}
ClsDBVariablen.Instance.SetTextVariableWert("S13", k.TurnierNr.ToString());
if (turnierID == 0)
{
// Turniername auf "freies Spielen" setzen
ClsDBVariablen.Instance.SetTextVariableWert("S14", "freies Spielen");
// Spiel 0 initialisieren
SetSpiel0();
// Spiel next initialisieren
TSpiele nextspiel = null;
ClsGlobal.Instance.NextSpiel = nextspiel;
ClsDBVariablen.Instance.SetTextVariableWert("S16", "");
ClsDBVariablen.Instance.SetTextVariableWert("S48", "0"); // Runde_next
ClsDBVariablen.Instance.SetTextVariableWert("S49", "0"); // Gruppe_next
ClsDBVariablen.Instance.SetTextVariableWert("S50", "0"); // Spiel_next
// Spielabschnitt auf 1 setzten
ClsSpielAbschnittControler.Instance.Spielabschnitt = 1;
// Zeiten initialisieren
ClsZeitkontroler.Instance.ResetAlleUhren();
// Tabellenvariablen füllen
Turnierwechsel(turnierID);
return(0);
}
// prüfen ob turnier bereits beendet
if (k.status == 3)
{
// MessageBox.Show("Turnier ist bereits beendet und kann nicht geladen werden.", "Meldung...");
////ClsTranslateControls.ShowMessage("M0014", "Meldung", new object[] { "\n" }, MessageBoxButtons.OK);
ClsDBVariablen.Instance.SetTextVariableWert("S48", ""); // Runde_next
ClsDBVariablen.Instance.SetTextVariableWert("S49", ""); // Gruppe_next
ClsDBVariablen.Instance.SetTextVariableWert("S50", ""); // Spiel_next
}
// neues Turnier laden
// tk - TurnierKopf
TKopf tkk = ClsTurnierControler.Turnier(turnierID);
if (tkk != null)
{
// tk.Add(tkk);
ClsDBVariablen.Instance.SetTextVariableWert("S14", tkk.Beschreibung);
}
// aktuelle Runde ermitteln
List <TRunden> runden = ClsTurnierControler.Runden(turnierID);
int runde = (from r in runden
where r.TurnierID == ClsGlobal.Instance.TurnierID && r.status == 1
select r.Runde).FirstOrDefault();
// Naechste Begegnungen
ClsSpielfunktionen.SetNext(ClsSpielfunktionen.FindNext(0, turnierID));
// aktives spiel auf null setzen
ClsGlobal.Instance.AktivesSpiel = null;
// Tabellenvariablen füllen
Turnierwechsel(turnierID);
return(0);
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(0);
}
}
public static void TorschuetzeToVariable(int turnierID)
{
try
{
bool kname = Convert.ToBoolean(ClsOptionsControler.Options3("kurznamen").Value);
// Create a DataTable for buildup
DataTable tempTable = new DataTable();
// Spalte je Anzeigespalte erstellen
List <Anzeigetabelle> cols1 = ClsOptionsControler.Anzeigetabelle("T06", "std");
List <Anzeigetabelle> cols = (from x in cols1 where x.Sichtbar == 1 select x).ToList();
string[] spalten = new string[cols.Count];
if (cols.Any())
{
for (int i = 0; i < cols.Count; i++)
{
spalten[i] = cols[i].DBFeld;
}
}
// Tabelle lesen
List <ClsTorschuetze> tab = ClsTurnierControler.TorschuetzenList(turnierID);
// Werte übersetzen
if (tab.Any())
{
for (int i = 0; i < tab.Count; i++)
{
if (kname)
{
tab[i].Mannschaft = Kurzname(tab[i].Mannschaft);
}
}
}
// Mache aus List ein Datatable
using (var reader = FastMember.ObjectReader.Create(tab, spalten))
{
tempTable.Load(reader);
}
// Spalten übersetzen
for (int i = 0; i < tempTable.Columns.Count; i++)
{
// Anzeigename
string text = (from x in cols where x.DBFeld == tempTable.Columns[i].ColumnName select x.Anzeigename).FirstOrDefault();
if (string.IsNullOrEmpty(text))
{
//text = ClsLocalisationFunctions.Tabellenfeld("Torschuetzen", tempTable.Columns[i].ColumnName);
text = ClsTextControler.TextByNameAndNumber("Torschuetzen", tempTable.Columns[i].ColumnName);
}
if (!string.IsNullOrEmpty(text))
{
tempTable.Columns[i].ColumnName = text;
}
}
ClsDBVariablen.Instance.SetTabellenVariableWert("T06", ConvertDatatabletoString(tempTable));
// return tempTable;
// tempTable.Dispose();
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
private static void TabCalc(int turnierID, string gruppe)
{
try
{
// Tabellenupdate
List <TTabellen> mannschaften = ClsTurnierControler.Tabellen(turnierID, gruppe);
if (mannschaften.Any())
{
List <TTabellen> unsorted1 = Settablevalues(turnierID, gruppe, mannschaften);
for (int i = 0; i < unsorted1.Count; i++)
{
unsorted1[i].Direkterpunktvergleich = unsorted1.Count;
unsorted1[i].Direktererweitertervergleich = unsorted1.Count;
ClsTurnierControler.SaveTabellen(unsorted1[i]);
}
// Dierektervergleich
// ermittel ob es gleiche punktanzahl gibt
List <int> test = unsorted1.GroupBy(x => x.Punkte).Select(y => y.Key).ToList();
// alle pläzte duchgehen und prüfen ob es noch weitere Plaetze mit gleicher punktzahl gibt
for (int i = 0; i < test.Count; i++)
{
List <TTabellen> newlist = ClsTurnierControler.Tabellen(turnierID, gruppe);
List <TTabellen> dist = (from x in newlist where x.Punkte == test[i] select x).ToList();
if (dist.Count > 1)
{
// nur über Punkte ausrechnen
List <TTabellen> unsorted = new List <TTabellen>(Settablevalues(turnierID, gruppe, dist).ToList());
List <TTabellen> sorted = unsorted.OrderByDescending(x => x.Punkte).ToList();
for (int p = 0; p < sorted.Count; p += 1)
{
TTabellen row = sorted[p];
ClsTurnierControler.SaveTabellenDVP(row, p);
}
// über Punkte und Tore ausrechnen
sorted = unsorted.OrderByDescending(x => x.Punkte).ThenByDescending(y => y.Tore).ThenBy(z => z.Gegentore).ToList();
for (int p = 0; p < sorted.Count; p += 1)
{
TTabellen row = sorted[p];
ClsTurnierControler.SaveTabellenDVPV(row, p);
}
}
}
}
// Gruppenplaetze eintragen
List <TTabellen> tabelle = ClsTurnierControler.Tabellen(turnierID, gruppe);
if (tabelle.Any())
{
// Nach Vorgaben sortieren
List <TTabellen> sortedtabelle = ClsFunktionen.STTabellem(tabelle);
// Plaetze eintragen
int platz = 1;
for (int i = 0; i < sortedtabelle.Count; i++)
{
if (sortedtabelle[i] != null)
{
sortedtabelle[i].Platz = platz;
ClsTurnierControler.SaveTabellen(sortedtabelle[i]);
platz += 1;
}
}
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
private static List <TTabellen> Settablevalues(int turnierID, string gruppe, List <TTabellen> mannschaften)
{
try
{
List <string> mannamen = mannschaften.Select(x => x.Mannschaft).ToList();
// Tabellenupdate
if (mannschaften.Any())
{
for (int i = 0; i < mannschaften.Count; i++)
{
// Spiele lesen
List <TSpiele> spiele1 = ClsTurnierControler.Spiele(turnierID, gruppe);
List <TSpiele> spiele = (from e in spiele1
where (e.IstMannA == mannschaften[i].Mannschaft && mannamen.Contains(e.IstMannB))
||
(e.IstMannB == mannschaften[i].Mannschaft && mannamen.Contains(e.IstMannA))
select e).ToList();
// Spiele Auswerten
int punkte =
(from TSpiele e in spiele
where e.IstMannA == mannschaften[i].Mannschaft
select e.PunkteA).Sum()
+
(from TSpiele e in spiele
where e.IstMannB == mannschaften[i].Mannschaft
select e.PunkteB).Sum();
int tore =
(from TSpiele e in spiele
where e.IstMannA == mannschaften[i].Mannschaft
select e.ToreA).Sum()
+
(from TSpiele e in spiele
where e.IstMannB == mannschaften[i].Mannschaft
select e.ToreB).Sum();
int gegentore =
(from TSpiele e in spiele
where e.IstMannA == mannschaften[i].Mannschaft
select e.ToreB).Sum()
+
(from TSpiele e in spiele
where e.IstMannB == mannschaften[i].Mannschaft
select e.ToreA).Sum();
int spielanz =
(from TSpiele e in spiele
where e.IstMannA == mannschaften[i].Mannschaft &&
e.Status == 3
select e).Count()
+
(from TSpiele e in spiele
where e.IstMannB == mannschaften[i].Mannschaft &&
e.Status == 3
select e).Count();
// gegentore wenn beide nicht da
int anz = (from e in spiele1
where (e.IstMannA == mannschaften[i].Mannschaft && e.Status == 4)
||
(e.IstMannB == mannschaften[i].Mannschaft && e.Status == 4)
select e).Count();
gegentore += (anz * 5);
mannschaften[i].Punkte = punkte;
mannschaften[i].Tore = tore;
mannschaften[i].Gegentore = gegentore;
mannschaften[i].Spiele = spielanz;
mannschaften[i].Torverhaeltnis = tore - gegentore;
}
}
return(mannschaften);
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(new List <TTabellen>());
}
}
/// <summary>
/// Nach Rundenplazierung die Mannschften in den Folgerunden eintragen.
/// </summary>
/// <param name="spiel">todo: describe spiel parameter on IstMannschaftenGegenueber</param>
private static void IstMannschaftenGegenueber(TSpiele spiel)
{
try
{
// Gruppenübergereifende Plaetze ermitten und mannschaften in folgerunden eintragen (1ter 1ter, 2ter 1ter,...)
int grpManAnz = ClsTurnierControler.Tabellen((int)ClsGlobal.Instance.TurnierID, spiel.Gruppe).Count;
// So oft wie Mannschaften je Gruppe (Anzeahl der Mannschaften wird al Platzzaehler verwendet)
for (int p = 1; p <= grpManAnz; p += 1)
{
// alle Tabelleneintraege der Runde
List <TTabellen> erg1 = ClsTurnierControler.Tabellen((int)ClsGlobal.Instance.TurnierID, spiel.Runde);
// Alle x-platzierten lesen
List <TTabellen> erg = (from d in erg1
where d.Platz == p
select d).ToList();
if (erg != null)
{
// nach vorgaben sortieren
erg = ClsFunktionen.STTabellem(erg);
// erg enthaelt nun alle x-platzierten nach sortiervorgabe
int platz = 1;
for (int i = 0; i < erg.Count; i++)
{
string suchstr = platz.ToString() + "ter " + p.ToString() + "ter-Runde " + spiel.Runde.ToString();
List <TSpiele> s0 = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID);
List <TSpiele> s1 = (from s in s0
where s.Status < 2
select s).ToList();
List <TSpiele> p1 = (from s in s1
where s.IstMannA == suchstr
select s).ToList();
if (p1.Any())
{
for (int j = 0; j < p1.Count; j++)
{
p1[j].IstMannA = erg[i].Mannschaft;
p1[j].Status = p1[j].Status + 1;
ClsTurnierControler.SaveSpiel(p1[j]);
}
}
List <TSpiele> p2 = (from s in s1
where s.IstMannB == suchstr
select s).ToList();
if (p2.Any())
{
for (int j = 0; j < p1.Count; j++)
{
p2[j].IstMannB = erg[i].Mannschaft;
p2[j].Status = p2[j].Status + 1;
ClsTurnierControler.SaveSpiel(p2[j]);
}
}
platz += 1;
// suche Tabelleneinträge der folgerunde und ersetzte Mannschftsnamen
List <TTabellen> tab = ClsTurnierControler.Tabellen(ClsGlobal.Instance.TurnierID);
TTabellen gefunden = (from x in tab
where x.Mannschaft == suchstr
select x).FirstOrDefault();
if (gefunden != null)
{
gefunden.Mannschaft = erg[i].Mannschaft;
ClsTurnierControler.SaveTabellen(gefunden);
}
}
ClsDBVariablen.Instance.SetTabellenVariableWert("T02", ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
}
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
public static string SpielplanToVariable_Json(int turnierID)
{
try
{
bool kname = Convert.ToBoolean(ClsOptionsControler.Options3("kurznamen").Value);
string Runde = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T02" && x.Field == "Runde").Value;
string Gruppe = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T02" && x.Field == "Gruppe").Value;
string Status = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T02" && x.Field == "Status").Value;
string Datum = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T02" && x.Field == "Datum").Value;
if (string.IsNullOrEmpty(Runde))
{
Runde = "0";
}
int runde = Convert.ToInt32(Runde);
// Create a DataTable for buildup
DataTable tempTable = new DataTable();
// Spalte je Anzeigespalte esretllen (Überschriften)
List <Anzeigetabelle> cols1 = ClsOptionsControler.Anzeigetabelle("T02", "std");
List <Anzeigetabelle> cols = (from x in cols1 where x.Sichtbar == 1 select x).ToList();
string[] spalten = new string[cols.Count + 1];
if (cols.Any())
{
spalten[0] = "ID";
for (int i = 0; i < cols.Count; i++)
{
spalten[i + 1] = cols[i].DBFeld;
}
}
// Zeilen Hinzufügen
// Tabelle lesen
List <TSpiele> tab = ClsTurnierControler.Spiele(turnierID);
// Daten filtern
if (Runde != "0")
{
tab = (from t in tab
where t.Runde == runde
select t).ToList();
}
if (!string.IsNullOrEmpty(Gruppe))
{
tab = (from t in tab
where t.Gruppe == Gruppe
select t).ToList();
}
if (!string.IsNullOrEmpty(Status))
{
tab = (from t in tab
where t.Status == Convert.ToInt32(Status)
select t).ToList();
}
if (!string.IsNullOrEmpty(Datum))
{
tab = (from t in tab
//where t.Datum == Convert.ToDateTime(ClsGlobal.Instance.FilterS.Date)
where t.Datum == Datum
select t).ToList();
}
// Daten sortieren
tab = (from ot in tab
orderby ot.Spiel
select ot).ToList();
// Werte übersetzen
if (tab.Any())
{
for (int i = 0; i < tab.Count; i++)
{
if (kname)
{
tab[i].IstMannA = Kurzname(tab[i].IstMannA);
tab[i].IstMannB = Kurzname(tab[i].IstMannB);
}
}
}
// Mache aus List ein Datatable
using (var reader = FastMember.ObjectReader.Create(tab, spalten))
{
tempTable.Load(reader);
}
// Spalten übersetzen
for (int i = 0; i < tempTable.Columns.Count; i++)
{
// Anzeigename
string text = (from x in cols where x.DBFeld == tempTable.Columns[i].ColumnName select x.Anzeigename).FirstOrDefault();
if (string.IsNullOrEmpty(text))
{
//text = ClsLocalisationFunctions.Tabellenfeld("Spielplan", tempTable.Columns[i].ColumnName);
text = ClsTextControler.TextByNameAndNumber("Spielplan", tempTable.Columns[i].ColumnName);
}
if (!string.IsNullOrEmpty(text))
{
tempTable.Columns[i].ColumnName = text;
}
}
return(ConvertDatatabletoString(tempTable));
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(null);
}
}
/// <summary>
/// Nach Gruppenplazierung die Mannschften in den Folgerunden eintragen.
/// </summary>
/// <param name="spiel">todo: describe spiel parameter on IstMannschaftenGI</param>
private static void IstMannschaftenGI(string Gruppe)
{
try
{
// platz in Gruppe ermitteln über order by und mannschaften in folgerunden eintragen
List <TTabellen> e = ClsTurnierControler.Tabellen(ClsGlobal.Instance.TurnierID, Gruppe);
if (e.Any())
{
for (int i = 0; i < e.Count; i++)
{
if (e[i] != null)
{
string suchstr = e[i].Platz.ToString() + "ter-" + Gruppe;
// hole alle Spiele des Turniers
List <TSpiele> s0 = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID);
// filter Spiele die den Status kleiner 2 haben
List <TSpiele> s1 = (from s in s0
where s.Status < 2
select s).ToList();
// suche Spiele die SuchStr in MannA haben
List <TSpiele> p1 = (from s in s1
where s.IstMannA == suchstr
select s).ToList();
if (p1.Any())
{
for (int j = 0; j < p1.Count; j++)
{
p1[j].IstMannA = e[i].Mannschaft;
p1[j].Status = p1[j].Status + 1;
ClsTurnierControler.SaveSpiel(p1[j]);
}
}
// suche Spiele die SuchStr in MannB haben
List <TSpiele> p2 = (from s in s1
where s.IstMannB == suchstr
select s).ToList();
if (p2.Any())
{
for (int j = 0; j < p2.Count; j++)
{
p2[j].IstMannB = e[i].Mannschaft;
p2[j].Status = p2[j].Status + 1;
ClsTurnierControler.SaveSpiel(p2[j]);
}
}
// suche Tabelleneinträge der folgerunde und ersetzte Mannschftsnamen
List <TTabellen> tab = ClsTurnierControler.Tabellen(ClsGlobal.Instance.TurnierID);
TTabellen gefunden = (from x in tab
where x.Mannschaft == suchstr
select x).FirstOrDefault();
if (gefunden != null)
{
gefunden.Mannschaft = e[i].Mannschaft;
ClsTurnierControler.SaveTabellen(gefunden);
}
}
}
ClsDBVariablen.Instance.SetTabellenVariableWert("T02", ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
private static void Tor_nebenereignisse(TSpiele spiel, string aoderb, int add, string mannschaft, int spielerID)
{
try
{
ClsDBVariablen.Instance.SetTextVariableWert("S12", ClsFunktionen.Setspielstand());
// spiel speichern
if (spiel != null)
{
if (spiel.Spiel != 0)
{
ClsTurnierControler.SaveSpiel(ClsGlobal.Instance.AktivesSpiel);
}
}
// prüfen ob Ereignis gespeichert werden muss
string SpielzeitStr = ClsDBVariablen.Instance.GetTextVariableWert("S08");
if (ClsZeitkontroler.Instance.GetClockStatus(2)) // ClsSpielzeitControler.Instance.Nachspielzeitlaeuft)
{
SpielzeitStr = SpielzeitStr + "+" + ClsDBVariablen.Instance.GetTextVariableWert("S35");
}
DateTime cpu = DateTime.Now;
string freiSpielereignisse = ClsOptionsControler.Options3("Spielfreieereignisse").Value;
string Spielername = "";
if (spielerID != 0)
{
Spieler spieler = ClsMannschaftenControler.Spieler(spielerID);
Spielername = spieler.Nachname + ", " + spieler.Vorname;
}
if (spiel.Spiel != 0 || (spiel.Spiel == 0 && freiSpielereignisse == "True"))
{
TEreignisse e = new TEreignisse
{
TurnierID = spiel.TurnierID,
TurnierNr = spiel.TurnierNr,
Spiel = spiel.Spiel,
Mannschaft = mannschaft,
Spieler = Spielername,
Spielzeit = SpielzeitStr,
Spielzeitrichtung = ClsTimerControler.Timer(ClsTimerControler.TimerID(1)).Countdown.ToString(), //ClsOptionsControler.Options3("Spielzeitrichtung").Value,
CPUZeit = DateTime.Now,
Ereignistyp = "05"
};
ClsEreignisControler.AddEreignis(e);
}
// update der Ereignistabelle
ClsDBVariablen.Instance.SetTabellenVariableWert("T03", ClsTabellenfunktionen.EreignisseToVariable_Json(ClsGlobal.Instance.TurnierID));
// update der Torschützentabelle
ClsTabellenfunktionen.TorschuetzeToVariable(ClsGlobal.Instance.TurnierID);
// einstellen des Torschützen als aktive gewählten Spieler
ClsDBVariablen.Instance.SetTextVariableWert("S38", spielerID.ToString());
// prüfen ob ein Torton abgespielt werden soll
if (add > 0)
{
string torton = string.Empty;
if (ClsOptionsControler.Options3("individualTorsound").Value != "True")
{
torton = ClsOptionsControler.Options3("Tor").Value;
}
else
{
DB.Mannschaften m = new DB.Mannschaften();
if (aoderb == "A")
{
m = ClsMannschaftenControler.Mannschaft(spiel.IstMannA);
}
else
{
m = ClsMannschaftenControler.Mannschaft(spiel.IstMannB);
}
if (m != null)
{
torton = m.Torton;
}
}
if (torton != string.Empty)
{
ClsSoundplayer.Instance.TPlay(torton + "|" + "30");
}
}
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
}
}
/// <summary>
/// Spielendebehandlung
/// </summary>
/// <param name="spiel"></param>
/// <param name="beidenichts"></param>
/// <returns></returns>
public static int Spiel_beenden(TSpiele spiel, bool beidenichts = false)
{
try
{
bool rundenwechsel = false;
if (beidenichts == false)
{
// wenn nur 2 Mannschaften in Gruppe dann Unentschieden nicht erlaubt
List <TSpiele> sl1 = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID);
int anzGrMan = (from TSpiele tee in sl1
where tee.Gruppe == spiel.Gruppe
select tee).Count();
if (anzGrMan == 1 && spiel.ToreA == spiel.ToreB)
{
ClsMessage.SendMessage("In dieser Gruppe ist kein Unentschieden erlaubt.\nSpiel nicht beendet.", "Geht nicht...");
////ClsTranslateControls.ShowMessage("M0016", "Meldung", new object[] { "\n" }, MessageBoxButtons.OK);
return(0);
}
}
// Spiel beenden
if (beidenichts == false)
{
ClsTurnierControler.SaveSpielStatus(spiel, 3);
}
else
{
ClsTurnierControler.SaveSpielStatus(spiel, 4);
}
ClsDBVariablen.Instance.SetTabellenVariableWert("T02", ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
// Punkte vergeben
if (beidenichts == false)
{
SpielPunkteSpeichern(ClsGlobal.Instance.TurnierID, spiel.Spiel);
}
// Tabelle berechnen
TabCalc(ClsGlobal.Instance.TurnierID, spiel.Gruppe);
// prüfen ob Spiel um platz wenn ja, platz in Tabelle eintragen
TKopf tkk = ClsTurnierControler.Turnier(ClsGlobal.Instance.TurnierID);
if (tkk.Platzierungstyp == "P")
{
if (spiel.SPlatz != 0)
{
if (spiel.ToreA > spiel.ToreB)
{
SaveTabellenplatz(spiel.Gruppe, spiel.IstMannA, spiel.SPlatz);
}
else if (spiel.ToreA < spiel.ToreB)
{
SaveTabellenplatz(spiel.Gruppe, spiel.IstMannB, spiel.SPlatz);
}
}
if (spiel.VPlatz != 0)
{
if (spiel.ToreA > spiel.ToreB)
{
SaveTabellenplatz(spiel.Gruppe, spiel.IstMannB, spiel.VPlatz);
}
else if (spiel.ToreA < spiel.ToreB)
{
SaveTabellenplatz(spiel.Gruppe, spiel.IstMannA, spiel.VPlatz);
}
}
}
// Prüfen ob alle Spiele der Gruppe beendet sind
List <TSpiele> spiele1 = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID, spiel.Gruppe);
int g = (from grp in spiele1
where grp.Status < 3
select grp).Count();
if (g == 0)
{
// Gruppe abgeschlossen
// wenn alle Spiele beendet dann Gruppe als beendet buchen
ClsTurnierControler.SaveGruppenStatus(ClsGlobal.Instance.TurnierID, spiel.Gruppe, 3);
// Mannschaften in folgerunden eintragen
IstMannschaftenGI(spiel.Gruppe);
// prüfen ob alle gruppen in Runde beendet
List <TSpiele> spiele = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID, spiel.Runde);
int r = (from x in spiele
where x.Status < 3
select x).Count();
if (r == 0)
{
rundenwechsel = true;
// Runde als beendet buchen
ClsTurnierControler.SaveRundenStatus(ClsGlobal.Instance.TurnierID, GetActualRoundNo(ClsGlobal.Instance.TurnierID), 3);
// istmanschaften bei Gruppenübergereifender Folgerunde
IstMannschaftenGegenueber(spiel);
// wenn Folgerunde existent
if (tkk.Matrix != "AdHoc")
{
int rundenAnz = ClsTurnierControler.Runden(ClsGlobal.Instance.TurnierID).Count;
if (spiel.Runde < rundenAnz)
{
int neueRunde = spiel.Runde;
neueRunde += 1;
ClsDBVariablen.Instance.SetTextVariableWert("S17", neueRunde.ToString());
// ClsLocalisationFunctions.Keytext("Text", "01") + " " + runde;
ClsMessage.SendMessage("Runde beendet", "rundenwechsel...");
ClsTurnierControler.SaveRundenStatus(ClsGlobal.Instance.TurnierID, neueRunde, 1);
}
}
}
// prüfen ob alle Spiele in allen Runden in Turnier beendet
List <TSpiele> spiele3 = ClsTurnierControler.Spiele(ClsGlobal.Instance.TurnierID);
int ts = (from grp in spiele3
where grp.Status < 3
select grp).Count();
if (ts == 0)
{
ClsTurnierControler.SaveTurnierStatus(ClsGlobal.Instance.TurnierID, 3);
// ClsFunktionen.fillTreeViewdetails( turniernr, tvBrowser);
ClsMessage.SendMessage("Turnier beendet.", "Geschaft...");
////ClsTranslateControls.ShowMessage("M0017", "Meldung", new object[] { "\n" }, MessageBoxButtons.OK);
}
}
ClsDBVariablen.Instance.SetTabellenVariableWert("T01", ClsTabellenfunktionen.TabelleToVariable_Json(ClsGlobal.Instance.TurnierID));
if (rundenwechsel == true)
{
return(2);
}
return(1);
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(0);
}
}
public static string TabelleToVariable_Json(int turnierID)
{
try
{
ClsTabellenVariabeln tv = ClsDBVariablen.Instance.GetTabellenVariable("T01");
bool kname = Convert.ToBoolean(ClsOptionsControler.Options3("kurznamen").Value);
string Runde = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T01" && x.Field == "Runde").Value;
string Gruppe = ClsGlobal.Instance.TableFilterList.Find(x => x.Table == "T01" && x.Field == "Gruppe").Value;
if (string.IsNullOrEmpty(Runde))
{
Runde = "0";
}
int runde = Convert.ToInt32(Runde);
// Create a DataTable for buildup
DataTable tempTable = new DataTable();
// Spalte je Anzeigespalte erstellen
List <Anzeigetabelle> cols1 = ClsOptionsControler.Anzeigetabelle("T01", "std");
List <Anzeigetabelle> cols = (from x in cols1 where x.Sichtbar == 1 select x).ToList();
string[] spalten = new string[cols.Count + 1];
if (cols.Any())
{
spalten[0] = "ID";
for (int i = 0; i < cols.Count; i++)
{
spalten[i + 1] = cols[i].DBFeld;
}
}
// Tabelle lesen
List <TTabellen> tab = ClsTurnierControler.Tabellen(turnierID);
// Daten filtern
if (Runde != "0")
{
tab = (from t in tab
where t.Runde == runde
select t).ToList();
}
if (!string.IsNullOrEmpty(Gruppe))
{
tab = (from t in tab
where t.Gruppe == Gruppe
select t).ToList();
}
// Daten sortieren
tab = (from t in tab
orderby t.Runde, t.Gruppe, t.Platz
select t).ToList();
//// Seite berechnen
int recPerPage = tv.RecPerPage;
int skip = calacSkipRecords("T02", recPerPage, (decimal)tab.Count());
// tabseite
tab = (from t in tab select t).Skip(skip).Take(recPerPage).ToList();
// Werte übersetzen
if (tab.Any())
{
for (int i = 0; i < tab.Count; i++)
{
if (kname)
{
tab[i].Mannschaft = Kurzname(tab[i].Mannschaft);
}
}
}
// Mache aus List ein Datatable
using (var reader = FastMember.ObjectReader.Create(tab, spalten))
{
tempTable.Load(reader);
}
// Spalten übersetzen
for (int i = 0; i < tempTable.Columns.Count; i++)
{
// Anzeigename
string text = (from x in cols where x.DBFeld == tempTable.Columns[i].ColumnName select x.Anzeigename).FirstOrDefault();
if (string.IsNullOrEmpty(text))
{
//text = ClsLocalisationFunctions.Tabellenfeld("Tabelle", tempTable.Columns[i].ColumnName);
text = ClsTextControler.TextByNameAndNumber("Tabelle", tempTable.Columns[i].ColumnName);
}
if (!string.IsNullOrEmpty(text))
{
tempTable.Columns[i].ColumnName = text;
}
}
return(ConvertDatatabletoString(tempTable));
// tempTable.Dispose();
}
catch (Exception ex)
{
ClsError.Error(Name, MethodBase.GetCurrentMethod().ToString(), ex);
return(null);
}
}
/// <summary>
/// Gibt das TSpiele-Objekt zurück für die SpielNr innerhalb des Turnieres. (SpielNR is nicht gleich SpielID)
/// </summary>
/// <param name="SpielNr"></param>
/// <returns></returns>
public static TSpiele MatchByNr(int SpielNr)
{
return(ClsTurnierControler.Spiel(ClsGlobal.Instance.TurnierID, SpielNr));
}
