public static string EingabePatternOptimieren(string rohEingabe, bool sternErlaubt)
{
if (rohEingabe.Length == 0)
{
return("");
}
char[] array = rohEingabe.ToCharArray();
ArrayList arrayList = new ArrayList();
for (int i = 0; i < array.Length; i++)
{
if ((array[i] > '@' & array[i] < '[') || (array[i] > '`' & array[i] < '{') || (array[i] > '/' & array[i] < ':') || array[i] == ' ')
{
arrayList.Add(array[i]);
}
else if (sternErlaubt && array[i] == '*')
{
arrayList.Add(array[i]);
}
}
char[] array2 = new char[arrayList.Count];
for (int j = 0; j < arrayList.Count; j++)
{
array2[j] = (char)arrayList[j];
}
string eingabe = new string(array2);
eingabe = ToolboxStrings.DoppelteLeerzeichenRaus(eingabe);
return(eingabe.Trim());
}
public static string EingabePatternOptimieren(string rohEingabe, bool sternErlaubt)
{
if (rohEingabe.Length == 0)
{
return("");
}
char[] charArray = rohEingabe.ToCharArray();
ArrayList arrayList = new ArrayList();
for (int index = 0; index < charArray.Length; ++index)
{
if (charArray[index] > '@' & charArray[index] < '[' || charArray[index] > '`' & charArray[index] < '{' || charArray[index] > '/' & charArray[index] < ':' || charArray[index] == ' ')
{
arrayList.Add((object)charArray[index]);
}
else if (sternErlaubt && charArray[index] == '*')
{
arrayList.Add((object)charArray[index]);
}
}
char[] chArray = new char[arrayList.Count];
for (int index = 0; index < arrayList.Count; ++index)
{
chArray[index] = (char)arrayList[index];
}
return(ToolboxStrings.DoppelteLeerzeichenRaus(new string(chArray)).Trim());
}
private string ErmittleFreienNamenFuerAimlDatei(
string vorgabe,
string extension,
out bool abgebrochen)
{
abgebrochen = false;
bool flag = false;
string str1 = "";
if (string.IsNullOrEmpty(vorgabe))
{
vorgabe = ResReader.Reader.GetString("unbenannt");
}
do
{
string original = InputBox.Show(ResReader.Reader.GetString("NamenFuerNeueAIMLDateiAngeben"), ResReader.Reader.GetString("NeueAIMLDateiErzeugen"), vorgabe, out abgebrochen);
if (string.IsNullOrEmpty(original))
{
abgebrochen = true;
}
if (!abgebrochen)
{
flag = false;
string str2 = ToolboxStrings.ReplaceEx(ToolboxStrings.ReplaceEx(ToolboxStrings.ReplaceEx(ToolboxStrings.ReplaceEx(ToolboxStrings.ReplaceEx(ToolboxStrings.ReplaceEx(original, string.Format(".{0}", (object)"aiml"), ""), string.Format(".{0}", (object)"startup"), ""), ".xml", ""), ".", "_"), "\\", "_"), "/", "_").Trim();
if (str2 == "")
{
flag = true;
}
else
{
str1 = string.Format("{0}\\{1}.{2}", (object)this._arbeitsVerzeichnis, (object)str2, (object)extension);
if (File.Exists(str1))
{
int num = (int)MessageBox.Show(ResReader.Reader.GetString("AIMLDateiSchonVorhanden"));
flag = true;
}
else
{
try
{
ToolboxStrings.String2File("test", str1);
File.Delete(str1);
}
catch (Exception ex)
{
int num = (int)MessageBox.Show(string.Format(ResReader.Reader.GetString("AIMLDateiNameUngueltigOderKeinZugriff"), (object)ex.Message));
flag = true;
}
}
}
}
}while (!abgebrochen & flag);
if (abgebrochen)
{
str1 = (string)null;
}
return(str1);
}
private string ErsetzungenDurchfuehren(
List <DictionaryEntry> ersetzungen,
string rohEingabe,
bool kreisUbersetzungenVermeiden)
{
Hashtable hashtable = (Hashtable)null;
if (kreisUbersetzungenVermeiden)
{
hashtable = new Hashtable();
}
if (rohEingabe.Length < 1)
{
return("");
}
if (ersetzungen.Count < 1)
{
return(rohEingabe);
}
string original = " " + rohEingabe + " ";
foreach (DictionaryEntry dictionaryEntry in ersetzungen)
{
string key = (string)dictionaryEntry.Key;
if (!kreisUbersetzungenVermeiden || !hashtable.Contains((object)key.ToLower()))
{
string replacement = (string)dictionaryEntry.Value;
if (kreisUbersetzungenVermeiden)
{
string str = original;
original = ToolboxStrings.ReplaceEx(original, key, replacement);
if (str != original)
{
hashtable.Add((object)replacement.ToLower(), (object)null);
}
}
else
{
original = ToolboxStrings.ReplaceEx(original, key, replacement);
}
}
}
return(original.Trim());
}
private string ErsetzungenDurchfuehren(List <DictionaryEntry> ersetzungen, string rohEingabe, bool kreisUbersetzungenVermeiden)
{
Hashtable hashtable = null;
if (kreisUbersetzungenVermeiden)
{
hashtable = new Hashtable();
}
if (rohEingabe.Length < 1)
{
return("");
}
if (ersetzungen.Count < 1)
{
return(rohEingabe);
}
string text = " " + rohEingabe + " ";
foreach (DictionaryEntry item in ersetzungen)
{
string text2 = (string)item.Key;
if (!kreisUbersetzungenVermeiden || !hashtable.Contains(text2.ToLower()))
{
string text3 = (string)item.Value;
if (kreisUbersetzungenVermeiden)
{
string a = text;
text = ToolboxStrings.ReplaceEx(text, text2, text3);
if (a != text)
{
hashtable.Add(text3.ToLower(), null);
}
}
else
{
text = ToolboxStrings.ReplaceEx(text, text2, text3);
}
}
}
return(text.Trim());
}
public void Suchen(string suchEingabe, Arbeitsbereich.WoSuchenOrte woSuchen)
{
suchEingabe = ToolboxStrings.UmlauteAussschreiben(suchEingabe);
this.SucheImArbeitsbereichEvent(suchEingabe, woSuchen);
}
public void Exportieren(
string exportVerzeichnis,
Arbeitsbereich.VerzeichnisVorherLeeren verzeichnisVorherLeeren,
bool alleStarTagsInExtraDateiExportieren,
bool exportFuerGaitoBotDePublizierung,
out bool abgebrochen)
{
if (!Directory.Exists(exportVerzeichnis))
{
throw new ApplicationException(string.Format("Exportverzeichnis '{0}' nicht vorhanden!", (object)exportVerzeichnis));
}
if ((uint)verzeichnisVorherLeeren > 0U)
{
if (verzeichnisVorherLeeren == Arbeitsbereich.VerzeichnisVorherLeeren.leerenUndVorherFragen && MessageBox.Show(string.Format(ResReader.Reader.GetString("ExportVerzeichnisWirklichLeeren"), (object)exportVerzeichnis), ResReader.Reader.GetString("Export"), MessageBoxButtons.YesNo) != DialogResult.Yes)
{
abgebrochen = true;
return;
}
foreach (string directory in Directory.GetDirectories(exportVerzeichnis))
{
try
{
Directory.Delete(directory, true);
}
catch (Exception ex)
{
int num = (int)MessageBox.Show(string.Format(ml.ml_string(70, "Das Verzeichnis '{0}' konnte nicht gelöscht werden: {1}"), (object)directory, (object)ex.Message));
abgebrochen = true;
return;
}
}
foreach (string file in Directory.GetFiles(exportVerzeichnis))
{
try
{
File.Delete(file);
}
catch (Exception ex)
{
int num = (int)MessageBox.Show(string.Format(ml.ml_string(71, "Die Datei '{0}' konnte nicht gelöscht werden: {1}"), (object)file, (object)ex.Message));
abgebrochen = true;
return;
}
}
}
if (alleStarTagsInExtraDateiExportieren)
{
StringCollection stringCollection = new StringCollection();
foreach (IArbeitsbereichDatei arbeitsbereichDatei in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
if (arbeitsbereichDatei is AIMLDatei)
{
AIMLDatei aimlDatei1 = (AIMLDatei)arbeitsbereichDatei;
AIMLDatei aimlDatei2 = new AIMLDatei(this);
aimlDatei2.LiesAusString(aimlDatei1.XML.OuterXml);
List <AIMLCategory> aimlCategoryList = new List <AIMLCategory>();
foreach (AIMLCategory category in aimlDatei2.RootTopic.Categories)
{
if (category.That == "" && category.Pattern == "*")
{
stringCollection.Add(category.Template);
aimlCategoryList.Add(category);
}
}
foreach (AIMLCategory category in aimlCategoryList)
{
aimlDatei2.RootTopic.LoescheCategory(category);
}
StringBuilder stringBuilder = new StringBuilder();
foreach (string str in aimlDatei1.Unterverzeichnisse)
{
stringBuilder.AppendFormat("{0}_", (object)str);
}
string str1 = string.Format("{0}\\{1}{2}.aiml", (object)exportVerzeichnis, (object)stringBuilder.ToString(), (object)aimlDatei1.Titel);
aimlDatei2.Dateiname = str1;
bool cancel = false;
aimlDatei2.Save(out cancel);
}
}
if ((uint)stringCollection.Count > 0U)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<pattern>*</pattern><template><random>");
foreach (string str in stringCollection)
{
stringBuilder.AppendFormat("<li>{0}</li>", (object)str);
}
stringBuilder.Append("</random></template>");
AIMLDatei aimlDatei = new AIMLDatei(this);
aimlDatei.LeerFuellen();
aimlDatei.Dateiname = string.Format("{0}\\_stars_.aiml", (object)exportVerzeichnis);
aimlDatei.RootTopic.AddNewCategory().ContentNode.InnerXml = stringBuilder.ToString();
bool cancel = false;
if (File.Exists(aimlDatei.Dateiname))
{
File.Delete(aimlDatei.Dateiname);
}
aimlDatei.Save(out cancel);
}
foreach (IArbeitsbereichDatei arbeitsbereichDatei in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
if (arbeitsbereichDatei is StartupDatei)
{
StartupDatei startupDatei = (StartupDatei)arbeitsbereichDatei;
StringBuilder stringBuilder = new StringBuilder();
foreach (string baustein in arbeitsbereichDatei.Unterverzeichnisse)
{
stringBuilder.AppendFormat("{0}_", (object)this.DateinameBausteinBereinigt(baustein));
}
string str1 = "startup";
string str2 = string.Format("{0}\\{1}{2}.{3}", (object)exportVerzeichnis, (object)stringBuilder.ToString(), (object)this.DateinameBausteinBereinigt(startupDatei.Titel), (object)str1);
string dateiname = startupDatei.Dateiname;
if (string.IsNullOrEmpty(dateiname))
{
ToolboxStrings.String2File(startupDatei.XML.OuterXml, str2);
}
else
{
File.Copy(dateiname, str2, true);
}
}
}
}
else
{
foreach (IArbeitsbereichDatei arbeitsbereichDatei in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
StringBuilder stringBuilder = new StringBuilder();
foreach (string baustein in arbeitsbereichDatei.Unterverzeichnisse)
{
stringBuilder.AppendFormat("{0}_", (object)this.DateinameBausteinBereinigt(baustein));
}
string str1;
if (arbeitsbereichDatei is AIMLDatei)
{
str1 = "aiml";
}
else
{
if (!(arbeitsbereichDatei is StartupDatei))
{
throw new ApplicationException(string.Format("Datei '{0}' hat einen unbekannten Typ", (object)arbeitsbereichDatei.Titel));
}
str1 = "startup";
}
string str2 = string.Format("{0}\\{1}{2}.{3}", (object)exportVerzeichnis, (object)stringBuilder.ToString(), (object)this.DateinameBausteinBereinigt(arbeitsbereichDatei.Titel), (object)str1);
string dateiname = arbeitsbereichDatei.Dateiname;
if (string.IsNullOrEmpty(dateiname))
{
ToolboxStrings.String2File(arbeitsbereichDatei.XML.OuterXml, str2);
}
else
{
File.Copy(dateiname, str2, true);
}
}
}
abgebrochen = false;
}
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;
}
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;
}
public void Exportieren(string exportVerzeichnis, VerzeichnisVorherLeeren verzeichnisVorherLeeren, bool alleStarTagsInExtraDateiExportieren, bool exportFuerGaitoBotDePublizierung, out bool abgebrochen)
{
if (!Directory.Exists(exportVerzeichnis))
{
throw new ApplicationException(string.Format("Exportverzeichnis '{0}' nicht vorhanden!", exportVerzeichnis));
}
switch (verzeichnisVorherLeeren)
{
case VerzeichnisVorherLeeren.leerenUndVorherFragen:
{
DialogResult dialogResult = MessageBox.Show(string.Format(ResReader.Reader.GetString("ExportVerzeichnisWirklichLeeren"), exportVerzeichnis), ResReader.Reader.GetString("Export"), MessageBoxButtons.YesNo);
if (dialogResult != DialogResult.Yes)
{
abgebrochen = true;
return;
}
goto default;
}
default:
{
string[] directories = Directory.GetDirectories(exportVerzeichnis);
string[] array = directories;
foreach (string text in array)
{
try
{
Directory.Delete(text, true);
}
catch (Exception ex)
{
MessageBox.Show(string.Format(global::MultiLang.ml.ml_string(70, "Das Verzeichnis '{0}' konnte nicht gelöscht werden: {1}"), text, ex.Message));
abgebrochen = true;
return;
}
}
string[] files = Directory.GetFiles(exportVerzeichnis);
string[] array2 = files;
foreach (string text2 in array2)
{
try
{
File.Delete(text2);
}
catch (Exception ex2)
{
MessageBox.Show(string.Format(global::MultiLang.ml.ml_string(71, "Die Datei '{0}' konnte nicht gelöscht werden: {1}"), text2, ex2.Message));
abgebrochen = true;
return;
}
}
break;
}
case VerzeichnisVorherLeeren.nichtLeeren:
break;
}
if (alleStarTagsInExtraDateiExportieren)
{
StringCollection stringCollection = new StringCollection();
foreach (IArbeitsbereichDatei item in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
if (item is AIMLDatei)
{
AIMLDatei aIMLDatei = (AIMLDatei)item;
AIMLDatei aIMLDatei2 = new AIMLDatei(this);
aIMLDatei2.LiesAusString(aIMLDatei.XML.OuterXml);
List <AIMLCategory> list = new List <AIMLCategory>();
foreach (AIMLCategory category in aIMLDatei2.RootTopic.Categories)
{
if (category.That == "" && category.Pattern == "*")
{
stringCollection.Add(category.Template);
list.Add(category);
}
}
foreach (AIMLCategory item2 in list)
{
aIMLDatei2.RootTopic.LoescheCategory(item2);
}
StringBuilder stringBuilder = new StringBuilder();
string[] unterverzeichnisse = aIMLDatei.Unterverzeichnisse;
foreach (string arg in unterverzeichnisse)
{
stringBuilder.AppendFormat("{0}_", arg);
}
string text4 = aIMLDatei2.Dateiname = string.Format("{0}\\{1}{2}.aiml", exportVerzeichnis, stringBuilder.ToString(), aIMLDatei.Titel);
bool flag = false;
aIMLDatei2.Save(out flag);
}
}
if (stringCollection.Count != 0)
{
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder2.Append("<pattern>*</pattern><template><random>");
StringEnumerator enumerator4 = stringCollection.GetEnumerator();
try
{
while (enumerator4.MoveNext())
{
string current4 = enumerator4.Current;
stringBuilder2.AppendFormat("<li>{0}</li>", current4);
}
}
finally
{
IDisposable disposable = enumerator4 as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
stringBuilder2.Append("</random></template>");
AIMLDatei aIMLDatei3 = new AIMLDatei(this);
aIMLDatei3.LeerFuellen();
aIMLDatei3.Dateiname = string.Format("{0}\\_stars_.aiml", exportVerzeichnis);
AIMLCategory aIMLCategory = aIMLDatei3.RootTopic.AddNewCategory();
aIMLCategory.ContentNode.InnerXml = stringBuilder2.ToString();
bool flag2 = false;
if (File.Exists(aIMLDatei3.Dateiname))
{
File.Delete(aIMLDatei3.Dateiname);
}
aIMLDatei3.Save(out flag2);
}
foreach (IArbeitsbereichDatei item3 in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
if (item3 is StartupDatei)
{
StartupDatei startupDatei = (StartupDatei)item3;
StringBuilder stringBuilder3 = new StringBuilder();
string[] unterverzeichnisse2 = item3.Unterverzeichnisse;
foreach (string baustein in unterverzeichnisse2)
{
stringBuilder3.AppendFormat("{0}_", this.DateinameBausteinBereinigt(baustein));
}
string text5 = "startup";
string text6 = string.Format("{0}\\{1}{2}.{3}", exportVerzeichnis, stringBuilder3.ToString(), this.DateinameBausteinBereinigt(startupDatei.Titel), text5);
string dateiname = startupDatei.Dateiname;
if (string.IsNullOrEmpty(dateiname))
{
ToolboxStrings.String2File(startupDatei.XML.OuterXml, text6);
}
else
{
File.Copy(dateiname, text6, true);
}
}
}
}
else
{
foreach (IArbeitsbereichDatei item4 in this.GetZuExportierendeDateien(exportFuerGaitoBotDePublizierung))
{
StringBuilder stringBuilder4 = new StringBuilder();
string[] unterverzeichnisse3 = item4.Unterverzeichnisse;
foreach (string baustein2 in unterverzeichnisse3)
{
stringBuilder4.AppendFormat("{0}_", this.DateinameBausteinBereinigt(baustein2));
}
string text7 = "";
if (item4 is AIMLDatei)
{
text7 = "aiml";
goto IL_05c3;
}
if (item4 is StartupDatei)
{
text7 = "startup";
goto IL_05c3;
}
throw new ApplicationException(string.Format("Datei '{0}' hat einen unbekannten Typ", item4.Titel));
IL_05c3:
string text8 = string.Format("{0}\\{1}{2}.{3}", exportVerzeichnis, stringBuilder4.ToString(), this.DateinameBausteinBereinigt(item4.Titel), text7);
string dateiname2 = item4.Dateiname;
if (string.IsNullOrEmpty(dateiname2))
{
ToolboxStrings.String2File(item4.XML.OuterXml, text8);
}
else
{
File.Copy(dateiname2, text8, true);
}
}
}
abgebrochen = false;
}