/// <summary>
/// Searches for taxa using the give search options.
/// </summary>
/// <param name="searchOptions">The search options to use in the search.</param>
/// <returns></returns>
public List <TaxonSearchResultItemViewModel> SearchTaxa(TaxonSearchOptions searchOptions)
{
TaxonNameSearchCriteria taxonNameSearchCriteria = searchOptions.CreateTaxonNameSearchCriteriaObject();
TaxonNameList taxonNames = CoreData.TaxonManager.GetTaxonNames(_user, taxonNameSearchCriteria);
ITaxon taxonFoundById = SearchTaxonById(searchOptions.NameSearchString);
var resultList = new List <TaxonSearchResultItemViewModel>();
if (taxonFoundById != null) // the user entered a valid taxonid as search string
{
resultList.Add(TaxonSearchResultItemViewModel.CreateFromTaxon(taxonFoundById));
}
for (int i = 0; i < taxonNames.Count; i++)
{
resultList.Add(TaxonSearchResultItemViewModel.CreateFromTaxonName(taxonNames[i]));
}
resultList = resultList.Distinct().ToList();
SpeciesFactManager speciesFactManager = new SpeciesFactManager(_user);
IEnumerable <ITaxon> protectedTaxonList = speciesFactManager.GetProtectedTaxons();
// Set protection level for each taxon; public or not
resultList.ForEach(t => t.SpeciesProtectionLevel = protectedTaxonList.Any(ptl => ptl.Id == t.TaxonId) ? SpeciesProtectionLevelEnum.Protected1 : SpeciesProtectionLevelEnum.Public);
return(resultList);
}
public TaxonNameList searchTaxa(string searchString)
{
ITaxonNameSearchCriteria searchCriteria;
TaxonNameList taxonNames;
searchCriteria = new TaxonNameSearchCriteria();
// Begränsa sökningen till vetenskapliga namn.
searchCriteria.Category = CoreData.TaxonManager.GetTaxonNameCategory(getUserContext(), (Int32)(TaxonNameCategoryId.ScientificName));
// Begränsa sökningen till giltiga namn och taxa.
searchCriteria.IsValidTaxon = true;
searchCriteria.IsValidTaxonName = true;
// Ange söksträng.
searchCriteria.NameSearchString = new StringSearchCriteria();
searchCriteria.NameSearchString.SearchString = searchString;
// Tala om hur söksträngen ska matchas mot de vetenskapliga namnen.
// Om mer än en operator anges så provas de en i taget tills minst en träff fås.
searchCriteria.NameSearchString.CompareOperators = new List <StringCompareOperator>();
searchCriteria.NameSearchString.CompareOperators.Add(StringCompareOperator.Equal);
taxonNames = CoreData.TaxonManager.GetTaxonNames(getUserContext(), searchCriteria);
//if (taxonNames.IsNotEmpty() && taxonNames.Count == 1)
//{
// Hämta föräldraträdet.
// TaxonTreeNode pekar på taxonNames[0].Taxon så det gäller
// att gå upp i trädet via taxonTreeNode.Parents för att få
// information om föräldrarna.
//taxonTreeNode = taxonNames[0].Taxon.GetParentTaxonTree(getUserContext(), true);
//}
// else. Hantera problemet om sökningen gav noll eller flera träffar.
return(taxonNames);
}
public TaxonNameSearchCriteria CreateTaxonNameSearchCriteriaObject()
{
var taxonNameSearchCriteria = new TaxonNameSearchCriteria();
if (!string.IsNullOrEmpty(NameSearchString))
{
var nameSearchCriteria = new StringSearchCriteria();
nameSearchCriteria.SearchString = NameSearchString;
nameSearchCriteria.CompareOperators = new List <StringCompareOperator>();
if (NameCompareOperator.HasValue)
{
nameSearchCriteria.CompareOperators.AddRange(GetStringCompareOperator(NameCompareOperator.Value));
}
else
{
nameSearchCriteria.CompareOperators.AddRange(GetStringCompareOperator(DefaultNameCompareOperator));
}
taxonNameSearchCriteria.NameSearchString = nameSearchCriteria;
}
if (!string.IsNullOrEmpty(AuthorSearchString))
{
var authorSearchCriteria = new StringSearchCriteria();
authorSearchCriteria.SearchString = AuthorSearchString;
authorSearchCriteria.CompareOperators = new List <StringCompareOperator>();
if (AuthorCompareOperator.HasValue)
{
authorSearchCriteria.CompareOperators.AddRange(GetStringCompareOperator(AuthorCompareOperator.Value));
}
else
{
authorSearchCriteria.CompareOperators.AddRange(GetStringCompareOperator(DefaultAuthorCompareOperator));
}
taxonNameSearchCriteria.AuthorSearchString = authorSearchCriteria;
}
taxonNameSearchCriteria.IsOkForSpeciesObservation = IsOkForObsSystems;
taxonNameSearchCriteria.IsRecommended = IsRecommended;
taxonNameSearchCriteria.IsUnique = IsUnique;
taxonNameSearchCriteria.IsValidTaxon = IsValidTaxon;
taxonNameSearchCriteria.IsValidTaxonName = IsValidTaxonName;
if (NameCategoryId.HasValue && NameCategoryId.Value != -1)
{
taxonNameSearchCriteria.Category = taxonNameSearchCriteria.Category = CoreData.TaxonManager.GetTaxonNameCategory(
CoreData.UserManager.GetCurrentUser(),
NameCategoryId.Value);
}
if (RestrictToTaxonId.HasValue && RestrictToTaxonChildren)
{
taxonNameSearchCriteria.TaxonIds = new List <int> {
RestrictToTaxonId.Value
};
}
return(taxonNameSearchCriteria);
}
/// <summary>
/// The general matching algorithm.
/// This method is called by all the other methods in order to get the match result.
/// </summary>
/// <param name="item">The match item.</param>
/// <param name="options">Match options.</param>
/// <returns></returns>
private DyntaxaMatchItem GetMatch(DyntaxaMatchItem item, MatchSettingsViewModel options)
{
item.Status = MatchStatus.NoMatch;
if (options.ColumnContentAlternative == MatchColumnContentAlternative.NameAndAuthorCombined)
{
//TODO: split name and author
/*
* StringBuilder name = new StringBuilder();
* StringBuilder author = new StringBuilder();
* bool nameIsCompleted = false;
* string[] stringArray = item.NameString.Split(' ');
* for (int i = 0; i < stringArray.Length; i++)
* {
* if (!nameIsCompleted)
* {
* if (name.Length > 0)
* {
* name.Append(" ");
*
* }
* name.Append(stringArray[i]);
* }
* }
*/
}
//ITaxonSearchCriteria taxonSearchCriteria = new TaxonSearchCriteria();
//taxonSearchCriteria.TaxonName = item.NameString;
////taxonSearchCriteria.TaxonIds =
////taxonSearchCriteria.TaxonCategoryIds =
//CoreData.TaxonManager.GetTaxaBySearchCriteria(_user, taxonSearchCriteria);
//var taxonNameSearchCriteria = new TaxonNameSearchCriteria();
//taxonNameSearchCriteria.NameSearchString = new StringSearchCriteria();
//taxonNameSearchCriteria.NameSearchString.SearchString = item.NameString;
//taxonNameSearchCriteria.NameSearchString.CompareOperators = new List<StringCompareOperator>();
//taxonNameSearchCriteria.NameSearchString.CompareOperators.Add(StringCompareOperator.Iterative);
//if (options.LimitToTaxon && options.LimitToParentTaxonId.HasValue)
//{
// taxonNameSearchCriteria.TaxonIdList = new List<int> { options.LimitToParentTaxonId.Value };
//}
options.SearchOptions.NameSearchString = item.NameString;
TaxonNameSearchCriteria taxonNameSearchCriteria = options.SearchOptions.CreateTaxonNameSearchCriteriaObject();
if (options.MatchToType == MatchTaxonToType.TaxonNameAndAuthor)
{
taxonNameSearchCriteria.IsAuthorIncludedInNameSearchString = true;
}
TaxonNameList taxonNames = CoreData.TaxonManager.GetTaxonNames(_user, taxonNameSearchCriteria);
if (taxonNames.IsNotEmpty())
{
var dicTaxonNames = new Dictionary <int, ITaxonName>();
foreach (ITaxonName taxonName in taxonNames)
{
if (taxonName.Status.Id == (int)TaxonNameStatusId.Removed)
{
continue;
}
if (!dicTaxonNames.ContainsKey(taxonName.Taxon.Id))
{
dicTaxonNames.Add(taxonName.Taxon.Id, taxonName);
}
}
if (dicTaxonNames.Count == 1)
{
ITaxon taxon = CoreData.TaxonManager.GetTaxon(_user, dicTaxonNames.Keys.First());
item.SetTaxon(taxon, options);
item.Status = MatchStatus.Exact;
}
else if (dicTaxonNames.Count > 1)
{
item.Status = MatchStatus.NeedsManualSelection;
item.DropDownListIdentifier = "AlternativeTaxa" + item.RowNumber.ToString();
item.AlternativeTaxa = new TaxonSelectList(taxonNames).GetList(); // todo - den här ska vara med
}
}
else
{
//TODO: Using som fuzzy algorithms to obtain taxon suggestions.
}
return(item);
}
