/// <summary> /// Gets a specific ESD metadata term /// </summary> /// <param name="termId">The id of the term to get</param> /// <param name="preferredState">Specify whether the term must be preferred or non-preferred (for SKOS-compatible XML after published after June 2010, only preferred is relevant)</param> /// <returns>The relevant term, or null if not found</returns> public EsdTerm GetTerm(string termId, EsdPreferredState preferredState) { string xPath = String.Empty; switch (preferredState) { case EsdPreferredState.Preferred: xPath = this.skosCompatible ? "ns:Item[@Id=\"{0}\"]" : "ns:Item[@Preferred='true' and @Id=\"{0}\"]"; break; case EsdPreferredState.NonPreferred: if (this.skosCompatible) { return(null); // non-preferred terms no longer have their own id } xPath = "ns:Item[@Preferred='false' and @Id=\"{0}\"]"; break; case EsdPreferredState.Any: // for SKOS-compatible this effectively is the same as EsdPreferredState.Preferred xPath = "ns:Item[@Id=\"{0}\"]"; break; } xPath = String.Format(CultureInfo.InvariantCulture, xPath, termId.Trim()); XPathNodeIterator it = this.SelectNodes(xPath); if (it.Count != 1) { return(null); } it.MoveNext(); return(this.GetEsdTermFromXml(it.Current)); }
/// <summary> /// Gets ESD metadata terms based on the name of the term /// </summary> /// <param name="termName">The term name to search for</param> /// <param name="exactMatch">true to match the whole name of a term; false to match any part of the term</param> /// <param name="preferredState">Specify whether the term must be preferred or non-preferred</param> /// <returns>A collection of matching terms</returns> /// <remarks>Matching is not case-sensitive. For SKOS-compatible lists (those published after June 2010) the behaviour /// of this method has changed. When a search matches a non-preferred term it used to return the non-preferred term /// as a top-level object alongside preferred terms. For SKOS compatible lists it now returns the preferred term which /// goes with the non-preferred term.</remarks> public EsdTermCollection GetTerms(string termName, bool exactMatch, EsdPreferredState preferredState) { // double-quotes (") are used to delimit xpath strings in this method because it allows apostrophes in the string string xPath = null; if (exactMatch) { switch (preferredState) { case EsdPreferredState.Preferred: xPath = this.skosCompatible ? "ns:Item[ns:Name[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]" : "ns:Item[@Preferred='true' and ns:Name[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]"; break; case EsdPreferredState.NonPreferred: xPath = this.skosCompatible ? "ns:Item[ns:AlternativeName[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]" : "ns:Item[@Preferred='false' and ns:Name[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]"; break; case EsdPreferredState.Any: xPath = this.skosCompatible ? "ns:Item[ns:Name[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"] or ns:AlternativeName[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]" : "ns:Item[ns:Name[translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')=\"{0}\"]]"; break; } } else { switch (preferredState) { case EsdPreferredState.Preferred: xPath = this.skosCompatible ? "ns:Item[ns:Name[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]" : "ns:Item[@Preferred='true' and ns:Name[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]"; break; case EsdPreferredState.NonPreferred: xPath = this.skosCompatible ? "ns:Item[ns:AlternativeName[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]" : "ns:Item[@Preferred='false' and ns:Name[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]"; break; case EsdPreferredState.Any: xPath = this.skosCompatible ? "ns:Item[ns:Name[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")] or ns:AlternativeName[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]" : "ns:Item[ns:Name[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), \"{0}\")]]"; break; } } XPathNodeIterator it = this.SelectNodes(String.Format(CultureInfo.InvariantCulture, xPath, termName.Trim().ToLower(CultureInfo.CurrentCulture))); EsdTermCollection terms = new EsdTermCollection(); while (it.MoveNext()) { terms.Add(this.GetEsdTermFromXml(it.Current)); } terms.Sort(); return(terms); }
/// <summary> /// Gets the numeric index of a term's position in the collection /// </summary> /// <param name="termName">Name of the term.</param> /// <param name="state">The state.</param> /// <returns></returns> public int IndexOf(string termName, EsdPreferredState state) { foreach (EsdTerm term in this) { if (term.Text.ToLowerInvariant() == termName.ToLowerInvariant() && (state == EsdPreferredState.Any || ((state == EsdPreferredState.Preferred) == term.Preferred))) { return(IndexOf(term)); } } return(-1); }
/// <summary> /// Gets the numeric index of a term's position in the collection /// </summary> /// <param name="termId">The term id.</param> /// <param name="state">The state.</param> /// <returns></returns> public int IndexOfId(string termId, EsdPreferredState state) { foreach (EsdTerm term in this) { if (term.Id == termId && (state == EsdPreferredState.Any || ((state == EsdPreferredState.Preferred) == term.Preferred))) { return(IndexOf(term)); } } return(-1); }
/// <summary> /// Checks the terms in the control against the specified controlled list /// </summary> /// <returns>true if all terms are valid; false if any one term is not valid (matching is not case sensitive)</returns> protected override bool EvaluateIsValid() { // If an instance of this validator is run more than once on one request, just return the same result and don't do all the work again. // Not that anyone would run it more than once on one request, unless it was really inefficient (SharePoint field controls). if (cachedIsValid != null) { return((bool)cachedIsValid); } // check the list was specified if (this.controlledListName == null || this.controlledListName.Length == 0) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "The ControlledListName property was not set for {0}", this.GetType().ToString())); } // get control to validate and get its value Control controlToValidate = this.Parent.FindControl(this.ControlToValidate); string valueToValidate = String.Empty; // If it's a textbox ensure it's in a variable we can use later to put a tidied-up value back into the textbox TextBox textboxToValidate = controlToValidate as TextBox; if (textboxToValidate != null) { // Trim off any trailing semi-colon separator valueToValidate = textboxToValidate.Text.TrimEnd(' ', ';'); } else { // Maybe it's a list of some kind? Test with cast rather than .GetType() == typeof(ListControl) // because need to support customised derived types of control. ListControl listToValidate = controlToValidate as ListControl; if (listToValidate != null) { EsdTermCollection selectedTerms = new EsdTermCollection(); foreach (ListItem item in listToValidate.Items) { if (item.Selected) { EsdTerm selectedTerm = new EsdTerm(); selectedTerm.Id = item.Value; selectedTerm.Text = item.Text; selectedTerms.Add(selectedTerm); } } valueToValidate = selectedTerms.ToString(); } else { // No other control type supported yet - throw a useful error for the developer throw new ArgumentException(String.Format("The control type matched by the ControlToValidate property, {0}, is not supported by the EsdTermValidator", controlToValidate.GetType().ToString())); } } // this isn't a required validator if (valueToValidate.Length == 0) { this.cachedIsValid = true; return(true); } // get the XML we need EsdControlledList esdListXml = EsdControlledList.GetControlledList(this.controlledListName, false); // box has semi-colon separated list of preferred terms string[] searchTerms; if (this.multipleTerms) { valueToValidate = valueToValidate.Trim(' ', ';'); searchTerms = valueToValidate.Split(';'); } else { searchTerms = new string[1]; searchTerms[0] = valueToValidate.Trim(); } // If we only want preferred terms, search for any term then we can convert it to the preferred term EsdPreferredState searchState = (this.preferredState == EsdPreferredState.Preferred ? EsdPreferredState.Any : this.preferredState); // Search for terms and gather results StringBuilder termBuilder = new StringBuilder(); this.invalidTerms = new ArrayList(); this.matchedTerms.Clear(); List <string> matchedTermIds = new List <string>(); int totalMatchedTerms = 0; string trimmedSearch; Regex numeric = new Regex("^[0-9]+$"); foreach (string searchTerm in searchTerms) { trimmedSearch = searchTerm.Trim(); if (trimmedSearch.Length == 0) { continue; } if (this.termIdsAllowed && numeric.IsMatch(trimmedSearch)) { if (this.allowedTerms.Count > 0) { // Validate the text of the term against just those terms in the AllowedTerms collection int termIndex = this.allowedTerms.IndexOfId(trimmedSearch, this.preferredState); // If that didn't work and we want preferred terms, see if it matches a non-preferred term and the preferred term is allowed if (this.preferredState == EsdPreferredState.Preferred && termIndex == -1) { EsdTerm matchedTerm = esdListXml.GetTerm(trimmedSearch, EsdPreferredState.NonPreferred); if (matchedTerm != null) { matchedTerm = esdListXml.GetPreferredTerm(matchedTerm.ConceptId); if (matchedTerm != null) { termIndex = this.allowedTerms.IndexOf(matchedTerm.Text, EsdPreferredState.Preferred); } } } if (termIndex > -1) { EsdTerm matchedTerm = this.allowedTerms[termIndex]; totalMatchedTerms++; // Add it unless it's a duplicate if (!matchedTermIds.Contains(matchedTerm.Id)) { this.matchedTerms.Add(matchedTerm); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(matchedTerm.Id); matchedTermIds.Add(matchedTerm.Id); } } else { this.invalidTerms.Add(trimmedSearch); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(trimmedSearch); } } else { EsdTerm matchedTerm = esdListXml.GetTerm(trimmedSearch, searchState); if (matchedTerm != null) { totalMatchedTerms++; // If we want preferred terms, ensure we have the preferred term if (this.preferredState == EsdPreferredState.Preferred && !matchedTerm.Preferred) { matchedTerm = esdListXml.GetPreferredTerm(matchedTerm.ConceptId); } // Add it unless it's a duplicate if (!matchedTermIds.Contains(matchedTerm.Id)) { this.matchedTerms.Add(matchedTerm); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(matchedTerm.Id); matchedTermIds.Add(matchedTerm.Id); } } else { this.invalidTerms.Add(trimmedSearch); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(trimmedSearch); } } } else { if (this.allowedTerms.Count > 0) { // Validate the text of the term against just those terms in the AllowedTerms collection int termIndex = this.allowedTerms.IndexOf(trimmedSearch, this.preferredState); // If that didn't work and we want preferred terms, see if it matches a non-preferred term and the preferred term is allowed if (this.preferredState == EsdPreferredState.Preferred && termIndex == -1) { EsdTermCollection matchedTerms = esdListXml.GetTerms(trimmedSearch, true, EsdPreferredState.NonPreferred); if (matchedTerms.Count == 1) { EsdTerm matchedTerm = esdListXml.GetPreferredTerm(matchedTerms[0].ConceptId); if (matchedTerm != null) { termIndex = this.allowedTerms.IndexOf(matchedTerm.Text, EsdPreferredState.Preferred); } } } if (termIndex > -1) { EsdTerm matchedTerm = this.allowedTerms[termIndex]; totalMatchedTerms++; // Add it unless it's a duplicate if (!matchedTermIds.Contains(matchedTerm.Id)) { this.matchedTerms.Add(matchedTerm); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(matchedTerm.Text); matchedTermIds.Add(matchedTerm.Id); } } else { this.invalidTerms.Add(trimmedSearch); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(trimmedSearch); } } else { // Validate the text of the term against the full controlled list EsdTermCollection terms = esdListXml.GetTerms(trimmedSearch, true, searchState); if (terms.Count == 1) { totalMatchedTerms++; // If we want preferred terms, ensure we have the preferred term EsdTerm matchedTerm = terms[0]; if (this.preferredState == EsdPreferredState.Preferred && !matchedTerm.Preferred) { matchedTerm = esdListXml.GetPreferredTerm(matchedTerm.ConceptId); } // Add it unless it's a duplicate if (!matchedTermIds.Contains(matchedTerm.Id)) { this.matchedTerms.Add(matchedTerm); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(matchedTerm.Text); matchedTermIds.Add(matchedTerm.Id); } } else { this.invalidTerms.Add(trimmedSearch); if (termBuilder.Length > 0) { termBuilder.Append("; "); } termBuilder.Append(trimmedSearch); } } } } // if control had user-editable (rather than selectable) values, update control with case-corrected terms if (textboxToValidate != null) { textboxToValidate.Text = termBuilder.ToString(); } // return true if terms valid; false if any one term is not valid // totalMatchedTerms may not be the same as this.MatchedTerms.Count because totalMatchedTerms is incremented for a duplicate if (totalMatchedTerms == searchTerms.Length) { this.cachedIsValid = true; return(true); // all terms were matched } else { StringBuilder errorBuilder = new StringBuilder(); string listName = esdListXml.AbbreviatedName; string termDelimiter = "'"; // build error message with singular grammar if (this.invalidTerms.Count == 1) { if (this.allowedTerms.Count > 0) { errorBuilder.Append(termDelimiter).Append(this.invalidTerms[0]).Append(termDelimiter).Append(" is not one of the ").Append(listName).Append(" terms allowed here"); } else { errorBuilder.Append(termDelimiter).Append(this.invalidTerms[0]).Append(termDelimiter).Append(" is not a"); if (listName.StartsWith("A") || listName.StartsWith("E") || listName.StartsWith("I") || listName.StartsWith("O") || listName.StartsWith("U")) { errorBuilder.Append("n"); } errorBuilder.Append(" ").Append(listName).Append(" "); if (this.preferredState == EsdPreferredState.Preferred) { errorBuilder.Append("preferred"); } else if (this.preferredState == EsdPreferredState.NonPreferred) { errorBuilder.Append("non-preferred"); } errorBuilder.Append(" term"); } } else { // build error message with plural grammar for (short i = 0; i < this.invalidTerms.Count; i++) { if (errorBuilder.Length > 0) { if (i == (this.invalidTerms.Count - 1)) { errorBuilder.Append(" and "); } else { errorBuilder.Append(", "); } } errorBuilder.Append(termDelimiter).Append(this.invalidTerms[i]).Append(termDelimiter); } if (this.allowedTerms.Count > 0) { errorBuilder.Append(" are not among the ").Append(listName).Append(" terms allowed here"); } else { errorBuilder.Append(" are not ").Append(listName).Append(" "); if (this.preferredState == EsdPreferredState.Preferred) { errorBuilder.Append("preferred"); } else if (this.preferredState == EsdPreferredState.NonPreferred) { errorBuilder.Append("non-preferred"); } errorBuilder.Append(" terms"); } } this.ErrorMessage = errorBuilder.ToString(); this.cachedIsValid = false; return(false); } }