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