public WebTaxonNameSearchCriteria GetTaxonNameSearchCriteria(Boolean refresh)
 {
     if (_taxonNameSearchCriteria.IsNull() || refresh)
     {
         _taxonNameSearchCriteria = new WebTaxonNameSearchCriteria();
     }
     return(_taxonNameSearchCriteria);
 }
        public static WebTaxonName GetTaxonName(WebServiceContext context)
        {
            List <WebTaxonName>        taxonNames;
            WebTaxonNameSearchCriteria searchCriteria;

            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.NameSearchString = "björn";
            taxonNames = TaxonManager.GetTaxonNamesBySearchCriteria(context, searchCriteria);
            return(taxonNames[0]);
        }
示例#3
0
        /// <summary>
        /// Check the data in current object
        /// </summary>
        /// <param name='searchCriteria'>Search criteria.</param>
        public static void CheckData(this WebTaxonNameSearchCriteria searchCriteria)
        {
            if (searchCriteria.IsNotNull())
            {
                searchCriteria.CheckStrings();
                if (searchCriteria.AuthorSearchString.IsNotNull())
                {
                    searchCriteria.AuthorSearchString.SearchString = searchCriteria.AuthorSearchString.SearchString.CheckSqlInjection();
                }

                if (searchCriteria.NameSearchString.IsNotNull())
                {
                    searchCriteria.NameSearchString.SearchString = searchCriteria.NameSearchString.SearchString.CheckSqlInjection();
                }
            }
        }
示例#4
0
        /// <summary>
        /// Get taxon names that matches the search criteria.
        /// </summary>
        /// <param name="searchCriteria">The taxon name search criteria.</param>
        /// <returns>Taxon names.</returns>
        /// <exception cref="ArgumentException">Thrown if search criteria is not valid.</exception>
        public static TaxonNameList GetTaxonNamesBySearchCriteria(TaxonNameSearchCriteria searchCriteria)
        {
            List <WebTaxonName>        webTaxonNames;
            WebTaxonNameSearchCriteria webSearchCriteria;

            // Check arguments.
            searchCriteria.CheckNotNull("searchCriteria");
            searchCriteria.CheckData();

            // Create WebSearchCriteria.
            webSearchCriteria = new WebTaxonNameSearchCriteria();
            webSearchCriteria.NameSearchMethod = searchCriteria.NameSearchMethod;
#if DATA_SPECIFIED_EXISTS
            webSearchCriteria.NameSearchMethodSpecified = true;
#endif
            webSearchCriteria.NameSearchString = searchCriteria.NameSearchString;

            // Get data from web service.
            webTaxonNames = WebServiceClient.GetTaxonNamesBySearchCriteria(webSearchCriteria);
            return(GetTaxonNames(webTaxonNames));
        }
        public void GetTaxonNamesBySearchCriteria()
        {
            List <WebTaxonName>        taxonNames;
            WebTaxonNameSearchCriteria searchCriteria;

            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.NameSearchString = new WebStringSearchCriteria();
            searchCriteria.NameSearchString.SearchString = "Trumgräshoppa";
            taxonNames = WebServiceProxy.TaxonService.GetTaxonNamesBySearchCriteria(GetClientInformation(), searchCriteria);
            Assert.IsTrue(taxonNames.IsNotEmpty());

            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.NameSearchString = new WebStringSearchCriteria();
            searchCriteria.NameSearchString.SearchString = "Björn";
            taxonNames = WebServiceProxy.TaxonService.GetTaxonNamesBySearchCriteria(GetClientInformation(), searchCriteria);
            Assert.IsTrue(taxonNames.IsNotEmpty());

            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.IsIsOriginalNameSpecified = true;
            searchCriteria.IsOriginalName            = true;
            taxonNames = WebServiceProxy.TaxonService.GetTaxonNamesBySearchCriteria(GetClientInformation(), searchCriteria);
            Assert.IsTrue(taxonNames.IsNotEmpty());
        }
        public void GetTaxonNamesBySearchCriteria()
        {
            List <WebTaxonName>        taxonNames;
            WebTaxonNameSearchCriteria searchCriteria;

            foreach (ArtDatabankenService.Data.SearchStringComparisonMethod nameSearchMethod in Enum.GetValues(typeof(ArtDatabankenService.Data.SearchStringComparisonMethod)))
            {
                searchCriteria = new WebTaxonNameSearchCriteria();
                searchCriteria.NameSearchString = "björn";
                searchCriteria.NameSearchMethod = nameSearchMethod;
                taxonNames = TaxonManager.GetTaxonNamesBySearchCriteria(GetContext(), searchCriteria);
                Assert.IsTrue(taxonNames.IsNotEmpty());
            }

            // Test retrieval of name for not valid taxon.
            // The taxon name occurs twice, with relation
            // to both valid and invalid taxon.
            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.NameSearchString = "fläckig björnspinnare";
            taxonNames = TaxonManager.GetTaxonNamesBySearchCriteria(GetContext(), searchCriteria);
            Assert.IsTrue(taxonNames.IsNotEmpty());
            Assert.AreEqual(1, taxonNames.Count);
            Assert.AreEqual(searchCriteria.NameSearchString, taxonNames[0].Name);
        }
 public WebTaxonNameSearchCriteriaTest()
 {
     _taxonNameSearchCriteria = null;
 }
        public void GetTaxaById()
        {
            Boolean                    taxonFound;
            List <Int32>               taxonIds;
            List <WebTaxon>            taxa;
            List <WebTaxonName>        taxonNames;
            WebTaxonNameSearchCriteria searchCriteria;

            foreach (TaxonInformationType taxonInformationType in Enum.GetValues(typeof(TaxonInformationType)))
            {
                taxa = TaxonManager.GetTaxaById(GetContext(), GetSomeTaxonIds(), taxonInformationType);
                Assert.IsNotNull(taxa);
                Assert.AreEqual(taxa.Count, GetSomeTaxonIds().Count);

                foreach (WebTaxon taxon in taxa)
                {
                    Assert.AreEqual(taxon.TaxonInformationType, taxonInformationType);

                    taxonFound = false;
                    foreach (Int32 taxonId in GetSomeTaxonIds())
                    {
                        if (taxonId == taxon.Id)
                        {
                            taxonFound = true;
                            break;
                        }
                    }
                    Assert.IsTrue(taxonFound);
                }
            }

            // Test that only valid relations in dt_hier are used.
            // Test taxon is 1097, Oedipodium Griffithianum which
            // has moved in the taxa tree more than once.

            taxonIds = new List <Int32>();
            taxonIds.Add(1097);
            taxa = TaxonManager.GetTaxaById(GetContext(), taxonIds, TaxonInformationType.PrintObs);
            Assert.IsNotNull(taxa);
            Assert.AreEqual(taxa.Count, taxonIds.Count);

            // Test problem with searching for taxon names equal to 'mossa'.
            searchCriteria = new WebTaxonNameSearchCriteria();
            searchCriteria.NameSearchString = "mossa";
            searchCriteria.NameSearchMethod = ArtDatabankenService.Data.SearchStringComparisonMethod.Iterative;
            taxonNames = TaxonManager.GetTaxonNamesBySearchCriteria(GetContext(), searchCriteria);
            taxonIds   = new List <Int32>();
            foreach (WebTaxonName taxonName in taxonNames)
            {
                if (!taxonIds.Contains(taxonName.Taxon.Id))
                {
                    taxonIds.Add(taxonName.Taxon.Id);
                }
            }
            taxa = TaxonManager.GetTaxaById(GetContext(), taxonIds, TaxonInformationType.Basic);
            Assert.IsTrue(taxa.IsNotEmpty());

            // Test with invalid taxa.
            taxonIds = new List <Int32>();
            taxonIds.Add(190);
            taxonIds.Add(1637);
            taxonIds.Add(1638);
            taxa = TaxonManager.GetTaxaById(GetContext(), taxonIds, TaxonInformationType.Basic);
            Assert.IsTrue(taxa.IsNotEmpty());
            Assert.AreEqual(taxonIds.Count, taxa.Count);
        }