/// <summary>
/// Gets the XML for an ESD controlled list or mapping, cacheing it if possible
/// </summary>
/// <param name="configKey">Key for XML file name <Escc.Web.Metadata/ControlledListXml> section of web.config</param>
/// <param name="withDom">true to include DOM and XPath support; false for XPath only</param>
/// <returns>Populated XML document, or null if not found</returns>
public static EsdXmlDocument GetEsdDocument(string configKey, bool withDom)
{
// TODO: Ideally this would check the format of the file to decide, but as a quick fix
// just check whether the key includes the word "mapping"
NameValueCollection config = ConfigurationManager.GetSection("Escc.Web.Metadata/ControlledListXml") as NameValueCollection;
if (config == null)
{
config = ConfigurationManager.GetSection("EsccWebTeam.Egms/ControlledListXml") as NameValueCollection;
}
if (config == null)
{
config = ConfigurationManager.GetSection("egmsXml") as NameValueCollection;
}
if (config != null)
{
if (configKey.ToLower(CultureInfo.CurrentCulture).IndexOf("mapping") > -1)
{
return(EsdMapping.GetMapping(configKey, withDom));
}
else
{
return(EsdControlledList.GetControlledList(configKey, withDom));
}
}
else
{
return(null);
}
}
/// <summary>
/// Gets the XML for an ESD controlled list, cacheing it if possible
/// </summary>
/// <param name="configKey">Key for XML file name <Escc.Web.Metadata/ControlledListXml> section of web.config</param>
/// <param name="withDom">true to include DOM and XPath support; false for XPath only</param>
/// <returns>Populated XML document, or null if not found</returns>
public static EsdControlledList GetControlledList(string configKey, bool withDom)
{
HttpContext ctx = HttpContext.Current;
EsdControlledList xmlDoc = null;
string cacheKey = String.Format(CultureInfo.InvariantCulture, "EsdXml_{0}", configKey);
// Check for the document in the Application Data Cache
if (ctx != null)
{
xmlDoc = (EsdControlledList)ctx.Cache.Get(cacheKey);
}
// Not in cache, so load XML
if (xmlDoc == null)
{
NameValueCollection config = ConfigurationManager.GetSection("Escc.Web.Metadata/ControlledListXml") as NameValueCollection;
if (config == null)
{
config = ConfigurationManager.GetSection("EsccWebTeam.Egms/ControlledListXml") as NameValueCollection;
}
if (config == null)
{
config = ConfigurationManager.GetSection("egmsXml") as NameValueCollection;
}
if (config != null)
{
if (String.IsNullOrEmpty(config[configKey]))
{
throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, Resources.ErrorConfigListNotFound, configKey));
}
xmlDoc = new EsdControlledList();
if (withDom)
{
xmlDoc.LoadDom(config[configKey]);
}
else
{
xmlDoc.LoadXPath(config[configKey]);
}
}
else
{
throw new ConfigurationErrorsException(Resources.ErrorConfig);
}
// Cache me if you can
if (ctx != null)
{
ctx.Cache.Insert(cacheKey, xmlDoc, null, DateTime.MaxValue, TimeSpan.FromMinutes(15));
}
}
// See whether this XML is in the new SKOS-compatible format or the old format. The old format used the Preferred attribute.
xmlDoc.skosCompatible = (xmlDoc.SelectNodes("ns:Item[@Preferred]").Count == 0);
return(xmlDoc);
}
/// <summary>
/// Gets the XML for an ESD controlled list or mapping, cacheing it if possible
/// </summary>
/// <param name="xmlFileUri">The URI of the XML file.</param>
/// <param name="withDom">true to include DOM and XPath support; false for XPath only</param>
/// <returns>Populated XML document, or null if not found</returns>
/// <exception cref="FileNotFoundException">Thrown if the file doesn't exist</exception>
/// <exception cref="XmlException">Thrown if the file isn't XML</exception>
/// <exception cref="ArgumentException">Thrown if the file isn't recognised as ESD Taxonomy XML</exception>
public static EsdXmlDocument GetEsdDocument(Uri xmlFileUri, bool withDom)
{
Type documentType = EsdXmlDocument.GetEsdDocumentType(xmlFileUri);
if (documentType == typeof(EsdControlledList))
{
return(EsdControlledList.GetControlledList(xmlFileUri, withDom));
}
else if (documentType == typeof(EsdMapping))
{
return(EsdMapping.GetMapping(xmlFileUri, withDom));
}
// Need this to compile. Shouldn't ever return null, because if neither of those two match an exception should have been thrown
return(null);
}
/// <summary>
/// Gets the ESD metadata terms mapped to the specified terms in another ESD controlled list
/// </summary>
/// <param name="esdListXml">The XML file of the ESD controlled list containing the mapped terms</param>
/// <param name="termsToMap">The terms for which to get mapped terms</param>
/// <param name="mapForwards">If false, map from list B to list A, rather than list A to list B</param>
/// <returns>A collection of mapped terms</returns>
public EsdTermCollection GetMappedTerms(EsdControlledList esdListXml, EsdTermCollection termsToMap, bool mapForwards)
{
EsdTermCollection mappedTerms = new EsdTermCollection();
foreach (EsdTerm termToMap in termsToMap)
{
EsdTermCollection termsFound = this.GetMappedTerms(esdListXml, termToMap.Id, mapForwards);
foreach (EsdTerm foundTerm in termsFound)
{
if (!mappedTerms.Contains(foundTerm))
{
mappedTerms.Add(foundTerm);
}
}
}
return(mappedTerms);
}
/// <summary>
/// Gets the XML for an ESD controlled list, cacheing it if possible
/// </summary>
/// <param name="xmlFileUri">The URI of the XML file.</param>
/// <param name="withDom">true to include DOM and XPath support; false for XPath only</param>
/// <returns>Populated XML document, or null if not found</returns>
public static EsdControlledList GetControlledList(Uri xmlFileUri, bool withDom)
{
HttpContext ctx = HttpContext.Current;
EsdControlledList xmlDoc = null;
string cacheKey = String.Format(CultureInfo.InvariantCulture, "EsdXml_{0}", Regex.Replace(xmlFileUri.ToString(), "[^A-Za-z]", String.Empty));
// Check for the document in the Application Data Cache
if (ctx != null)
{
xmlDoc = (EsdControlledList)ctx.Cache.Get(cacheKey);
}
// Not in cache, so load XML
if (xmlDoc == null)
{
xmlDoc = new EsdControlledList();
if (withDom)
{
xmlDoc.LoadDom(xmlFileUri.ToString());
}
else
{
xmlDoc.LoadXPath(xmlFileUri.ToString());
}
// Cache me if you can
if (ctx != null)
{
ctx.Cache.Insert(cacheKey, xmlDoc, null, DateTime.MaxValue, TimeSpan.FromMinutes(15));
}
}
// See whether this XML is in the new SKOS-compatible format or the old format. The old format used the Preferred attribute.
xmlDoc.skosCompatible = (xmlDoc.SelectNodes("ns:Item[@Preferred]").Count == 0);
return(xmlDoc);
}
private bool skosCompatible = true; // assume up-to-date
#endregion Private fields to cache properties
#region Static factory methods
/// <summary>
/// Gets the XML for an ESD controlled list, cacheing it if possible
/// </summary>
/// <param name="configKey">Key for XML file name <Escc.Web.Metadata/ControlledListXml> section of web.config</param>
/// <returns>Populated XML document, or null if not found</returns>
public static EsdControlledList GetControlledList(string configKey)
{
return(EsdControlledList.GetControlledList(configKey, false));
}
/// <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);
}
}
/// <summary>
/// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"/> interface.
/// </summary>
/// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
public void ProcessRequest(HttpContext context)
{
// If there is no query, just return no results
string searchTerm = String.Empty;
bool formatResultsAsJSON = true;
if (!String.IsNullOrEmpty(context.Request.QueryString["term"]))
{
searchTerm = context.Request.QueryString["term"]; // JQueryUI plugin
}
else if (!String.IsNullOrEmpty(context.Request.QueryString["q"]))
{
searchTerm = context.Request.QueryString["q"]; // old autocomplete plugin
formatResultsAsJSON = false;
}
if (String.IsNullOrEmpty(searchTerm))
{
return;
}
// Check we know which list to query
if (String.IsNullOrEmpty(context.Request.QueryString["list"]))
{
throw new ArgumentException("The controlled list must be specified in the querystring as list=<abbreviated name of list>");
}
// Load the list
EsdControlledList controlledList = EsdControlledList.GetControlledList(context.Request.QueryString["list"]);
List <string> termsFound = new List <string>();
// Are the valid terms limited to a specific list of allowed terms?
if (String.IsNullOrEmpty(context.Request.QueryString["allowed"]))
{
// If not limited, do a standard search for the search term. Get non-preferred terms too because
// they're there to help the user find the appropriate preferred term.
EsdTermCollection results = controlledList.GetTerms(searchTerm, false, EsdPreferredState.Any);
// Return results as one per line, with non-preferred terms suffixed by a separator and the appropriate preferred term
foreach (EsdTerm term in results)
{
if (term.Text.ToUpperInvariant().Contains(searchTerm.ToUpperInvariant()))
{
if (term.Preferred)
{
termsFound.Add(term.Text);
// Add non-preferred terms suffixing them with a separator and the appropriate preferred term
EsdTermCollection nonPreferredTerms = controlledList.GetNonPreferredTerms(term.Id);
foreach (EsdTerm nonPreferredTerm in nonPreferredTerms)
{
if (nonPreferredTerm.Text.Contains(searchTerm))
{
termsFound.Add(nonPreferredTerm.Text + "|" + term.Text);
}
}
}
else
{
// Non-preferred terms will only be directly returned like this from an XML file published before June 2010, which uses the pre-SKOS schema
termsFound.Add(term.Text + "|" + controlledList.GetPreferredTerm(term.ConceptId).Text);
}
}
}
}
else
{
// Only a restricted set of terms are allowed, passed as semi-colon separated list of ids in the querystring.
// Use IDs rather than terms to limit length of querystring.
EsdTermCollection allowed = new EsdTermCollection();
allowed.ReadString(context.Request.QueryString["allowed"]);
// Look up each allowed term (we knew those) and its non-preferred terms (those are new)
foreach (EsdTerm term in allowed)
{
// ReadString has put the ids into the Text property, so use that for search to get the
// text of the preferred term.
EsdTerm preferredTerm = controlledList.GetTerm(term.Text, EsdPreferredState.Preferred);
if (preferredTerm.Text.Contains(searchTerm))
{
termsFound.Add(preferredTerm.Text);
}
// Add non-preferred terms suffixing them with a separator and the appropriate preferred term
EsdTermCollection nonPreferredTerms = controlledList.GetNonPreferredTerms(preferredTerm.Id);
foreach (EsdTerm nonPreferredTerm in nonPreferredTerms)
{
if (nonPreferredTerm.Text.Contains(searchTerm))
{
termsFound.Add(nonPreferredTerm.Text + "|" + preferredTerm.Text);
}
}
}
}
// Sort and return results
termsFound.Sort();
if (formatResultsAsJSON)
{
context.Response.Write("[");
int len = termsFound.Count;
for (int i = 0; i < len; i++)
{
int dividerPos = termsFound[i].IndexOf("|");
if (dividerPos == -1)
{
// preferred term needs only a value property
context.Response.Write("{ \"label\": \"" + termsFound[i].Replace(searchTerm, "<em>" + searchTerm + "</em>") + "\", \"value\": \"" + termsFound[i] + "\" }");
}
else
{
string[] parts = termsFound[i].Split(new char[] { '|' }, 2, StringSplitOptions.RemoveEmptyEntries);
// non-preferred term needs label and value
context.Response.Write("{ \"label\": \"" + parts[0].Replace(searchTerm, "<em>" + searchTerm + "</em>") + " – use " + parts[1] + "\", \"value\": \"" + parts[1] + "\" }");
}
if (i < len - 1)
{
context.Response.Write(",");
}
}
context.Response.Write("]");
}
else
{
// one-per-line format for old autocomplete plugin
foreach (string result in termsFound)
{
context.Response.Write(result + Environment.NewLine);
}
}
}
/// <summary>
/// Gets the ESD metadata terms mapped to the specified term in another ESD controlled list
/// </summary>
/// <param name="esdListXml">The XML file of the ESD controlled list containing the mapped terms</param>
/// <param name="termId">The id of the term for which to get mapped terms</param>
/// <param name="mapForwards">If false, map from list B to list A, rather than list A to list B</param>
/// <param name="termIdToExclude">The id of a term which should not be included even if it is mapped to the specified term</param>
/// <returns>A collection of mapped terms</returns>
public EsdTermCollection GetMappedTerms(EsdControlledList esdListXml, string termId, bool mapForwards, string termIdToExclude)
{
if (termId == null)
{
return(new EsdTermCollection());
}
// get mappings
string xPath;
if (mapForwards)
{
xPath = String.Format(CultureInfo.InvariantCulture, "ns:ItemMapping[ns:From/ns:Item[@Id='{0}']]", termId.Trim());
}
else
{
xPath = String.Format(CultureInfo.InvariantCulture, "ns:ItemMapping[ns:To/ns:Item[@Id='{0}']]", termId.Trim());
}
XPathNodeIterator it = this.SelectNodes(xPath);
// get details of mapped terms
EsdTermCollection terms = new EsdTermCollection();
if (mapForwards)
{
if (termIdToExclude != null && termIdToExclude.Length > 0)
{
xPath = String.Format(CultureInfo.InvariantCulture, "ns:To/ns:Item[@Id!='{0}']", termIdToExclude);
}
else
{
xPath = "ns:To/ns:Item";
}
}
else
{
if (termIdToExclude != null && termIdToExclude.Length > 0)
{
xPath = String.Format(CultureInfo.InvariantCulture, "ns:From/ns:Item[@Id!='{0}']", termIdToExclude);
}
else
{
xPath = "ns:From/ns:Item";
}
}
while (it.MoveNext())
{
XPathNodeIterator mappingNode = this.SelectNodes(xPath, it.Current);
if (mappingNode.Count == 1)
{
mappingNode.MoveNext();
EsdTerm term = esdListXml.GetTerm(mappingNode.Current.GetAttribute("Id", ""), EsdPreferredState.Preferred);
if (term != null)
{
terms.Add(term);
}
}
}
terms.Sort();
return(terms);
}
/// <summary>
/// Gets the ESD metadata terms mapped to the specified term in another ESD controlled list
/// </summary>
/// <param name="esdListXml">The XML file of the ESD controlled list containing the mapped terms</param>
/// <param name="termId">The id of the term for which to get mapped terms</param>
/// <param name="mapForwards">If false, map from list B to list A, rather than list A to list B</param>
/// <returns>A collection of mapped terms</returns>
public EsdTermCollection GetMappedTerms(EsdControlledList esdListXml, string termId, bool mapForwards)
{
return(this.GetMappedTerms(esdListXml, termId, mapForwards, null));
}
/// <summary>
/// Gets the ESD metadata terms mapped to the specified term in another ESD controlled list
/// </summary>
/// <param name="esdListXml">The XML file of the ESD controlled list containing the mapped terms</param>
/// <param name="termId">The id of the term for which to get mapped terms</param>
/// <returns>A collection of mapped terms</returns>
public EsdTermCollection GetMappedTerms(EsdControlledList esdListXml, string termId)
{
return(this.GetMappedTerms(esdListXml, termId, true));
}
/// <summary>
/// Gets the ESD metadata terms mapped to the specified terms in another ESD controlled list
/// </summary>
/// <param name="esdListXml">The XML file of the ESD controlled list containing the mapped terms</param>
/// <param name="termsToMap">The terms for which to get mapped terms</param>
/// <returns>A collection of mapped terms</returns>
public EsdTermCollection GetMappedTerms(EsdControlledList esdListXml, EsdTermCollection termsToMap)
{
return(this.GetMappedTerms(esdListXml, termsToMap, true));
}
/// <summary>
/// Determines whether this mapping is a mapping of the specified list.
/// </summary>
/// <param name="list">The list.</param>
/// <returns>
/// <c>true</c> if this mapping is a mapping of the specified list; otherwise, <c>false</c>.
/// </returns>
public bool IsMappingOf(EsdControlledList list)
{
return(IsMappingFrom(list) || IsMappingTo(list));
}
/// <summary>
/// Determines whether this mapping is to the specified list.
/// </summary>
/// <param name="list">The list.</param>
/// <returns>
/// <c>true</c> if this mapping is to the specified list; otherwise, <c>false</c>.
/// </returns>
public bool IsMappingTo(EsdControlledList list)
{
return(MakeListUriComparable(list.ThisVersionUrl) == MakeListUriComparable(this.ToListUrl));
}
