public static TaxonRankType GetChildRank(TaxonRankType rank) { switch (rank) { case TaxonRankType.Species: return(TaxonRankType.None); case TaxonRankType.Genus: return(TaxonRankType.Species); case TaxonRankType.Family: return(TaxonRankType.Genus); case TaxonRankType.Order: return(TaxonRankType.Family); case TaxonRankType.Class: return(TaxonRankType.Order); case TaxonRankType.Phylum: return(TaxonRankType.Class); case TaxonRankType.Kingdom: return(TaxonRankType.Phylum); case TaxonRankType.Domain: return(TaxonRankType.Kingdom); default: return(TaxonRankType.None); } }
// Protected members protected override async Task <bool> IsFilteredAsync(ISearchContext context, ISpecies species, string value) { TaxonRankType rank = ParseRankType(Name); switch (rank) { case TaxonRankType.Species: return(await Task.FromResult(!species.Name.Equals(value, StringComparison.OrdinalIgnoreCase))); case TaxonRankType.Genus: if (species.Genus != null) { return(await Task.FromResult(!species.Genus.Name.Equals(value, StringComparison.OrdinalIgnoreCase))); } else { return(true); } case TaxonRankType.Any: return(!(await context.Database.GetTaxaAsync(species)).Values.Any(taxon => taxon.Name.Equals(value, StringComparison.OrdinalIgnoreCase))); default: { ITaxon taxon = (await context.Database.GetTaxaAsync(species)).GetOrDefault(rank); return(taxon is null || !taxon.Name.Equals(value, StringComparison.OrdinalIgnoreCase)); } } }
// Public members public static string GetNameForRank(TaxonRankType rank, bool plural = false) { string result; if (plural) { result = GetPluralForRank(rank); } else { if (rank == TaxonRankType.None) { result = string.Empty; } else if (rank != TaxonRankType.Custom) { result = rank.ToString().ToLowerInvariant(); } else { throw new ArgumentOutOfRangeException(nameof(rank)); } } return(result); }
private async Task ReplyDeleteTaxonAsync(TaxonRankType rank, string taxonName) { ITaxon taxon = await GetTaxonOrReplyAsync(rank, taxonName); if (taxon.IsValid()) { await ReplyDeleteTaxonAsync(taxon); } }
private async Task ReplySetTaxonDescriptionAsync(TaxonRankType rank, string taxonName, string description) { ITaxon taxon = await GetTaxonOrReplyAsync(rank, taxonName); if (taxon.IsValid()) { await ReplySetTaxonDescriptionAsync(taxon, description); } }
private static string GetFieldNameForRank(TaxonRankType rank) { if (rank <= 0) { return(string.Empty); } return(string.Format("{0}_id", TaxonUtilities.GetNameForRank(rank).ToLowerInvariant())); }
private async Task ReplySetTaxonCommonNameAsync(TaxonRankType rank, string taxonName, string commonName) { ITaxon taxon = await GetTaxonOrReplyAsync(rank, taxonName); if (taxon.IsValid()) { await ReplySetTaxonCommonNameAsync(taxon, commonName); } }
// Private members private static string GetTableNameForRank(TaxonRankType rank) { string tableName = TaxonUtilities.GetNameForRank(rank).ToTitle(); if (tableName.Equals("Order")) { tableName = "Ord"; } return(tableName); }
public static string MapTaxonRankTypeToTaxonRankString(this TaxonRankType rank) { switch (rank) { case TaxonRankType.AboveGenus: return(TaxaClassificationConstants.AboveGenusTaxonRankStringValue); case TaxonRankType.AboveFamily: return(TaxaClassificationConstants.AboveFamilyTaxonRankStringValue); default: return(rank.ToString().ToLower()); } }
private async Task ReplySetTaxonPictureAsync(TaxonRankType rank, string taxonName, string imageUrl) { ITaxon taxon = await GetTaxonOrReplyAsync(rank, taxonName); if (taxon.IsValid() && await ReplyValidateImageUrlAsync(imageUrl)) { taxon.Pictures.Clear(); taxon.Pictures.Add(new Picture(imageUrl)); await Db.UpdateTaxonAsync(taxon); await ReplySuccessAsync($"Successfully set the picture for for {taxon.GetRank().GetName()} **{taxon.GetName().ToTitle()}**."); } }
public void GbifTaxaClassificationResolver_Resolve_ShouldWork() { const string CanonicalName = "Coleoptera"; const TaxonRankType Rank = TaxonRankType.Order; var connectorFactory = new NetConnectorFactory(); var requester = new GbifApiV09DataRequester(connectorFactory); var service = new GbifTaxaClassificationResolver(requester); var response = service.Resolve(CanonicalName).Result; var defaultClassification = response.FirstOrDefault(); Assert.AreEqual(CanonicalName, defaultClassification.CanonicalName, "CanonicalName should match."); Assert.AreEqual(Rank, defaultClassification.Rank, "Rank should match."); }
private async Task ReplySetTaxonParentAsync(TaxonRankType rank, string childTaxonName, string parentTaxonName) { ITaxon child = await GetTaxonOrReplyAsync(rank.GetChildRank(), childTaxonName); ITaxon parent = child.IsValid() ? await GetTaxonOrReplyAsync(rank, parentTaxonName) : null; if (child.IsValid() && parent.IsValid()) { child.ParentId = parent.Id; await Db.UpdateTaxonAsync(child); await ReplySuccessAsync($"{child.GetRank().GetName().ToSentence()} **{child.GetName().ToTitle()}** has sucessfully been placed under the {parent.GetRank().GetName()} **{parent.GetName().ToTitle()}**."); } }
public void CatalogueOfLifeTaxaClassificationDataService_Resolve_ShouldWork() { const string ScientificName = "Coleoptera"; const TaxonRankType Rank = TaxonRankType.Order; var requester = new CatalogueOfLifeDataRequester(new NetConnectorFactory()); var service = new CatalogueOfLifeTaxaClassificationResolver(requester); var response = service.Resolve(ScientificName).Result; Assert.IsNotNull(response, "Response should not be null."); var defaultClassification = response.SingleOrDefault(); Assert.AreEqual(ScientificName, defaultClassification.ScientificName, "ScientificName should match."); Assert.AreEqual(Rank, defaultClassification.Rank, "Rank should match."); }
// Private members private async Task ReplyTaxonOrTypeAsync(TaxonRankType rank, string taxonName) { if (string.IsNullOrWhiteSpace(taxonName)) { await ReplyTaxonAsync(rank); } else { ITaxon taxon = await GetTaxonOrReplyAsync(rank, taxonName); if (taxon.IsValid()) { await ReplyTaxonAsync(taxon); } } }
private ITaxonRank GetClassificationItem(Result result, TaxonRankType rank) { try { var name = result.Classification .FirstOrDefault(c => string.Compare(c.Rank, rank.MapTaxonRankTypeToTaxonRankString(), true) == 0) .Name; return(new TaxonRankServiceModel { ScientificName = name, Rank = rank }); } catch { return(null); } }
public async Task <ITaxon> ReplyTaxonSuggestionAsync(TaxonRankType rank, string taxonName) { IEnumerable <ITaxon> taxa = await Db.GetTaxaAsync(rank); int minimumDistance = int.MaxValue; ITaxon suggestion = null; foreach (ITaxon taxon in taxa) { int dist = StringUtilities.GetLevenshteinDistance(taxonName.ToLowerInvariant(), taxon.Name.ToLowerInvariant()); if (dist < minimumDistance) { minimumDistance = dist; suggestion = taxon; } } return(await ReplyNoSuchTaxonExistsAsync(taxonName, suggestion)); }
private async Task ReplyAddTaxonAsync(TaxonRankType rank, string taxonName, string description) { // Make sure that the taxon does not already exist before trying to add it. ITaxon taxon = (await Db.GetTaxaAsync(taxonName, rank)).FirstOrDefault(); if (taxon.IsValid()) { await ReplyWarningAsync($"The {rank.GetName()} **{taxon.GetName()}** already exists."); } else { taxon = new Common.Taxa.Taxon(rank, taxonName) { Name = taxonName, Description = description }; await Db.AddTaxonAsync(taxon); await ReplySuccessAsync($"Successfully created new {rank.GetName()}, **{taxon.GetName()}**."); } }
public async Task ReplyTaxonAsync(TaxonRankType rank) { // List all taxa of the given rank. IEnumerable <ITaxon> taxa = (await Db.GetTaxaAsync(rank)).OrderBy(t => t.GetName()); List <string> lines = new List <string>(); foreach (ITaxon taxon in taxa) { // Count the number of items under this taxon. int subtaxaCount = (await Db.GetSubtaxaAsync(taxon)).Count(); if (subtaxaCount > 0) { lines.Add($"{taxon.GetName().ToTitle()} ({subtaxaCount})"); } } if (lines.Count() <= 0) { await ReplyInfoAsync($"No {rank.GetName(true)} have been added yet."); } else { string title = $"All {rank.GetName(true)} ({lines.Count()})"; IEnumerable <Discord.Messaging.IEmbed> pages = EmbedUtilities.CreateEmbedPages(title.ToTitle(), lines, options: EmbedPaginationOptions.AddPageNumbers); foreach (Discord.Messaging.IEmbed page in pages) { page.Footer += $" — Empty {rank.GetName(true)} are not listed."; } await ReplyAsync(new PaginatedMessage(pages)); } }
public static async Task <IEnumerable <ITaxon> > GetTaxaAsync(this SQLiteDatabase database, string name) { // Return all taxa that have the given name. List <ITaxon> result = new List <ITaxon>(); TaxonRankType[] ranks = new TaxonRankType[] { TaxonRankType.Domain, TaxonRankType.Kingdom, TaxonRankType.Phylum, TaxonRankType.Class, TaxonRankType.Order, TaxonRankType.Family, TaxonRankType.Genus, TaxonRankType.Species }; foreach (TaxonRankType rank in ranks) { result.AddRange(await database.GetTaxaAsync(name, rank)); } return(result); }
public static TaxonRankType MapTaxonRankStringToTaxonRankType(this string rank) { TaxonRankType rankType = TaxonRankType.Other; if (!string.IsNullOrWhiteSpace(rank)) { switch (rank.ToLower()) { case TaxaClassificationConstants.AboveGenusTaxonRankStringValue: rankType = TaxonRankType.AboveGenus; break; case TaxaClassificationConstants.AboveFamilyTaxonRankStringValue: rankType = TaxonRankType.AboveFamily; break; default: Enum.TryParse(rank, true, out rankType); break; } } return(rankType); }
public async Task <ITaxon> ReplyNoSuchTaxonExistsAsync(string input, ITaxon suggestion, TaxonRankType rank = TaxonRankType.None) { string taxonName = rank == TaxonRankType.None ? "taxon" : rank.GetName(); if (suggestion != null) { taxonName = suggestion.GetRank().GetName(); } StringBuilder sb = new StringBuilder(); if (string.IsNullOrWhiteSpace(input)) { sb.Append($"No such {taxonName} exists."); } else { sb.Append($"No {taxonName} named \"{input}\" exists."); } if (suggestion != null) { string suggestionText = (suggestion is ISpecies species) ? species.GetFullName() : suggestion.GetName().ToTitle(); sb.Append($" Did you mean **{suggestionText}**?"); } IPaginatedMessage message = new PaginatedMessage(sb.ToString()) { Restricted = true }; if (suggestion != null) { bool confirmed = false; message.AddReaction(PaginatedMessageReactionType.Yes, async(args) => { confirmed = true; await Task.CompletedTask; }); await ReplyAndWaitAsync(message); if (!confirmed) { suggestion = null; } } else { await ReplyAsync(message); } return(suggestion); }
public static async Task <IEnumerable <ITaxon> > GetTaxaAsync(this SQLiteDatabase database, TaxonRankType rank) { List <ITaxon> taxa = new List <ITaxon>(); string tableName = GetTableNameForRank(rank); if (string.IsNullOrEmpty(tableName)) { return(Enumerable.Empty <ITaxon>()); } using (SQLiteCommand cmd = new SQLiteCommand(string.Format("SELECT * FROM {0}", tableName))) foreach (DataRow row in await database.GetRowsAsync(cmd)) { taxa.Add(await database.CreateTaxonFromDataRowAsync(row, rank)); } return(taxa); }
public static async Task <ITaxon> CreateTaxonFromDataRowAsync(this SQLiteDatabase database, DataRow row, TaxonRankType rank) { ITaxon taxon = new Taxon(rank, row.Field <string>("name")) { Id = row.Field <long>("id"), Description = row.Field <string>("description") }; if (!row.IsNull("common_name") && !string.IsNullOrWhiteSpace(row.Field <string>("common_name"))) { taxon.CommonNames.Add(row.Field <string>("common_name")); } if (!row.IsNull("pics") && !string.IsNullOrWhiteSpace(row.Field <string>("pics"))) { taxon.Pictures.Add(new Picture(row.Field <string>("pics"))); } string parentIdFieldName = GetFieldNameForRank(TaxonUtilities.GetParentRank(rank)); if (!string.IsNullOrEmpty(parentIdFieldName) && !row.IsNull(parentIdFieldName)) { taxon.ParentId = row.Field <long>(parentIdFieldName); } return(await Task.FromResult(taxon)); }
public static async Task <ITaxon> GetTaxonAsync(this SQLiteDatabase database, long?id, TaxonRankType rank) { string tableName = GetTableNameForRank(rank); if (string.IsNullOrEmpty(tableName) || !id.HasValue) { return(null); } ITaxon taxon = null; using (SQLiteCommand cmd = new SQLiteCommand(string.Format("SELECT * FROM {0} WHERE id = $id", tableName))) { cmd.Parameters.AddWithValue("$id", id); DataRow row = await database.GetRowAsync(cmd); if (row != null) { taxon = await database.CreateTaxonFromDataRowAsync(row, rank); } } return(taxon); }
private void ReplaceTreatmentMetaClassificationItem(IDocument document, IEnumerable <ITaxonClassification> classification, string genus, TaxonRankType rank) { if (classification == null) { throw new ArgumentNullException(nameof(classification)); } var matchingHigherTaxa = classification .Select(c => c.Classification.SingleOrDefault(x => x.Rank == rank).ScientificName) .Distinct() .ToList(); var higherTaxaCount = matchingHigherTaxa.Count(); switch (higherTaxaCount) { case 0: this.logger?.Log(LogType.Warning, "Zero matches for rank {0}.", rank); break; case 1: { string taxonName = matchingHigherTaxa.Single(); this.logger?.Log("{0}: {1}\t--\t{2}", genus, rank, taxonName); string xpath = string.Format(TreatmentMetaReplaceXPathTemplate, genus, rank.MapTaxonRankTypeToTaxonRankString()); document.SelectNodes(xpath) .AsParallel() .ForAll(node => { node.InnerText = taxonName; }); } break; default: { this.logger?.Log(LogType.Warning, "Multiple matches for rank {0}:", rank); foreach (string taxonName in matchingHigherTaxa) { this.logger?.Log("{0}: {1}\t--\t{2}", genus, rank, taxonName); } this.logger?.Log(); } break; } }
public async Task <ITaxon> GetTaxonOrReplyAsync(TaxonRankType rank, string taxonName) { IEnumerable <ITaxon> taxa = await Db.GetTaxaAsync(taxonName, rank); return(await GetTaxonOrReplyAsync(taxa, rank, taxonName)); }
public static async Task <IEnumerable <ITaxon> > GetTaxaAsync(this SQLiteDatabase database, string name, TaxonRankType rank) { if (rank == TaxonRankType.Any) { return(await database.GetTaxaAsync(name)); } else { List <ITaxon> taxa = new List <ITaxon>(); string tableName = GetTableNameForRank(rank); if (string.IsNullOrEmpty(tableName) || string.IsNullOrEmpty(name)) { return(Enumerable.Empty <ITaxon>()); } using (SQLiteCommand cmd = new SQLiteCommand(string.Format("SELECT * FROM {0} WHERE name = $name OR common_name = $name COLLATE NOCASE", tableName))) { cmd.Parameters.AddWithValue("$name", name.ToLowerInvariant()); foreach (DataRow row in await database.GetRowsAsync(cmd)) { taxa.Add(await database.CreateTaxonFromDataRowAsync(row, rank)); } } return(taxa); } }
public static TaxonRankType GetParentRank(this TaxonRankType rankType) { return(TaxonUtilities.GetParentRank(rankType)); }
private async Task <ITaxon> GetTaxonOrReplyAsync(IEnumerable <ITaxon> matchingTaxa, TaxonRankType rank, string taxonName) { ITaxon taxon = null; if (matchingTaxa.Count() <= 0) { // The taxon could not be found. taxon = await ReplyTaxonSuggestionAsync(rank, taxonName); } else if (matchingTaxa.Count() > 1) { // Multiple taxa were found. await ReplyMatchingTaxaAsync(matchingTaxa); } else { // We have a single taxon. taxon = matchingTaxa.First(); } return(taxon); }
public static async Task <ITaxon> GetTaxonAsync(this SQLiteDatabase database, string name, TaxonRankType rank) { return((await database.GetTaxaAsync(name, rank)).FirstOrDefault()); }