/// <summary> /// Text in taxon title. /// </summary> /// <param name="taxonTitle">The taxon title.</param> /// <param name="textToFind">Text to locate.</param> /// <param name="type">Compare type.</param> /// <param name="compareType">Type of the compare.</param> /// <returns> /// true if it succeeds, false if it fails. /// </returns> private static bool TextInTaxonTitle(string taxonTitle, string textToFind, HierarchicalTaxonCompareType type, StringComparison compareType) { switch (type) { case HierarchicalTaxonCompareType.StartsWith: return(taxonTitle.StartsWith(textToFind, compareType)); case HierarchicalTaxonCompareType.EndsWith: return(taxonTitle.EndsWith(textToFind, compareType)); case HierarchicalTaxonCompareType.Contains: return(taxonTitle.Contains(textToFind)); case HierarchicalTaxonCompareType.Equals: return(taxonTitle.Equals(textToFind, compareType)); default: return(false); } }
/// <summary> /// Searches from Parent to parent to match the taxon name you need, returns the first match /// ** Sitefinitysteve.com Extension **. /// </summary> /// <param name="currentTaxon">Current Node.</param> /// <param name="textToFind">Text to locate.</param> /// <param name="type">Compare type.</param> /// <param name="isCaseSensitive">Case Sensitive check, doesn't apply to Contains.</param> /// <returns> /// Null if nothing found. /// </returns> public static HierarchicalTaxon GetFirstParentTaxon(this HierarchicalTaxon currentTaxon, string textToFind, HierarchicalTaxonCompareType type, bool isCaseSensitive) { StringComparison compareType = (isCaseSensitive) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; while (currentTaxon != null) { if (TextInTaxonTitle(currentTaxon.Title, textToFind, type, compareType)) { return(currentTaxon); } currentTaxon = currentTaxon.Parent; } return(null); }
/// <summary> /// Searches from Parent to parent to match the taxon name you need, returns the first match /// ** Sitefinitysteve.com Extension ** /// </summary> /// <param name="currentTaxon">Current Node</param> /// <param name="textToFind">Text to locate</param> /// <param name="type">Compare type</param> /// <param name="isCaseSensitive">Case Sensitive check, doesn't apply to Contains</param> /// <returns>Null if nothing found</returns> public static HierarchicalTaxon GetFirstParentTaxon(this HierarchicalTaxon currentTaxon, string textToFind, HierarchicalTaxonCompareType type, bool isCaseSensitive) { bool found = false; HierarchicalTaxon foundTaxon = null; var compareType = (isCaseSensitive) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; //Check this one, TODO: consolidate this and the one below if (type == HierarchicalTaxonCompareType.StartsWith) { found = currentTaxon.Title.StartsWith(textToFind, compareType); } else if (type == HierarchicalTaxonCompareType.EndsWith) { found = currentTaxon.Title.EndsWith(textToFind, compareType); } else if (type == HierarchicalTaxonCompareType.Equals) { found = currentTaxon.Title.Equals(textToFind, compareType); } else if (type == HierarchicalTaxonCompareType.Contains) { found = currentTaxon.Title.Contains(textToFind); } if (found) { return(currentTaxon); } if (currentTaxon.Parent != null) { while (currentTaxon != null) { switch (type) { case HierarchicalTaxonCompareType.StartsWith: found = currentTaxon.Title.StartsWith(textToFind, compareType); break; case HierarchicalTaxonCompareType.EndsWith: found = currentTaxon.Title.EndsWith(textToFind, compareType); break; case HierarchicalTaxonCompareType.Contains: found = currentTaxon.Title.Contains(textToFind); break; case HierarchicalTaxonCompareType.Equals: found = currentTaxon.Title.Equals(textToFind, compareType); break; } if (found) { foundTaxon = currentTaxon; break; } else { currentTaxon = currentTaxon.Parent; } } } return(foundTaxon); }