Example #1
0
        public AIMLDatei AddAimlLeereDatei(
            Arbeitsbereich arbeitsbereich,
            bool ersteDateiMitBeispielen)
        {
            if (arbeitsbereich.Dateiverwaltung != this)
            {
                throw new ApplicationException("Arbeitsbereich passt nicht zur ArbeitsbereichDateiverwaltung!");
            }
            string vorgabe = (string)null;

            if (ersteDateiMitBeispielen)
            {
                vorgabe = ResReader.Reader.GetString("MeineErsteAimlDatei");
            }
            bool   abgebrochen;
            string str = this.ErmittleFreienNamenFuerAimlDatei(vorgabe, "aiml", out abgebrochen);

            if (abgebrochen)
            {
                return((AIMLDatei)null);
            }
            AIMLDatei aimlDatei = new AIMLDatei(arbeitsbereich);

            aimlDatei.OnChanged += new EventHandler(this.AimlDateiOnChanged);
            if (ersteDateiMitBeispielen)
            {
                aimlDatei.MitTargetBotStartFuellen();
            }
            else
            {
                aimlDatei.LeerFuellen();
            }
            aimlDatei.Dateiname = str;
            bool cancel;

            aimlDatei.Save(out cancel);
            this._dateien.Add((IArbeitsbereichDatei)aimlDatei);
            this.DateiAdded((IArbeitsbereichDatei)aimlDatei);
            return(aimlDatei);
        }
        public AIMLDatei AddAimlLeereDatei(Arbeitsbereich arbeitsbereich, bool ersteDateiMitBeispielen)
        {
            if (arbeitsbereich.Dateiverwaltung != this)
            {
                throw new ApplicationException("Arbeitsbereich passt nicht zur ArbeitsbereichDateiverwaltung!");
            }
            string vorgabe = null;

            if (ersteDateiMitBeispielen)
            {
                vorgabe = ResReader.Reader.GetString("MeineErsteAimlDatei");
            }
            bool   flag      = default(bool);
            string dateiname = this.ErmittleFreienNamenFuerAimlDatei(vorgabe, "aiml", out flag);

            if (flag)
            {
                return(null);
            }
            AIMLDatei aIMLDatei = new AIMLDatei(arbeitsbereich);

            aIMLDatei.OnChanged += this.AimlDateiOnChanged;
            if (ersteDateiMitBeispielen)
            {
                aIMLDatei.MitTargetBotStartFuellen();
            }
            else
            {
                aIMLDatei.LeerFuellen();
            }
            aIMLDatei.Dateiname = dateiname;
            bool flag2 = default(bool);

            aIMLDatei.Save(out flag2);
            this._dateien.Add(aIMLDatei);
            this.DateiAdded(aIMLDatei);
            return(aIMLDatei);
        }
Example #3
0
 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 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;
        }