public void Set(TaxonomicClassification taxonomy, WolframCommonNameData commonNameData)
{
using (var sqlConnection = new SqlConnection(WhatIsThatDbConnString))
{
sqlConnection.Open();
var cmd = new SqlCommand("UPDATE TaxonomyToName " +
"SET CommonName=@CommonName " +
"WHERE Kingdom=@Kingdom AND Phylum=@Phylum AND Class=@Class AND [Order]=@Order " +
"AND Family=@Family AND Genus=@Genus AND Species=@Species " +
"IF @@ROWCOUNT=0 INSERT INTO TaxonomyToName (CommonName, Kingdom, Phylum, Class, [Order], Family, Genus, Species) " +
"VALUES (@CommonName, @Kingdom, @Phylum, @Class, @Order, @Family, @Genus, @Species)")
{
CommandType = CommandType.Text,
Connection = sqlConnection
};
cmd.Parameters.AddWithValue("@CommonName", commonNameData.Name.Trim().ToLower());
cmd.Parameters.AddWithValue("@Kingdom", taxonomy.GetKingdom().Trim().ToLower());
cmd.Parameters.AddWithValue("@Phylum", taxonomy.GetPhylum().Trim().ToLower());
cmd.Parameters.AddWithValue("@Class", taxonomy.GetClass().Trim().ToLower());
cmd.Parameters.AddWithValue("@Order", taxonomy.GetOrder().Trim().ToLower());
cmd.Parameters.AddWithValue("@Family", taxonomy.GetFamily().Trim().ToLower());
cmd.Parameters.AddWithValue("@Genus", taxonomy.GetGenus().Trim().ToLower());
cmd.Parameters.AddWithValue("@Species", taxonomy.GetSpecies().Trim().ToLower());
cmd.ExecuteNonQuery();
}
var cacheKey = GenerateCommonNameCacheKey(taxonomy);
CommonNameCache.Set(cacheKey, commonNameData);
}
private WolframCommonNameData GetCommonNameDataFromDb(TaxonomicClassification taxonomy)
{
using (var sqlConnection = new SqlConnection(WhatIsThatDbConnString))
{
sqlConnection.Open();
var cmd = new SqlCommand("SELECT TOP 1 * FROM TaxonomyToName WHERE Kingdom=@Kingdom AND Phylum=@Phylum AND " +
"Class=@Class AND [Order]=@Order AND Family=@Family AND Genus=@Genus AND Species=@Species ")
{
CommandType = CommandType.Text,
Connection = sqlConnection
};
cmd.Parameters.AddWithValue("@Kingdom", taxonomy.GetKingdom().Trim().ToLower());
cmd.Parameters.AddWithValue("@Phylum", taxonomy.GetPhylum().Trim().ToLower());
cmd.Parameters.AddWithValue("@Class", taxonomy.GetClass().Trim().ToLower());
cmd.Parameters.AddWithValue("@Order", taxonomy.GetOrder().Trim().ToLower());
cmd.Parameters.AddWithValue("@Family", taxonomy.GetFamily().Trim().ToLower());
cmd.Parameters.AddWithValue("@Genus", taxonomy.GetGenus().Trim().ToLower());
cmd.Parameters.AddWithValue("@Species", taxonomy.GetSpecies().Trim().ToLower());
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var commonName = reader["CommonName"].ToString();
return(WolframCommonNameData.GetInstance(commonName));
}
}
}
}
return(null);
}
public List <TaxonomicClassification> GetLocalSpeciesTaxonomiesList(GeographyPoint coordinates)
{
var dtos = GetApplicableSpeciesListDtos(coordinates);
var classificationsLookup = new Dictionary <String, TaxonomicClassification>
{
{ "H**o.sapien", TaxonomicClassification.HUMAN },
};
//Strangely, humans aren't listed in their data! We need it for our purposes.
foreach (var dto in dtos)
{
var classifications = dto.SpeciesInfoDtoList.Select(speciesInfoDto =>
TaxonomicClassification.GetInstance(speciesInfoDto.Kingdom, speciesInfoDto.Phylum, speciesInfoDto.Class, speciesInfoDto.Order,
speciesInfoDto.Family, speciesInfoDto.Genus, speciesInfoDto.Species)).ToList();
foreach (var classification in classifications)
{
var key = classification.GetGenus().Trim().ToLower() + "." + classification.GetSpecies().Trim().ToLower();
if (!classificationsLookup.ContainsKey(key))
{
classificationsLookup.Add(key, classification);
}
}
}
return(classificationsLookup.Values.ToList());
}
public Boolean IsOutlier(TaxonomicClassification toCompare, List <TaxonomicClassification> taxonomies)
{
if (taxonomies.Count < 3)
{
//Not enough to determine
return(false);
}
var usedClassifications = new List <TaxonomicClassification.BiologicalClassification>
{
TaxonomicClassification.BiologicalClassification.Kingdom,
TaxonomicClassification.BiologicalClassification.Phylum
};
foreach (var classification in usedClassifications)
{
var hits = new Dictionary <String, int>();
var toCompareTaxonomicInfo = toCompare.GetOrderedTaxonomicInfo();
var myValue = toCompareTaxonomicInfo.Find(item => item.Key == classification).Value;
if (String.IsNullOrWhiteSpace(myValue))
{
return(false);
}
foreach (var candidate in taxonomies)
{
var taxonomicInfo = candidate.GetOrderedTaxonomicInfo();
var candidateValue = taxonomicInfo.Find(item => item.Key == classification).Value;
if (String.IsNullOrEmpty(candidateValue))
{
continue;
}
if (!hits.ContainsKey(candidateValue))
{
hits.Add(candidateValue, 1);
}
else
{
hits[candidateValue]++;
}
}
if (!hits.ContainsKey(myValue))
{
return(false);
}
if (hits.Values.Max() > 1 && hits[myValue] == 1)
{
return(true);
}
}
return(false);
}
private String GenerateCommonNameCacheKey(TaxonomicClassification taxonomy)
{
var keyBuffer = new StringBuilder();
keyBuffer.Append(taxonomy.GetGenus());
keyBuffer.Append("_");
keyBuffer.Append(taxonomy.GetSpecies());
return(keyBuffer.ToString());
}
public WolframCommonNameData Get(TaxonomicClassification taxonomy)
{
var cacheKey = GenerateCommonNameCacheKey(taxonomy);
var cachedCommonNameData = CommonNameCache.Get(cacheKey);
if (cachedCommonNameData != null)
{
return(cachedCommonNameData);
}
var commonNameData = GetCommonNameDataFromDb(taxonomy);
if (commonNameData != null)
{
CommonNameCache.Set(cacheKey, commonNameData);
}
return(commonNameData);
}
public String GetCommonNameFromScientific(TaxonomicClassification taxonomy)
{
//Both are required
if (String.IsNullOrEmpty(taxonomy.GetGenus()) || String.IsNullOrWhiteSpace(taxonomy.GetSpecies()))
{
return("");
}
var cachedNameInfo = CommonNameCache.Get(taxonomy);
if (cachedNameInfo != null)
{
return(cachedNameInfo.Name);
}
var parameters = new List <Parameter>();
var genusParam = new Parameter {
Name = "genus", Value = taxonomy.GetGenus(), Type = ParameterType.QueryString
};
parameters.Add(genusParam);
var speciesParam = new Parameter {
Name = "species", Value = taxonomy.GetSpecies(), Type = ParameterType.QueryString
};
parameters.Add(speciesParam);
var nameDataDto = ExecuteGetRequest <WolframResponseDto>(CommonNameDataPath, parameters);
if (nameDataDto != null)
{
var nameData = WolframCommonNameData.GetInstance(nameDataDto);
CommonNameCache.Set(taxonomy, nameData);
return(nameData.Name);
}
return("");
}
public TaxonomicClassification GetTaxonomyData(String tag)
{
var cachedTaxonomyData = TaxonomicDataCache.Get(tag);
if (cachedTaxonomyData != null)
{
return(TaxonomicClassification.GetInstance(cachedTaxonomyData.Kingdom, cachedTaxonomyData.Phylum,
cachedTaxonomyData.Class, cachedTaxonomyData.Order, cachedTaxonomyData.Family,
cachedTaxonomyData.Genus, cachedTaxonomyData.Species));
}
var parameters = new List <Parameter>();
var tagParameter = new Parameter {
Name = "tag", Value = tag, Type = ParameterType.QueryString
};
parameters.Add(tagParameter);
var taxonomicDataDto = ExecuteGetRequest <WolframResponseDto>(TaxonomicDataPath, parameters);
if (taxonomicDataDto != null)
{
var wolframTaxonomyData = WolframTaxonomyData.GetInstance(taxonomicDataDto);
TaxonomicDataCache.Set(tag, wolframTaxonomyData);
return(TaxonomicClassification.GetInstance(wolframTaxonomyData.Kingdom, wolframTaxonomyData.Phylum,
wolframTaxonomyData.Class, wolframTaxonomyData.Order, wolframTaxonomyData.Family,
wolframTaxonomyData.Genus, wolframTaxonomyData.Species));
}
var nullData = WolframTaxonomyData.NULL;
return(TaxonomicClassification.GetInstance(nullData.Kingdom, nullData.Phylum,
nullData.Class, nullData.Order, nullData.Family,
nullData.Genus, nullData.Species));
}
