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());
}
