private async Task _deleteTaxonAsync(Taxon[] taxa) { // Ensure that the user has necessary privileges to use this command. if (!await BotUtils.ReplyHasPrivilegeAsync(Context, PrivilegeLevel.ServerModerator)) { return; } if (await BotUtils.ReplyAsync_ValidateTaxa(Context, taxa)) { if ((await TaxonUtils.GetSpeciesAsync(taxa[0])).Count() > 0) { // If the taxon still has species underneath of it, don't allow it to be deleted. await BotUtils.ReplyAsync_Error(Context, "Taxa containing species cannot be deleted."); } else { // The taxon is empty, so delete the taxon. await TaxonUtils.DeleteTaxonAsync(taxa[0]); await BotUtils.ReplyAsync_Success(Context, string.Format("{0} **{1}** was successfully deleted.", StringUtils.ToTitleCase(taxa[0].GetTypeName()), taxa[0].GetName())); } } }
static Manager() { if (LicenseManager.UsageMode == LicenseUsageMode.Designtime) { return; } string path = TaxonUtils.GetConfigFilePath(); if (Directory.Exists(path)) { string[] files = Directory.GetFiles(path); string prefix = Path.GetFileNameWithoutExtension(TaxonUtils.GetConfigFileName("language_")).ToLower(); foreach (string f in files) { string fname = Path.GetFileNameWithoutExtension(f).ToLower(); if (fname.StartsWith(prefix)) { fname = fname.Replace(prefix, ""); if (fname.Length == 2) { Languages.Add(fname); } } } } Languages.Load(); Languages.Save(); CurrentLanguage = Languages.GetDefault(); IsDirty = false; StartWatcher(); }
public void Activate() { List <TaxonDesc> taxonToModify = new List <TaxonDesc>(); TaxonUtils.OriginalRoot.ParseNodeDesc((d) => { if (d.HasFrenchName && d.FrenchMultiName.Full.Contains(" ou ")) { taxonToModify.Add(d); } }); string logFile = Path.Combine(TaxonUtils.GetLogPath(), "SynonymRemoveOu.log"); using (StreamWriter log = new StreamWriter(logFile)) { log.WriteLine("Replace synonym separator ' ou ' with ';' (" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + ")\n"); log.WriteLine(" found " + taxonToModify.Count + " taxon that need to be changed\n\n"); string[] separatorArray = new string[] { " ou " }; foreach (TaxonDesc node in taxonToModify) { string oldName = node.FrenchMultiName.Full; node.FrenchMultiName = new Helpers.MultiName(string.Join(Helpers.MultiName.SeparatorAsString, node.FrenchMultiName.Full.Split(separatorArray, StringSplitOptions.RemoveEmptyEntries))); log.WriteLine("(" + node.RefMainName + ")" + oldName + " => " + node.FrenchMultiName.Full); } } string message = "Replacing synonym separator ' ou ' with ';' \n"; message += taxonToModify.Count + " taxons impacted\n"; message += "for more details, look at SynonymRemoveOu.log files"; Loggers.WriteInformation(LogTags.Data, message); }
public void Activate() { int count1 = 0; int count2 = 0; char[] forbiddenChar = "<>:\"/\\|?*".ToCharArray(); string logFile = Path.Combine(TaxonUtils.GetLogPath(), "CheckNames.log"); using (StreamWriter log = new StreamWriter(logFile)) { TaxonUtils.OriginalRoot.ParseNode((d) => { string name = d.Desc.RefMultiName.Main; if (name.Trim() != name) { count1++; log.WriteLine("empty spaces in " + d.GetHierarchicalName()); } if (name.IndexOfAny(forbiddenChar) != -1) { count2++; log.WriteLine("forbidden char in " + d.GetHierarchicalName()); } }); string message = "Name check:\n"; message += string.Format("{0} with spaces (or tab) at start or end of name\n", count1); message += string.Format("{0} with forbidden characters\n", count2); message += "more informations in " + logFile + " file.\n"; Loggers.WriteInformation(LogTags.Data, message); log.Write(message); } }
public void Activate() { _Result = new List <TaxonTreeNode>(); TaxonUtils.OriginalRoot.ParseNode(CheckLeaf); TaxonList list = new TaxonList { HasFile = true, FileName = Path.Combine(TaxonUtils.GetLogPath(), "ListOfNonSpeciesLeaves.lot") }; list.FromTaxonTreeNodeList(_Result); list.Save(false, TaxonList.FileFilterIndexEnum.ListOfTaxons); string message = string.Format("{0} taxons with no children and that are not species or sub species", _Result.Count); string logFile = Path.Combine(TaxonUtils.GetLogPath(), "ListOfNonSpeciesLeaves.log"); using (StreamWriter log = new StreamWriter(logFile)) { log.WriteLine(message); log.WriteLine(); foreach (TaxonTreeNode node in _Result) { log.WriteLine(node.GetHierarchicalName()); } } message += string.Format("\ntaxons found are saved as filter list in {0}", list.FileName); message += string.Format("\nfor more details, look at {0}", logFile); Loggers.WriteInformation(LogTags.Data, message); }
void ExportSounds(TaxonDesc desc, ExportData _data) { _data.ProgressItem.Update(_data.ProgressItem.Current + 1); if (desc.HasSound) { CopyFile(TaxonUtils.GetSoundFullPath(desc), true, _data); } }
public void Activate() { Data data = new Data(); TaxonUtils.OriginalRoot.ParseNode(CheckCollectionIds, data); string message = "CheckCollectionsIds results: \n\n"; message += String.Format(" Existents collections : {0} ids, {1} total images\n", data.Exists.Count, data.TotalExistsImage()); message += String.Format(" Inexistents collections: {0} ids, {1} total images\n", data.DontExists.Count, data.TotalDontExistsImage()); message += String.Format("for more details, look at CheckCollectionsIds.log file"); Loggers.WriteInformation(LogTags.Image, message); try { string file = Path.Combine(TaxonUtils.GetLogPath(), "CheckCollectionsIds.log"); if (File.Exists(file)) { File.Delete(file); } using (StreamWriter outfile = new StreamWriter(file)) { outfile.WriteLine("CheckCollectionsIds result ( " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + " )\n"); outfile.WriteLine("\n"); outfile.WriteLine(string.Format("Existent collections ( {0} ) :", data.Exists.Count)); foreach (KeyValuePair <int, int> p in data.Exists) { ImageCollection ic = TaxonImages.Manager.Collection(p.Key); string desc = " " + p.Key + " (" + p.Value + " images)"; if (ic == null) { outfile.WriteLine(desc + " not found in Manager"); } else { outfile.WriteLine(desc + " = " + ic.Name); } } outfile.WriteLine("\n"); outfile.WriteLine(string.Format("Inexistent collections ( {0} ) :", data.DontExists.Count)); foreach (KeyValuePair <int, int> p in data.DontExists) { string desc = " " + p.Key + " (" + p.Value + " images)"; outfile.WriteLine(desc); } } } catch (Exception e) { string error = "Exception while saving results in CheckCollectionsIds.log: \n\n"; error += e.Message; if (e.InnerException != null) { error += "\n" + e.InnerException.Message; } Loggers.WriteError(LogTags.Image, error); } }
private void OnSelectAndSetAsNewRoot(object sender, EventArgs e) { TaxonTreeNode selected = GetSelected(); TaxonUtils.CleanSubRoots(); TaxonUtils.PushSubRoot(selected); TaxonUtils.GotoTaxon(selected); TaxonUtils.SelectTaxon(selected); }
public void Activate() { int count1 = 0; int count2 = 0; int count3 = 0; int count4 = 0; string logFile = Path.Combine(TaxonUtils.GetLogPath(), "_TempCheck.log"); using (StreamWriter log = new StreamWriter(logFile)) { TaxonUtils.OriginalRoot.ParseNode((d) => { if (d.Desc.RefMultiName.Full.IndexOf('†') != -1 || (d.Desc.FrenchMultiName != null && d.Desc.FrenchMultiName.Full.Contains('†'))) { count1++; log.WriteLine("Cross in name for " + d.GetHierarchicalName()); } if (d.Desc.RedListCategory == RedListCategoryEnum.Extinct) { if (d.Desc.HasFlag(FlagsEnum.Extinct) || d.Desc.HasFlag(FlagsEnum.ExtinctInherited)) { d.Desc.SetFlagValue(FlagsEnum.Extinct, false); d.Desc.SetFlagValue(FlagsEnum.ExtinctInherited, false); count4++; } } else { if (d.Desc.HasFlag(FlagsEnum.ExtinctInherited)) { log.WriteLine("Extinct inherited: " + d.GetHierarchicalName()); count2++; } if (d.Desc.HasFlag(FlagsEnum.Extinct)) { log.WriteLine("Extinct: " + d.GetHierarchicalName()); count3++; } } }); string message = "Extinct check:\n"; message += string.Format("{0} with cross within name\n", count1); message += string.Format("{0} with extinct inherited flag\n", count2); message += string.Format("{0} with extinct flag\n", count3); if (count4 > 0) { message += string.Format("{0} remove extinct or extinct inherited flag\n", count4); message += string.Format("some data has been changed do not forget to save\n"); } message += "more informations in " + logFile + " file.\n"; Loggers.WriteInformation(LogTags.Data, message); log.Write(message); } }
private static void StartWatcher() { _Watcher = new FileSystemWatcher(); _Watcher.Path = TaxonUtils.GetConfigFilePath(); _Watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; _Watcher.Filter = "*.xml"; _Watcher.IncludeSubdirectories = false; _Watcher.Changed += new FileSystemEventHandler(OnChanged); _Watcher.EnableRaisingEvents = true; }
public void ScriptCall(string _name, int _index) { if (_index >= 0 && _index < Owner._HtmlDivs.Count) { TaxonTreeNode node = Owner._HtmlDivs[_index].Taxon; if (node != null && _name == node.Desc.RefMainName) { TaxonUtils.GotoTaxon(node); } } }
private async Task _deleteTaxonAsync(string name, TaxonRank rank) { // Ensure that the user has necessary privileges to use this command. if (!await BotUtils.ReplyHasPrivilegeAsync(Context, PrivilegeLevel.ServerModerator)) { return; } Taxon[] taxa = await TaxonUtils.GetTaxaAsync(name, rank); await _deleteTaxonAsync(taxa); }
private bool CheckFolder() { string folder = BuildFolder(); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } DirectoryInfo dir1 = new DirectoryInfo(folder); DirectoryInfo dir0 = new DirectoryInfo(TaxonUtils.GetTaxonPath()); return(dir0.FullName.ToLower() != dir1.FullName.ToLower()); }
public void Activate() { List <TaxonTreeNode> ListTaxons = new List <TaxonTreeNode>(); TaxonUtils.OriginalRoot.GetAllChildrenWithImageRecursively(ListTaxons); List <TaxonTreeNode> ListTaxonWithoutFrench = new List <TaxonTreeNode>(); foreach (TaxonTreeNode taxon in ListTaxons) { if (taxon.Desc.HasFrenchName) { ListTaxonWithoutFrench.Add(taxon); } } string message = "Check taxon with image but without French name:\n"; message += String.Format(" Total found: {0}\n", ListTaxonWithoutFrench.Count); message += String.Format("for more details, look at CheckImagesWithoutFrenchNames.log file"); Loggers.WriteInformation(LogTags.Image, message); try { string file = Path.Combine(TaxonUtils.GetLogPath(), "CheckImagesWithoutFrenchNames.log"); if (File.Exists(file)) { File.Delete(file); } using (StreamWriter outfile = new StreamWriter(file)) { outfile.WriteLine("CheckImagesWithoutFrenchNames result ( " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + " )\n"); outfile.WriteLine(string.Format("Taxon found: {0}", ListTaxonWithoutFrench.Count)); foreach (TaxonTreeNode taxon in ListTaxonWithoutFrench) { outfile.WriteLine(" " + taxon.GetHierarchicalName()); } } } catch (Exception e) { string error = "Exception while saving results in CheckImagesWithoutFrenchNames.log: \n\n"; error += e.Message; if (e.InnerException != null) { error += "\n" + e.InnerException.Message; } Loggers.WriteError(LogTags.Data, error); } }
private void buttonBrowse_Click(object sender, EventArgs e) { using (var fbd = new FolderBrowserDialog()) { fbd.Description = "Select Folder where new database will be saved"; fbd.SelectedPath = TaxonUtils.GetTaxonPath(); DialogResult result = fbd.ShowDialog(); if (result != DialogResult.OK || string.IsNullOrWhiteSpace(fbd.SelectedPath)) { return; } labelFolder.Text = fbd.SelectedPath; } }
public void Activate() { // retrouve la liste de toutes les especes List <TaxonTreeNode> Species = new List <TaxonTreeNode>(); TaxonUtils.OriginalRoot.GetAllChildrenRecursively(Species, ClassicRankEnum.Espece); List <TaxonTreeNode> badTaxons = new List <TaxonTreeNode>(); foreach (TaxonTreeNode t in Species) { if (t.Desc.RefMultiName.Main.Contains(" ")) { continue; } badTaxons.Add(t); } string message = "Check species named with only one word : "; if (badTaxons.Count == 0) { message += "none found\n"; Loggers.WriteInformation(LogTags.Data, message); return; } message += String.Format("found {0} species\n\n", badTaxons.Count); message += String.Format("for more details, look at CheckSpeciesWithoutSpaceChar.log file"); Loggers.WriteInformation(LogTags.Data, message); string file = Path.Combine(TaxonUtils.GetLogPath(), "CheckSpeciesWithoutSpaceChar.log"); if (File.Exists(file)) { File.Delete(file); } using (StreamWriter outfile = new StreamWriter(file)) { outfile.WriteLine("CheckSpeciesWithoutSpaceChar result ( " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + " )\n"); outfile.WriteLine("Find " + badTaxons.Count.ToString() + " species named with only one word\n"); foreach (TaxonTreeNode taxon in badTaxons) { outfile.WriteLine(" " + taxon.GetHierarchicalName()); } } }
//========================================================================================= // Export / Import // public static void ExportAllLanguages() { Dictionary <Language, Dictionary <string, string> > allText = new Dictionary <Language, Dictionary <string, string> >(); foreach (var lang in Languages.GetAvailableLanguages()) { Dictionary <string, string> result = LoadLanguage(lang.Iso); if (result != null) { allText[lang] = result; } } // get all keys Dictionary <string, bool> allKeys = new Dictionary <string, bool>(); foreach (var perLang in allText) { foreach (string key in perLang.Value.Keys) { allKeys[key] = true; } } List <string> listKeys = allKeys.Keys.ToList(); listKeys.Sort(); string exportFile = Path.Combine(TaxonUtils.GetConfigFilePath(), "AllTexts.csv"); using (TextWriter writer = new StreamWriter(exportFile)) { string headerLine = "Key;" + string.Join(";", allText.Keys); writer.WriteLine(headerLine); foreach (string key in listKeys) { string line = key; foreach (var dico in allText.Values) { line += ";"; if (dico.TryGetValue(key, out string value)) { line += value; } } writer.WriteLine(line); } } }
public GenerateNewDatabaseDialog(TaxonTreeNode _taxon, GenerateNewDatabaseConfig _config) { InitializeComponent(); _Taxon = _taxon; _Config = _config; if (_Taxon == null) { return; } labelTaxon.Text = _Taxon.Desc.RefMainName; labelTaxon.Tag = new Localization.Tag { Ignore = true }; labelFolder.Text = Path.Combine(TaxonUtils.GetTaxonPath(), "NewDatas"); ApplyConfig(); }
public void Activate() { _Data = new ComputeClassicRankData(); TaxonUtils.OriginalRoot.GetAllLastChildrenRecursively(_Data.Leaves); string file = Path.Combine(TaxonUtils.GetLogPath(), "ComputeClassicRank.log"); if (File.Exists(file)) { File.Delete(file); } using (_Data.Writer = new StreamWriter(file)) { ComputeTwoWordsSpeciesSupSpecies(); ComputeWithoutLatinName(); ComputeSubSpeciesSecond(); ComputeSpeciesFirst(); ComputeSubGenreFirst(); ComputeGenreFirst(); _Data.Holozoa = TaxonUtils.OriginalRoot.FindTaxonByName("holozoa"); if (_Data.Holozoa != null) { Compute4Animals(); } Compute4Others(); } string message = ""; message += String.Format("detect {0} new sub species\n", _Data.NewSubSpecies); message += String.Format("detect {0} new species\n", _Data.NewSpecies); message += String.Format("detect {0} new sub genre\n", _Data.NewSousGenre); message += String.Format("detect {0} new genre\n", _Data.NewGenre); message += String.Format("detect {0} new sous tribu\n", _Data.NewSousTribu); message += String.Format("detect {0} new tribus\n", _Data.NewTribu); message += String.Format("detect {0} new sous familles\n", _Data.NewSousFamille); message += String.Format("detect {0} new familles\n", _Data.NewFamille); message += String.Format("detect {0} new super famille\n", _Data.NewSuperFamille); message += String.Format("detect {0} new order\n", _Data.NewOrder); message += String.Format("detect {0} new without latin name\n", _Data.WithoutLatinName.Count); message += String.Format("for more details, look at ComputeClassicRank.log file"); Loggers.WriteInformation(LogTags.Data, message); }
//-------------------------------------------------------------------------------------- protected override void OnMouseDoubleClick(MouseEventArgs e) { if (MouseDoubleClickMode == MouseDoubleClickModeEnum.DoNothing) { return; } if (GetSelected() == null) { return; } TaxonUtils.GotoTaxon(GetSelected()); if (MouseDoubleClickMode == MouseDoubleClickModeEnum.SelectTaxon) { TaxonUtils.SelectTaxon(GetSelected()); } }
public void Activate() { List <TaxonTreeNode> extincts = new List <TaxonTreeNode>(); List <TaxonTreeNode> extinctsInherited = new List <TaxonTreeNode>(); string logFile = Path.Combine(TaxonUtils.GetLogPath(), "ExtinctsTaxons.log"); using (StreamWriter log = new StreamWriter(logFile)) { log.WriteLine("Move extinct flag to red list category EX (" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + ")\n"); TaxonUtils.OriginalRoot.ParseNode((d) => { if (d.Desc.HasFlag(FlagsEnum.Extinct)) { extincts.Add(d); } if (d.Desc.HasFlag(FlagsEnum.ExtinctInherited)) { extinctsInherited.Add(d); } }); log.WriteLine("taxon with extincts flag: " + extincts.Count.ToString()); foreach (TaxonTreeNode node in extincts) { log.WriteLine(" [" + node.Desc.RedListCategory.ToString() + "] " + node.GetHierarchicalName()); } log.WriteLine(); log.WriteLine("taxon with extincts inherited flag: " + extincts.Count.ToString()); foreach (TaxonTreeNode node in extinctsInherited) { log.WriteLine(" [" + node.Desc.RedListCategory.ToString() + "] " + node.GetHierarchicalName()); } log.WriteLine(); string message = "Move extinct flag to red list category EX results:\n"; message += string.Format("{0} taxons with extinct flag\n", extincts.Count.ToString()); message += string.Format("{0} taxons with extinct inherited flag\n", extinctsInherited.Count.ToString()); message += string.Format("for more details, look at {0}", logFile); Loggers.WriteInformation(LogTags.Data, message); log.Write(message); } }
private void button1_Click(object sender, EventArgs e) { button1.Enabled = false; bool success = dataSettingsControl1.updateData(); if (success) { TaxonUtils.initCollections(); TaxonUtils.OriginalRoot.UpdateAvailableImages(); TaxonControlList.OnAvailableImagesChanged(); Close(); } else { button1.Enabled = true; } }
//-------------------------------------------------------------------------------------- void ContextMenuStrip_Opening(object sender, System.ComponentModel.CancelEventArgs e) { ContextMenuStrip.Items.Clear(); ToolStripMenuItem menuItem; TaxonTreeNode taxon = GetSelected(); if (taxon != null) { menuItem = new ToolStripMenuItem(Localization.Manager.Get("_GotoTaxon", "Goto {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnGoto)); ContextMenuStrip.Items.Add(menuItem); menuItem = new ToolStripMenuItem(Localization.Manager.Get("_SelectTaxon", "Select {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnSelect)); ContextMenuStrip.Items.Add(menuItem); menuItem = new ToolStripMenuItem(Localization.Manager.Get("_SelectTaxonAndSetAsNewRoot", "Select and set as new root {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnSelectAndSetAsNewRoot)); ContextMenuStrip.Items.Add(menuItem); menuItem = TaxonUtils.FavoritesMenuItem(taxon); if (menuItem != null) { ContextMenuStrip.Items.Add(new ToolStripSeparator()); ContextMenuStrip.Items.Add(menuItem); } } if (CanBeSorted) { List <TaxonTreeNode> list = DataSource as List <TaxonTreeNode>; if (list.Count > 1) { if (ContextMenuStrip.Items.Count > 0) { ContextMenuStrip.Items.Add(new ToolStripSeparator()); } menuItem = new ToolStripMenuItem(Localization.Manager.Get("_Sort", "Sort")); menuItem.DropDownItems.Add(Localization.Manager.Get("_SortAlpha", "Alpha"), null, new System.EventHandler(OnSort)); menuItem.DropDownItems.Add(Localization.Manager.Get("_SortReverseAlpha", "Reverse Alpha"), null, new System.EventHandler(OnSort)); menuItem.DropDownItems.Add(Localization.Manager.Get("_SortTree", "Tree"), null, new System.EventHandler(OnSort)); menuItem.DropDownItems.Add(Localization.Manager.Get("_SortReverseTree", "Reverse Tree"), null, new System.EventHandler(OnSort)); ContextMenuStrip.Items.Add(menuItem); } } e.Cancel = ContextMenuStrip.Items.Count == 0; }
public void Activate() { int countDescChanged = 0; int countExtinct = 0; string logFile = Path.Combine(TaxonUtils.GetLogPath(), "RemoveExtinctCross.log"); using (StreamWriter log = new StreamWriter(logFile)) { log.WriteLine("Remove '†' (" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + ")\n"); TaxonUtils.OriginalRoot.ParseNodeDesc((d) => { if (d.RefMultiName.Main.Length == 0) { return; } if (d.RefMultiName.Main[d.RefMultiName.Main.Length - 1] == '†') { log.WriteLine(" " + d.RefMultiName.Main); List <string> names = d.RefMultiName.GetAll().ToList(); for (int i = 0; i < names.Count; i++) { names[i] = names[i].Replace("†", "").Trim(); } d.RefMultiName = new Helpers.MultiName(names); d.Flags |= (uint)FlagsEnum.Extinct; countDescChanged++; countExtinct++; } else if ((d.Flags & (uint)FlagsEnum.Extinct) != 0) { countExtinct++; } }); string message = "Remove Extinct Cross:\n"; message += String.Format("{0} extinct taxon renamed\n", countDescChanged); message += String.Format("{0} extinct taxons (with flags)\n", countExtinct); Loggers.WriteInformation(LogTags.Data, message); log.Write(message); } }
string BuildFranceMap(string _name) { if (TaxonUtils.Locations == null || _Current == null) { return(""); } TaxonTreeNode original = _Current.GetOriginal(); if (original == null || !TaxonUtils.Locations.LocationByTaxon.TryGetValue(original, out string Ids)) { return(""); } France.Map map = new France.Map(); foreach (string id in Ids.Split("|".ToCharArray())) { map.SetTheme(id, "on"); } _MapFileCount = (_MapFileCount + 1) % 100; string file = "comment_france_map" + _MapFileCount.ToString("D3") + ".jpg"; string path = Path.Combine(TaxonUtils.GetTempPath(), file); if (File.Exists(path)) { File.Delete(path); } map.CreateTexture(path, 0.6f); int count = 0; while (!File.Exists(path) && ++count < 4) { System.Threading.Thread.Sleep(500); } string result = ""; result += "<p><img src=\"" + path + "\" xmlns = \"\" /></p>"; return(result); }
public static void ImportAllLanguages() { Regex isoRegex = new Regex("\\((.*)\\)"); using (TextReader reader = new StreamReader(Path.Combine(TaxonUtils.GetConfigFilePath(), "AllTexts.csv"))) { // reade head line string line = reader.ReadLine(); if (line == null) { return; } string[] parts = line.Split(';'); int numColumns = parts.Length; if (numColumns <= 1) { return; } if (parts[0].Trim().ToLower() != "key") { return; } List <Tuple <Language, Dictionary <string, string> > > allText = new List <Tuple <Language, Dictionary <string, string> > >(); for (int i = 1; i < numColumns; i++) { Match isoMatch = isoRegex.Match(parts[i]); if (!isoMatch.Success || isoMatch.Groups.Count < 2) { return; } string iso = isoMatch.Groups[1].Value; Language lang = Languages.Get(iso, true); allText.Add(new Tuple <Language, Dictionary <string, string> >(lang, new Dictionary <string, string>())); } Dictionary <string, bool> keyDone = new Dictionary <string, bool>(); while ((line = reader.ReadLine()) != null) { parts = line.Split(';'); if (parts.Length != numColumns) { continue; } if (keyDone.ContainsKey(parts[0])) { continue; } keyDone[parts[0]] = true; for (int i = 1; i < numColumns; i++) { if (!String.IsNullOrEmpty(parts[i])) { allText[i - 1].Item2[parts[0]] = parts[i]; } } } foreach (var data in allText) { SaveLanguage(data.Item1.Iso, data.Item2); } } }
public bool Build(ContextMenuStrip _menu) { if (Taxon == null) { return(false); } ToolStripMenuItem menuItem; // goto menuItem = new ToolStripMenuItem( Localization.Manager.Get("_GotoTaxon", "Goto {0}", Taxon.Desc.RefMainName), null, new System.EventHandler(OnGoto)) { Tag = Taxon }; _menu.Items.Add(menuItem); // select if (TaxonUtils.SelectedTaxon() != Taxon) { menuItem = new ToolStripMenuItem( Localization.Manager.Get("_SelectTaxon", "Select {0}", Taxon.Desc.RefMainName), null, new System.EventHandler(OnSelect)) { Tag = Taxon }; _menu.Items.Add(menuItem); } // ascendants List <TaxonTreeNode> Ascendants = new List <TaxonTreeNode>(); Taxon.GetAllParents(Ascendants, false, false, false); if (Ascendants.Count > 0) { menuItem = new ToolStripMenuItem(Localization.Manager.Get("_SelectAscendant", "Select ascendant")); _menu.Items.Add(menuItem); foreach (TaxonTreeNode node in Ascendants) { ToolStripMenuItem subMenuItem = new ToolStripMenuItem( node.Desc.RefMainName, null, new System.EventHandler(OnSelect)) { Tag = node }; menuItem.DropDownItems.Add(subMenuItem); } } // add open image if ImagePath has been setup string imagePath = ImageDesc?.GetPath(Taxon.Desc); if (imagePath != null) { _menu.Items.Add(new ToolStripSeparator()); menuItem = new ToolStripMenuItem( Localization.Manager.Get("_OpenImage", "Open image {0}", imagePath), null, new EventHandler(OnOpenImage)) { Tag = imagePath }; _menu.Items.Add(menuItem); menuItem = new ToolStripMenuItem( Localization.Manager.Get("_LocateImage", "Locate image in explorer"), null, new EventHandler(OnLocateImage)) { Tag = imagePath }; _menu.Items.Add(menuItem); } // add favorite menu menuItem = TaxonUtils.FavoritesMenuItem(Taxon); if (menuItem != null) { _menu.Items.Add(new ToolStripSeparator()); _menu.Items.Add(menuItem); } menuItem = BuildAdvanced(); if (menuItem != null) { _menu.Items.Add(new ToolStripSeparator()); _menu.Items.Add(menuItem); } return(true); }
private void OnSelect(object sender, EventArgs e) { TaxonUtils.GotoTaxon(GetTag <TaxonTreeNode>(sender)); TaxonUtils.SelectTaxon(GetTag <TaxonTreeNode>(sender)); }
public void Activate() { OpenFileDialog ofd = new OpenFileDialog { Filter = "Jac Files (*.txt)|*.txt", Multiselect = false, AddExtension = true }; if (ofd.ShowDialog() != DialogResult.OK) { return; } if (!File.Exists(ofd.FileName)) { return; } TaxonTreeNode importNodes = TaxonTreeNode.Load(ofd.FileName); string shortName = Path.GetFileNameWithoutExtension(ofd.FileName); int errorNoTaxon = 0; int errorTwoManyTaxon = 0; int redListCategoryChanged = 0; string logFilenameErrors = Path.Combine(TaxonUtils.GetLogPath(), "ImportRedListCategory_" + shortName + ".log"); using (StreamWriter log = new StreamWriter(logFilenameErrors)) { if (importNodes == null || importNodes.Children == null || importNodes.Children.Count == 0) { log.WriteLine("no taxon found in file " + ofd.FileName); Loggers.WriteInformation(LogTags.Data, "no taxon found in file " + ofd.FileName); return; } TaxonSearch searchTool = new TaxonSearch(TaxonUtils.OriginalRoot, true, true); foreach (TaxonTreeNode node in importNodes.Children) { List <TaxonTreeNode> dests = searchTool.FindAll(node.Desc.RefMainName); if (dests == null || dests.Count == 0) { errorNoTaxon++; log.WriteLine("Error, no matching taxons found for that name: " + node.Desc.RefMainName); } else if (dests.Count > 1) { errorTwoManyTaxon++; log.WriteLine("Error, two many taxons found for that name: " + node.Desc.RefMainName); } else { if (dests[0].Desc.RedListCategory == node.Desc.RedListCategory) { log.WriteLine(node.Desc.RefMainName + " no change, is already " + node.Desc.RedListCategory.ToString()); } else { redListCategoryChanged++; log.WriteLine(node.Desc.RefMainName + " redlist category change from " + dests[0].Desc.RedListCategory.ToString() + " to " + node.Desc.RedListCategory.ToString()); dests[0].Desc.RedListCategory = node.Desc.RedListCategory; } } } } string message = "Importing red list category from: " + ofd.FileName + "\n"; message += String.Format(" Total taxons: {0}\n", importNodes.Children.Count); message += String.Format(" taxon not found: {0}\n", errorNoTaxon); message += String.Format(" taxon find more than one time: {0}\n", errorTwoManyTaxon); message += String.Format(" changed taxons: {0}\n", redListCategoryChanged); if (redListCategoryChanged > 0) { message += string.Format("some data has been changed do not forget to save\n"); } message += String.Format("for more details, look at ImportRedListCategory_{0}.log files", shortName); Loggers.WriteInformation(LogTags.Data, message); }
public async Task DeleteTaxon(string name) { Taxon[] taxa = await TaxonUtils.GetTaxaAsync(name); await _deleteTaxonAsync(taxa); }