예제 #1
0
        public void Publizieren()
        {
            this.Ergebnis           = ArbeitsbereichPublizieren.ergebnisse.erfolgreich;
            this._ergebnisProtokoll = new StringBuilder();
            this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("PublizierungGestartet"));
            if (!this._arbeitsbereich.SindAlleZuExportierendenDateienFehlerFrei)
            {
                this.ZeigeFehler(GaitoBotEditorCore.ResReader.Reader.GetString("PublizierenNichtAlleAIMLDateienKorrekt"), "Publizieren:Checking AIML-Files");
                this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
            }
            else
            {
                string gaitoBotEditorID = this._arbeitsbereich.GaitoBotID;
                if (gaitoBotEditorID != null)
                {
                    gaitoBotEditorID = gaitoBotEditorID.Trim();
                }
                if (string.IsNullOrEmpty(gaitoBotEditorID))
                {
                    this.ZeigeFehler(GaitoBotEditorCore.ResReader.Reader.GetString("KeineGaitoBotIDEingegeben"), "Publizieren:Checking GaitoBotID");
                    this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                }
                else
                {
                    bool flag;
                    try
                    {
                        flag = PublizierDienst.ExistsGaitoBotID(this._arbeitsbereich.GaitoBotID);
                    }
                    catch (Exception ex)
                    {
                        this.ZeigeFehler(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("FehlerBeiGaitoBotWebServiceZugriff"), (object)ex.Message), nameof(Publizieren));
                        this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                        goto label_33;
                    }
                    if (flag)
                    {
                        this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("GaitotbotIDExistiert"));
                        this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("AIMLDateienWerdenExportiert"));
                        bool abgebrochen = false;
                        this._arbeitsbereich.Exportieren(this.ExportVerzeichnis, Arbeitsbereich.VerzeichnisVorherLeeren.leerenUndNichtVorherFragen, true, true, out abgebrochen);
                        if (abgebrochen)
                        {
                            this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                        }
                        else
                        {
                            long num1 = (long)(int)(this.GroesseExportInByte / 1024L);
                            this.Protkolliere(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("AIMLExportGroesseLautetKB"), (object)num1));
                            long num2 = PublizierDienst.MaxKBWissen(this._arbeitsbereich.GaitoBotID);
                            this.Protkolliere(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("AIMLExportGroesseErlaubtKB"), (object)num2));
                            if (num1 > num2)
                            {
                                this.ZeigeFehler(GaitoBotEditorCore.ResReader.Reader.GetString("AIMLExportZuGrossFuerPublizieren"), "Publizieren:Checking export size");
                                this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                            }
                            else
                            {
                                this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("LoescheAlteAIMLDateienRemote"));
                                List <DateiPublizierungsInfos> source1 = new List <DateiPublizierungsInfos>();
                                foreach (string file in Directory.GetFiles(this.ExportVerzeichnis, "*.*"))
                                {
                                    DateiPublizierungsInfos publizierungsInfos1 = new DateiPublizierungsInfos();
                                    publizierungsInfos1.SetzeWerte(file);
                                    DateiPublizierungsInfos publizierungsInfos2 = new DateiPublizierungsInfos()
                                    {
                                        CRC32Checksumme = publizierungsInfos1.CRC32Checksumme, Dateiname = publizierungsInfos1.Dateiname, Groesse = publizierungsInfos1.Groesse, GesamtCheckString = publizierungsInfos1.GesamtCheckString
                                    };
                                    source1.Add(publizierungsInfos2);
                                }
                                string[] toDoDateinamen = (string[])null;
                                try
                                {
                                    toDoDateinamen = PublizierDienst.AlteOderGeloeschteDateienLoeschenUndHochzuladendeZurueckGeben(this._arbeitsbereich.GaitoBotID, source1.ToArray());
                                }
                                catch (Exception ex)
                                {
                                    this.ZeigeFehler(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("FehlerBeimRemoteLoeschen"), (object)ex.Message), "Publizieren:deleting old remote files");
                                    this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                                    goto label_33;
                                }
                                IEnumerable <DateiPublizierungsInfos> source2 = source1.Where <DateiPublizierungsInfos>((Func <DateiPublizierungsInfos, bool>)(toDo => ((IEnumerable <string>)toDoDateinamen).Contains <string>(toDo.Dateiname)));
                                this.Protkolliere(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("AnzahlDateienZuPublizieren"), (object)source2.Count <DateiPublizierungsInfos>()));
                                foreach (DateiPublizierungsInfos publizierungsInfos in source2)
                                {
                                    try
                                    {
                                        this.Protkolliere(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("PubliziereDatei"), (object)publizierungsInfos.Dateiname));
                                        AIMLDateiUebertragung aimlDateiInhalt = new AIMLDateiUebertragung()
                                        {
                                            CheckString = publizierungsInfos.GesamtCheckString, Dateiname = publizierungsInfos.Dateiname, Inhalt = ToolboxStrings.File2String(Path.Combine(this.ExportVerzeichnis, publizierungsInfos.Dateiname))
                                        };
                                        PublizierDienst.UebertrageAIMLDatei(gaitoBotEditorID, aimlDateiInhalt);
                                    }
                                    catch (Exception ex)
                                    {
                                        this.ZeigeFehler(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("FehlerBeimDateiPublizieren"), (object)publizierungsInfos.Dateiname, (object)ex.Message), "Publizieren:transfering file");
                                        this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                                    }
                                }
                                try
                                {
                                    this.Protkolliere("Resete GaitoBot auf Server");
                                    PublizierDienst.ReseteGaitoBot(gaitoBotEditorID);
                                }
                                catch (Exception ex)
                                {
                                    this.ZeigeFehler(string.Format(GaitoBotEditorCore.ResReader.Reader.GetString("FehlerBeimDateiPublizieren"), (object)"", (object)ex.Message), "Publizieren:reseting gaitobot on server");
                                    this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                                }
                            }
                        }
                    }
                    else
                    {
                        this.ZeigeFehler(GaitoBotEditorCore.ResReader.Reader.GetString("GaitotbotIDExistiertNicht"), "Publizieren:Checking GaitoBotID");
                        this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.fehlerhaft;
                    }
                }
            }
label_33:
            this.TempverzeichnisWiederLoeschen();
            switch (this.Ergebnis)
            {
            case ArbeitsbereichPublizieren.ergebnisse.erfolgreich:
                this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("PublizierungErfolgreich"));
                break;

            case ArbeitsbereichPublizieren.ergebnisse.fehlerhaft:
                this.Protkolliere(GaitoBotEditorCore.ResReader.Reader.GetString("PublizierungFehlerhaft"));
                break;

            default:
                throw new ApplicationException("Unbehandeltes Publizierungsergebnis: " + (object)this.Ergebnis);
            }
            this.Ergebnis = ArbeitsbereichPublizieren.ergebnisse.erfolgreich;
        }
예제 #2
0
        public void Publizieren()
        {
            this.Ergebnis           = ergebnisse.erfolgreich;
            this._ergebnisProtokoll = new StringBuilder();
            this.Protkolliere(ResReader.Reader.GetString("PublizierungGestartet"));
            if (!this._arbeitsbereich.SindAlleZuExportierendenDateienFehlerFrei)
            {
                this.ZeigeFehler(ResReader.Reader.GetString("PublizierenNichtAlleAIMLDateienKorrekt"), "Publizieren:Checking AIML-Files");
                this.Ergebnis = ergebnisse.fehlerhaft;
            }
            else
            {
                string text = this._arbeitsbereich.GaitoBotID;
                if (text != null)
                {
                    text = text.Trim();
                }
                if (string.IsNullOrEmpty(text))
                {
                    this.ZeigeFehler(ResReader.Reader.GetString("KeineGaitoBotIDEingegeben"), "Publizieren:Checking GaitoBotID");
                    this.Ergebnis = ergebnisse.fehlerhaft;
                }
                else
                {
                    bool flag = false;
                    try
                    {
                        flag = PublizierDienst.ExistsGaitoBotID(this._arbeitsbereich.GaitoBotID);
                    }
                    catch (Exception ex)
                    {
                        this.ZeigeFehler(string.Format(ResReader.Reader.GetString("FehlerBeiGaitoBotWebServiceZugriff"), ex.Message), "Publizieren");
                        this.Ergebnis = ergebnisse.fehlerhaft;
                        goto IL_04ab;
                    }
                    if (flag)
                    {
                        this.Protkolliere(ResReader.Reader.GetString("GaitotbotIDExistiert"));
                        this.Protkolliere(ResReader.Reader.GetString("AIMLDateienWerdenExportiert"));
                        bool flag2 = false;
                        this._arbeitsbereich.Exportieren(this.ExportVerzeichnis, Arbeitsbereich.VerzeichnisVorherLeeren.leerenUndNichtVorherFragen, true, true, out flag2);
                        if (flag2)
                        {
                            this.Ergebnis = ergebnisse.fehlerhaft;
                        }
                        else
                        {
                            long num = (int)(this.GroesseExportInByte / 1024);
                            this.Protkolliere(string.Format(ResReader.Reader.GetString("AIMLExportGroesseLautetKB"), num));
                            long num2 = PublizierDienst.MaxKBWissen(this._arbeitsbereich.GaitoBotID);
                            this.Protkolliere(string.Format(ResReader.Reader.GetString("AIMLExportGroesseErlaubtKB"), num2));
                            if (num > num2)
                            {
                                this.ZeigeFehler(ResReader.Reader.GetString("AIMLExportZuGrossFuerPublizieren"), "Publizieren:Checking export size");
                                this.Ergebnis = ergebnisse.fehlerhaft;
                            }
                            else
                            {
                                this.Protkolliere(ResReader.Reader.GetString("LoescheAlteAIMLDateienRemote"));
                                List <DateiPublizierungsInfos> list = new List <DateiPublizierungsInfos>();
                                string[] files = Directory.GetFiles(this.ExportVerzeichnis, "*.*");
                                foreach (string dateinameMitPfad in files)
                                {
                                    DateiPublizierungsInfos dateiPublizierungsInfos = new DateiPublizierungsInfos();
                                    dateiPublizierungsInfos.SetzeWerte(dateinameMitPfad);
                                    DateiPublizierungsInfos item = new DateiPublizierungsInfos
                                    {
                                        CRC32Checksumme   = dateiPublizierungsInfos.CRC32Checksumme,
                                        Dateiname         = dateiPublizierungsInfos.Dateiname,
                                        Groesse           = dateiPublizierungsInfos.Groesse,
                                        GesamtCheckString = dateiPublizierungsInfos.GesamtCheckString
                                    };
                                    list.Add(item);
                                }
                                string[] toDoDateinamen = null;
                                try
                                {
                                    toDoDateinamen = PublizierDienst.AlteOderGeloeschteDateienLoeschenUndHochzuladendeZurueckGeben(this._arbeitsbereich.GaitoBotID, list.ToArray());
                                }
                                catch (Exception ex2)
                                {
                                    this.ZeigeFehler(string.Format(ResReader.Reader.GetString("FehlerBeimRemoteLoeschen"), ex2.Message), "Publizieren:deleting old remote files");
                                    this.Ergebnis = ergebnisse.fehlerhaft;
                                    goto IL_04ab;
                                }
                                IEnumerable <DateiPublizierungsInfos> enumerable = from toDo in list
                                                                                   where toDoDateinamen.Contains(toDo.Dateiname)
                                                                                   select toDo;
                                this.Protkolliere(string.Format(ResReader.Reader.GetString("AnzahlDateienZuPublizieren"), enumerable.Count()));
                                foreach (DateiPublizierungsInfos item2 in enumerable)
                                {
                                    try
                                    {
                                        this.Protkolliere(string.Format(ResReader.Reader.GetString("PubliziereDatei"), item2.Dateiname));
                                        AIMLDateiUebertragung aimlDateiInhalt = new AIMLDateiUebertragung
                                        {
                                            CheckString = item2.GesamtCheckString,
                                            Dateiname   = item2.Dateiname,
                                            Inhalt      = ToolboxStrings.File2String(Path.Combine(this.ExportVerzeichnis, item2.Dateiname))
                                        };
                                        PublizierDienst.UebertrageAIMLDatei(text, aimlDateiInhalt);
                                    }
                                    catch (Exception ex3)
                                    {
                                        this.ZeigeFehler(string.Format(ResReader.Reader.GetString("FehlerBeimDateiPublizieren"), item2.Dateiname, ex3.Message), "Publizieren:transfering file");
                                        this.Ergebnis = ergebnisse.fehlerhaft;
                                    }
                                }
                                try
                                {
                                    this.Protkolliere("Resete GaitoBot auf Server");
                                    PublizierDienst.ReseteGaitoBot(text);
                                }
                                catch (Exception ex4)
                                {
                                    this.ZeigeFehler(string.Format(ResReader.Reader.GetString("FehlerBeimDateiPublizieren"), "", ex4.Message), "Publizieren:reseting gaitobot on server");
                                    this.Ergebnis = ergebnisse.fehlerhaft;
                                }
                            }
                        }
                    }
                    else
                    {
                        this.ZeigeFehler(ResReader.Reader.GetString("GaitotbotIDExistiertNicht"), "Publizieren:Checking GaitoBotID");
                        this.Ergebnis = ergebnisse.fehlerhaft;
                    }
                }
            }
            goto IL_04ab;
IL_04ab:
            this.TempverzeichnisWiederLoeschen();
            switch (this.Ergebnis)
            {
            case ergebnisse.erfolgreich:
                this.Protkolliere(ResReader.Reader.GetString("PublizierungErfolgreich"));
                break;

            case ergebnisse.fehlerhaft:
                this.Protkolliere(ResReader.Reader.GetString("PublizierungFehlerhaft"));
                break;

            default:
                throw new ApplicationException("Unbehandeltes Publizierungsergebnis: " + this.Ergebnis);
            }
            this.Ergebnis = ergebnisse.erfolgreich;
        }