예제 #1
0
        public static void SaveAnzeigetabelle(ClsCommand rb)
        {
            Core.DB.Anzeigetabelle at = new JavaScriptSerializer().Deserialize <Core.DB.Anzeigetabelle>(rb.Value1);
            Core.DBControler.ClsOptionsControler.SaveAnzeigetabelle(at);

            if (at.Tabelle == "T01")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(at.Tabelle, ClsTabellenfunktionen.TabelleToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (at.Tabelle == "T02")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(at.Tabelle, ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (at.Tabelle == "T03")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(at.Tabelle, ClsTabellenfunktionen.EreignisseToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (at.Tabelle == "Strafen")
            {
                ClsTabellenfunktionen.StrafenToVariable(ClsGlobal.Instance.Strafen1, "A");
                ClsTabellenfunktionen.StrafenToVariable(ClsGlobal.Instance.Strafen2, "B");
            }

            if (at.Tabelle == "T06")
            {
                ClsTabellenfunktionen.TorschuetzeToVariable(ClsGlobal.Instance.TurnierID);
            }

            GlobalServerEvents.SendMessage(null, new ClsStringEventArgs(ClsRequests.DataRequest(new ClsCommand(command: "Anzeigetabellen"))));
        }
예제 #2
0
        public static void RecPerPageChange(ClsCommand rb)
        {
            ClsDBVariablen.Instance.SetTabellenVariableRecPerPage(rb.Value1, Convert.ToInt32(rb.Value2));
            if (rb.Value1 == "T01")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.TabelleToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (rb.Value1 == "T02")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (rb.Value1 == "T03")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.EreignisseToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            GlobalServerEvents.SendMessage(null, new ClsStringEventArgs(ClsRequests.DataRequest(new ClsCommand(command: "TVariablen"))));
        }
        private static void Turnierwechsel(int turnierID)
        {
            // Tabellenfilter
            ClsTabellenfunktionen.IniTableFilter();

            // TurnierTabellen
            ClsDBVariablen.Instance.SetTabellenVariableWert("T01", ClsTabellenfunktionen.TabelleToVariable_Json(turnierID));

            // te - TurnierErgebnisse(spielplan)
            ClsDBVariablen.Instance.SetTabellenVariableWert("T02", ClsTabellenfunktionen.SpielplanToVariable_Json(turnierID));

            // tg - TurnierGruppen (und Combofelder zum filtern der Tabelleninhalten füllen)
            ////this.LoadGruppenToTG();

            // tn - TurnierEreignisse
            ClsDBVariablen.Instance.SetTabellenVariableWert("T03", ClsTabellenfunktionen.EreignisseToVariable_Json(turnierID));

            // th - Torjäger
            ClsTabellenfunktionen.TorschuetzeToVariable(turnierID);
        }
예제 #4
0
        public static void SetTablefilter(ClsCommand rb)
        {
            // Filter setzen
            (from x in ClsGlobal.Instance.TableFilterList where x.Table == rb.Value1 && x.Field == rb.Value2 select x).FirstOrDefault().Value = rb.Value3;

            // Filter zurück an clients senden
            GlobalServerEvents.SendMessage(null, new ClsStringEventArgs(ClsRequests.DataRequest(new ClsCommand(command: "TableFilter"))));

            // Tabelleninhalt setzetn
            switch (rb.Value1)
            {
            case "T01":
                ClsDBVariablen.Instance.SetTabellenVariableWert("T01", ClsTabellenfunktionen.TabelleToVariable_Json(ClsGlobal.Instance.TurnierID));
                break;

            case "T02":
                ClsDBVariablen.Instance.SetTabellenVariableWert("T02", ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
                break;

            case "T03":
                ClsDBVariablen.Instance.SetTabellenVariableWert("T03", ClsTabellenfunktionen.EreignisseToVariable_Json(ClsGlobal.Instance.TurnierID));
                break;
            }
        }
예제 #5
0
        public static void TablePageSelection(ClsCommand rb)
        {
            ClsTableFilter tf = (from x
                                 in ClsGlobal.Instance.TableFilterList
                                 where x.Table == rb.Value1 && x.Field == "SelPage"
                                 select x).FirstOrDefault();

            tf.IntValue = Convert.ToInt32(rb.Value2);

            if (rb.Value1 == "T01")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.TabelleToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (rb.Value1 == "T02")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.SpielplanToVariable_Json(ClsGlobal.Instance.TurnierID));
            }

            if (rb.Value1 == "T03")
            {
                ClsDBVariablen.Instance.SetTabellenVariableWert(rb.Value1, ClsTabellenfunktionen.EreignisseToVariable_Json(ClsGlobal.Instance.TurnierID));
            }
        }
예제 #6
0
        /// <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);
            }
        }