public static TaxonRank TypeToChildType(TaxonRank type)
{
switch (type)
{
case TaxonRank.Species:
return(0);
case TaxonRank.Genus:
return(TaxonRank.Species);
case TaxonRank.Family:
return(TaxonRank.Genus);
case TaxonRank.Order:
return(TaxonRank.Family);
case TaxonRank.Class:
return(TaxonRank.Order);
case TaxonRank.Phylum:
return(TaxonRank.Class);
case TaxonRank.Kingdom:
return(TaxonRank.Phylum);
case TaxonRank.Domain:
return(TaxonRank.Kingdom);
default:
return(0);
}
}
public static TaxonRank MapTaxonRank(DbDataReader reader)
{
TaxonRank tr = new TaxonRank();
ReflectMap(tr, reader, null, null, _taxonMapper);
return(tr);
}
public static string GetRankName(TaxonRank type, bool plural = false)
{
switch (type)
{
case TaxonRank.Species:
return(plural ? "species" : "species");
case TaxonRank.Genus:
return(plural ? "genera" : "genus");
case TaxonRank.Family:
return(plural ? "families" : "family");
case TaxonRank.Order:
return(plural ? "orders" : "order");
case TaxonRank.Class:
return(plural ? "classes" : "class");
case TaxonRank.Phylum:
return(plural ? "phyla" : "phylum");
case TaxonRank.Kingdom:
return(plural ? "kingdoms" : "kingdom");
case TaxonRank.Domain:
return(plural ? "domains" : "domain");
default:
return(string.Empty);
}
}
public bool IsValidChild(TaxonRank src, TaxonRank dest)
{
if (dest != null)
{
ISet <string> valid = SplitCSV(dest.ValidChildList);
return(valid.Contains(src.Code, StringComparer.OrdinalIgnoreCase));
}
return(false);
}
private static string _getRankColumnName(TaxonRank rank)
{
if (rank <= 0)
{
return(string.Empty);
}
return(string.Format("{0}_id", Taxon.GetRankName(rank)));
}
} // deprecated
public static string TypeToDatabaseColumnName(TaxonRank type)
{
if (type <= 0)
{
return(string.Empty);
}
return(string.Format("{0}_id", GetRankName(type)));
} // deprecated
private static string _getRankTableName(TaxonRank rank)
{
string table_name = StringUtils.ToTitleCase(Taxon.GetRankName(rank));
if (table_name == "Order")
{
table_name = "Ord";
}
return(table_name);
}
public static string TypeToDatabaseTableName(TaxonRank type)
{
string table_name = StringUtils.ToTitleCase(GetRankName(type));
if (table_name == "Order")
{
table_name = "Ord";
}
return(table_name);
} // deprecated
public TaxonNameDetails(int?taxonId, User user, Action <TaxonNameViewModel> successAction) : base(user, "TaxonNameDetails::" + taxonId.Value)
{
_successAction = successAction;
var service = new TaxaService(user);
Taxon taxon = service.GetTaxon(taxonId.Value);
_rank = service.GetTaxonRank(taxon);
_kingdomList = service.GetKingdomList();
Kingdom kingdom = _kingdomList.Find((k) => k.KingdomCode.Equals(taxon.KingdomCode));
_model = new TaxonNameViewModel(taxon, kingdom, _rank);
_model.DataChanged += new DataChangedHandler(_model_DataChanged);
InitializeComponent();
cmbKingdom.ItemsSource = _kingdomList;
this.chkChangedCombination.Visibility = (_rank != null && _rank.Category == "S" ? Visibility.Visible : Visibility.Hidden);
if (taxon.AvailableName.ValueOrFalse() || taxon.LiteratureName.ValueOrFalse())
{
string phraseCategory = "ALN Name Status";
chkChangedCombination.Visibility = System.Windows.Visibility.Hidden;
if (taxon.AvailableName.ValueOrFalse())
{
TaxonRank rank = service.GetTaxonRank(taxon);
if (rank != null)
{
switch (rank.Category.ToLower())
{
case "g": phraseCategory = "GAN Name Status";
break;
case "s": phraseCategory = "SAN Name Status";
break;
}
}
}
txtNameStatus.BindUser(PluginManager.Instance.User, PickListType.Phrase, phraseCategory, TraitCategoryType.Taxon);
}
else
{
txtNameStatus.Visibility = System.Windows.Visibility.Collapsed;
lblNameStatus.Visibility = System.Windows.Visibility.Collapsed;
}
this.DataContext = _model;
this.ChangesCommitted += new PendingChangesCommittedHandler(TaxonNameDetails_ChangesCommitted);
}
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);
}
public static TaxonRank GetChildRank(this TaxonRank rank)
{
switch (rank)
{
case TaxonRank.Kingdom:
return(TaxonRank.Subkingdom);
case TaxonRank.Subkingdom:
return(TaxonRank.Infrakingdom);
case TaxonRank.Infrakingdom:
return(TaxonRank.Phylum);
case TaxonRank.Phylum:
return(TaxonRank.Subphylum);
case TaxonRank.Subphylum:
return(TaxonRank.Class);
case TaxonRank.Class:
return(TaxonRank.Subclass);
case TaxonRank.Subclass:
return(TaxonRank.Superorder);
case TaxonRank.Superorder:
return(TaxonRank.Order);
case TaxonRank.Order:
return(TaxonRank.Suborder);
case TaxonRank.Suborder:
return(TaxonRank.Family);
case TaxonRank.Family:
return(TaxonRank.Subfamily);
case TaxonRank.Subfamily:
return(TaxonRank.Genus);
case TaxonRank.Genus:
return(TaxonRank.Species);
case TaxonRank.Species:
return(TaxonRank.Subspecies);
default:
return(TaxonRank.Root);
}
}
public static string GetTaxonName(this Models.Taxon taxon, TaxonRank rank)
{
switch (rank)
{
case TaxonRank.Kingdom:
return(taxon.Kingdom);
case TaxonRank.Subkingdom:
return(taxon.Subkingdom ?? "None");
case TaxonRank.Infrakingdom:
return(taxon.Infrakingdom ?? "None");
case TaxonRank.Phylum:
return(taxon.Phylum ?? "None");
case TaxonRank.Subphylum:
return(taxon.Subphylum ?? "None");
case TaxonRank.Class:
return(taxon.Class ?? "None");
case TaxonRank.Subclass:
return(taxon.Subclass ?? "None");
case TaxonRank.Superorder:
return(taxon.Superorder ?? "None");
case TaxonRank.Order:
return(taxon.Order ?? "None");
case TaxonRank.Suborder:
return(taxon.Suborder ?? "None");
case TaxonRank.Family:
return(taxon.Family ?? "None");
case TaxonRank.Subfamily:
return(taxon.Subfamily ?? "None");
case TaxonRank.Genus:
return(taxon.Genus ?? "None");
case TaxonRank.Species:
return(taxon.SpeciesName ?? "None");
default:
return("None");
}
}
public static string GetTaxonValue(this Models.Taxon taxon, TaxonRank rank)
{
switch (rank)
{
case TaxonRank.Kingdom:
return(taxon.Kingdom);
case TaxonRank.Subkingdom:
return(taxon.Subkingdom);
case TaxonRank.Infrakingdom:
return(taxon.Infrakingdom);
case TaxonRank.Phylum:
return(taxon.Phylum);
case TaxonRank.Subphylum:
return(taxon.Subphylum);
case TaxonRank.Class:
return(taxon.Class);
case TaxonRank.Subclass:
return(taxon.Subclass);
case TaxonRank.Superorder:
return(taxon.Superorder);
case TaxonRank.Order:
return(taxon.Order);
case TaxonRank.Suborder:
return(taxon.Suborder);
case TaxonRank.Family:
return(taxon.Family);
case TaxonRank.Subfamily:
return(taxon.Subfamily);
case TaxonRank.Genus:
return(taxon.Genus);
case TaxonRank.Species:
return(taxon.Species);
default:
return(null);
}
}
public async Task NavigateAsync(TaxonRank rank)
{
// we click on class we should get subclass
// currently getting class
var crumb = Breadcrumbs[rank];
Breadcrumbs = Breadcrumbs.Where(b => b.Key <= rank).ToDictionary(b => b.Key, b => b.Value);
Shape = crumb.Copy();
Rank = rank.GetChildRank();
foreach (var breadcrumb in Breadcrumbs)
{
Console.WriteLine(breadcrumb.GetHashCode());
}
Console.WriteLine(Shape.GetHashCode());
await SearchAsync();
}
public DataValidationResult ValidateTaxonMove(Taxon source, Taxon dest)
{
var map = GetTaxonRankMap();
// Can only really validate if the ranks of the source and target are 'known'
if (map.ContainsKey(RankKey(dest)) && map.ContainsKey(RankKey(source)))
{
TaxonRank destrank = map[RankKey(dest)];
TaxonRank srcrank = map[RankKey(source)];
if (!IsValidChild(srcrank, destrank))
{
return(new DataValidationResult(false, String.Format("{0} is not a valid child of {1}", srcrank.LongName, destrank.LongName)));
}
}
return(new DataValidationResult(true));
}
public TaxonRank ShowChooseConversion(TaxonRank sourceRank, List <TaxonRank> choices)
{
// Prepare the form...
grid.RowDefinitions[0].Height = Zero;
grid.RowDefinitions[1].Height = Forty;
grid.RowDefinitions[2].Height = Forty;
optConvert.Content = _owner.GetCaption("DragDropOptions.lblConvert", sourceRank.LongName);
optConvert.IsChecked = true;
cmbRanks.ItemsSource = choices;
cmbRanks.SelectedIndex = 0;
if (ShowDialog().GetValueOrDefault(false))
{
return(cmbRanks.SelectedItem as TaxonRank);
}
return(null);
}
protected override async Task OnInitializedAsync()
{
CurrentPage = 1;
Take = 10;
Rank = TaxonRank.Subkingdom;
Shape = new Taxon {
Kingdom = "Plantae"
};
Breadcrumbs = new Dictionary <TaxonRank, Taxon>
{
{
TaxonRank.Kingdom,
Shape.Copy()
}
};
ShowSearch = false;
await base.OnInitializedAsync();
}
public static async Task <Taxon[]> GetTaxaAsync(string name, TaxonRank rank)
{
List <Taxon> taxa = new List <Taxon>();
string table_name = _getRankTableName(rank);
if (string.IsNullOrEmpty(table_name))
{
return(null);
}
using (SQLiteCommand cmd = new SQLiteCommand(string.Format("SELECT * FROM {0} WHERE name = $name OR common_name = $name", table_name))) {
cmd.Parameters.AddWithValue("$name", name.ToLower());
using (DataTable table = await Database.GetRowsAsync(cmd))
foreach (DataRow row in table.Rows)
{
taxa.Add(Taxon.FromDataRow(row, rank));
}
}
return(taxa.ToArray());
}
public List <TaxonRank> GetChildRanks(TaxonRank targetRank)
{
var map = GetTaxonRankMap();
string[] valid = targetRank.ValidChildList.Split(',');
List <TaxonRank> result = new List <TaxonRank>();
foreach (string child in valid)
{
string elemType = child;
if (child.StartsWith("'") && child.EndsWith("'"))
{
elemType = child.Substring(1, child.Length - 2);
}
string key = RankKey(targetRank.KingdomCode, elemType);
if (map.ContainsKey(key))
{
result.Add(map[key]);
}
}
return(result);
}
public bool Contains(string name, TaxonRank type)
{
if (string.IsNullOrEmpty(name))
{
return(false);
}
name = name.Trim().ToLower();
switch (type)
{
case TaxonRank.Species:
return(Species != null && Species.name.ToLower() == name);
case TaxonRank.Genus:
return(Genus != null && Genus.name.ToLower() == name);
case TaxonRank.Family:
return(Family != null && Family.name.ToLower() == name);
case TaxonRank.Order:
return(Order != null && Order.name.ToLower() == name);
case TaxonRank.Class:
return(Class != null && Class.name.ToLower() == name);
case TaxonRank.Phylum:
return(Phylum != null && Phylum.name.ToLower() == name);
case TaxonRank.Kingdom:
return(Kingdom != null && Kingdom.name.ToLower() == name);
case TaxonRank.Domain:
return(Domain != null && Domain.name.ToLower() == name);
}
return(false);
}
private SelectList getAllNodeNames(TaxonRank rank)
{
List <SelectListItem> list = new List <SelectListItem>();
if (rank != TaxonRank.Class)
{
TaxonRank nextRank = Enum.GetValues(typeof(TaxonRank)).Cast <TaxonRank>()
.SkipWhile(e => e != rank).Skip(1).First();
SubjectManager subjectManager = new SubjectManager();
var nodes = subjectManager.GetAll <Node>().Where(n => n.Rank.Equals(nextRank));
nodes.OrderBy(n => n.Name).ToList().ForEach(n => list.Add(new SelectListItem()
{
Text = n.Name, Value = n.Id.ToString()
}));
return(new SelectList(list, "Value", "Text"));
}
return(new SelectList(list, "Value", "Text"));
}
public static Taxon FromDataRow(DataRow row, TaxonRank type)
{
Taxon taxon = new Taxon(type)
{
id = row.Field <long>("id"),
name = row.Field <string>("name"),
CommonName = row.Field <string>("common_name"),
description = row.Field <string>("description"),
pics = row.Field <string>("pics")
};
string parent_id_name = TypeToDatabaseColumnName(taxon.GetParentType());
if (!string.IsNullOrEmpty(parent_id_name))
{
taxon.parent_id = (row[parent_id_name] == DBNull.Value) ? 0 : row.Field <long>(parent_id_name);
}
else
{
taxon.parent_id = -1;
}
return(taxon);
}
public async Task <IEnumerable <Data.Shared.Models.Synonym> > GetSynonymsByParentAsync(TaxonRank rank, string taxonName)
{
var childRank = rank.GetChildRank();
var synonymQuery = _synonymRepository.WhereWithIncludes(s => s.Rank == childRank.ToString() &&
((rank == TaxonRank.Kingdom && s.Taxon.Kingdom == taxonName) ||
(rank == TaxonRank.Subkingdom && s.Taxon.Subkingdom == taxonName) ||
(rank == TaxonRank.Infrakingdom && s.Taxon.Infrakingdom == taxonName) ||
(rank == TaxonRank.Phylum && s.Taxon.Phylum == taxonName) ||
(rank == TaxonRank.Subphylum && s.Taxon.Subphylum == taxonName) ||
(rank == TaxonRank.Class && s.Taxon.Class == taxonName) ||
(rank == TaxonRank.Subclass && s.Taxon.Subclass == taxonName) ||
(rank == TaxonRank.Superorder && s.Taxon.Superorder == taxonName) ||
(rank == TaxonRank.Order && s.Taxon.Order == taxonName) ||
(rank == TaxonRank.Suborder && s.Taxon.Suborder == taxonName) ||
(rank == TaxonRank.Family && s.Taxon.Family == taxonName) ||
(rank == TaxonRank.Subfamily && s.Taxon.Subfamily == taxonName) ||
(rank == TaxonRank.Genus && s.Taxon.Genus == taxonName) ||
(rank == TaxonRank.Species && s.Taxon.Species == taxonName) ||
(rank == TaxonRank.Subspecies && s.Taxon.Subspecies == taxonName) ||
(rank == TaxonRank.Variety && s.Taxon.Subvariety == taxonName) ||
(rank == TaxonRank.Subkingdom && s.Taxon.Subkingdom == taxonName)),
false,
s => s.Include(s => s.Taxon));
var synonymResult = synonymQuery.GetSomeAsync();
var synonyms = new List <Data.Shared.Models.Synonym>();
await foreach (var synonym in synonymResult)
{
synonyms.Add(synonym.AsModel());
}
return(synonyms);
}
internal DragDropAction ShowChooseMergeOrConvert(TaxonDropContext context)
{
optMerge.Content = _owner.GetCaption("DragDropOptions.lblMerge", context.Source.Epithet, context.Target.Epithet);
List <TaxonRank> conversionOptions = new List <TaxonRank>();
if (context.TargetChildRank == null)
{
conversionOptions.AddRange(context.TaxaPlugin.Service.GetChildRanks(context.TargetRank));
}
else
{
conversionOptions.Add(context.TargetChildRank);
}
// Prepare the form depending on how many conversion options there all
if (conversionOptions.Count == 0)
{
// No conversion options - only show the merge option
grid.RowDefinitions[0].Height = new GridLength(80);
grid.RowDefinitions[1].Height = Zero;
grid.RowDefinitions[2].Height = Zero;
}
else if (conversionOptions.Count == 1)
{
var targetRank = conversionOptions[0];
grid.RowDefinitions[0].Height = new GridLength(80);
grid.RowDefinitions[1].Height = Forty;
grid.RowDefinitions[2].Height = Zero;
optConvert.Content = _owner.GetCaption("DragDropOptions.lblConvertAsChild", targetRank.LongName, context.Target.Epithet);
}
else
{
cmbRanks.ItemsSource = conversionOptions;
cmbRanks.SelectedIndex = 0;
grid.RowDefinitions[0].Height = new GridLength(80);
grid.RowDefinitions[1].Height = Forty;
grid.RowDefinitions[2].Height = Forty;
optConvert.Content = _owner.GetCaption("DragDropOptions.lblConvert", context.SourceRank.LongName);
}
DragDropAction result = null;
PrepareAutoSynonymy(context);
optMerge.IsChecked = true;
if (ShowDialog().GetValueOrDefault(false))
{
if (optMerge.IsChecked.GetValueOrDefault(false))
{
result = new MergeDropAction(context, chkCreateIDRecord.IsChecked.GetValueOrDefault(false));
if (chkCreateAvailable.IsChecked.HasValue && chkCreateAvailable.IsChecked.Value)
{
var availableName = _owner.TaxonExplorer.AddAvailableName(context.Target, false, false);
availableName.Epithet = context.Source.Epithet;
availableName.Author = context.Source.Author;
availableName.YearOfPub = context.Source.YearOfPub;
availableName.ChgComb = context.Source.ChgComb;
}
}
else
{
TaxonRank convertToRank = null;
if (conversionOptions.Count == 1)
{
convertToRank = conversionOptions[0];
}
else
{
convertToRank = cmbRanks.SelectedItem as TaxonRank;
}
result = new ConvertingMoveDropAction(context, convertToRank);
}
}
return(result);
}
public async Task <FindResult <Taxon> > FindTaxonsAsync(FindParams <Taxon> findParams, TaxonRank rank)
{
var result = await _httpClient.PostAsJsonAsync($"/api/taxon/find?rank={rank}", findParams);
return(await ReadResult <FindResult <Taxon> >(result));
}
private MenuItem BuildAddMenuItems()
{
MenuItem addMenu = _builder.New("TaxonExplorer.menu.Add").MenuItem;
if (Taxon.AvailableName.GetValueOrDefault(false) || Taxon.LiteratureName.GetValueOrDefault(false))
{
return(null);
}
if (Taxon.TaxaParentID == -1)
{
TaxonRank rank = Explorer.Service.GetRankByOrder(1);
if (rank != null)
{
addMenu.Items.Add(_builder.New(rank.LongName).Handler(() => { Explorer.AddNewTaxon(Taxon, rank); }).MenuItem);
addMenu.Items.Add(_builder.New("TaxonExplorer.menu.Add.AllRanks").Handler(() => { Explorer.AddNewTaxonAllRanks(Taxon); }).MenuItem);
}
}
else
{
switch (Taxon.ElemType)
{
case "":
addMenu.Items.Add(_builder.New("Unranked Valid").Handler(() => { Explorer.AddUnrankedValid(Taxon); }).MenuItem);
break;
case TaxonRank.INCERTAE_SEDIS:
case TaxonRank.SPECIES_INQUIRENDA:
AddSpecialNameMenuItems(addMenu, true, false, false, false);
break;
default:
TaxonRank rank = Explorer.Service.GetTaxonRank(Taxon.Taxon);
if (rank != null)
{
List <TaxonRank> validChildRanks = Explorer.Service.GetChildRanks(rank);
if (validChildRanks != null && validChildRanks.Count > 0)
{
foreach (TaxonRank childRank in validChildRanks)
{
// The for loop variable is outside of the scope of the closure, so we need to create a local...
TaxonRank closureRank = Explorer.Service.GetTaxonRank(childRank.Code, Taxon.KingdomCode);
addMenu.Items.Add(_builder.New(childRank.LongName).Handler(() => {
Explorer.AddNewTaxon(Taxon, closureRank);
}).MenuItem);
}
addMenu.Items.Add(new Separator());
}
addMenu.Items.Add(_builder.New("Unranked Valid").Handler(() => { Explorer.AddUnrankedValid(Taxon); }).MenuItem);
addMenu.Items.Add(new Separator());
AddSpecialNameMenuItems(addMenu, rank.AvailableNameAllowed, rank.LituratueNameAllowed, rank.AvailableNameAllowed, rank.AvailableNameAllowed);
addMenu.Items.Add(new Separator());
foreach (TaxonRank childRank in validChildRanks)
{
// The for loop variable is outside of the scope of the closure, so we need to create a local...
TaxonRank closureRank = Explorer.Service.GetTaxonRank(childRank.Code, Taxon.KingdomCode);
if (childRank.UnplacedAllowed.ValueOrFalse())
{
addMenu.Items.Add(_builder.New("Unplaced " + childRank.LongName).Handler(() => { Explorer.AddNewTaxon(Taxon, closureRank, true); }).MenuItem);
}
}
}
break;
}
}
return(addMenu);
}
public async Task SearchAsync(TaxonRank rank, string name)
{
if (Shape != null && !Breadcrumbs.ContainsKey(rank))
{
Breadcrumbs.Add(Rank, Shape.Copy());
}
switch (rank)
{
case TaxonRank.Kingdom:
Shape.Kingdom = name;
break;
case TaxonRank.Subkingdom:
Shape.Subkingdom = name;
break;
case TaxonRank.Infrakingdom:
Shape.Infrakingdom = name;
break;
case TaxonRank.Phylum:
Shape.Phylum = name;
break;
case TaxonRank.Subphylum:
Shape.Subphylum = name;
break;
case TaxonRank.Class:
Shape.Class = name;
break;
case TaxonRank.Subclass:
Shape.Subclass = name;
break;
case TaxonRank.Superorder:
Shape.Superorder = name;
break;
case TaxonRank.Order:
Shape.Order = name;
break;
case TaxonRank.Suborder:
Shape.Suborder = name;
break;
case TaxonRank.Family:
Shape.Family = name;
break;
case TaxonRank.Subfamily:
Shape.Subfamily = name;
break;
case TaxonRank.Genus:
Shape.Genus = name;
break;
case TaxonRank.Species:
Shape.Species = name;
break;
}
Rank = rank.GetChildRank();
Breadcrumbs[rank] = Shape.Copy();
await SearchAsync();
}
private string RankKey(TaxonRank rank)
{
return(RankKey(rank.KingdomCode, rank.Code));
}
public Taxon(TaxonRank type)
{
id = -1;
parent_id = -1;
this.type = type;
}
public TaxonNameViewModel(Taxon taxon, Kingdom kingdom, TaxonRank rank) : base(null, taxon, null)
{
_kingdom = kingdom;
_rank = rank;
}
