public void SpeciesEncyclopediaArticleConstructor1Test()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetTargetSpeciesFacts();
            SpeciesEncyclopediaArticle target = new SpeciesEncyclopediaArticle(speciesFacts);

            Assert.IsNotNull(target);
        }
        public void GetSpeciesFactsByParameters()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetSpeciesFacts();

            Data.ArtDatabankenService.SpeciesFactList subsetWithTaxon = speciesFacts.GetSpeciesFactsByParameters(speciesFacts[0].Taxon);
            Assert.IsNotNull(subsetWithTaxon);
            Assert.AreEqual(speciesFacts[0].Taxon.ScientificName, subsetWithTaxon[0].Taxon.ScientificName);

            Data.ArtDatabankenService.SpeciesFactList subsetWithFactor = speciesFacts.GetSpeciesFactsByParameters(speciesFacts[0].Factor);
            Assert.IsNotNull(subsetWithFactor);
            Assert.AreEqual(speciesFacts[0].Factor.Label, subsetWithFactor[0].Factor.Label);

            Data.ArtDatabankenService.SpeciesFactList subsetWithIndividualCetegory = speciesFacts.GetSpeciesFactsByParameters(speciesFacts[0].IndividualCategory);
            Assert.IsNotNull(subsetWithIndividualCetegory);
            Assert.AreEqual(speciesFacts[0].IndividualCategory.Name, subsetWithIndividualCetegory[0].IndividualCategory.Name);

            Data.ArtDatabankenService.SpeciesFactList subsetWithPeriod = speciesFacts.GetSpeciesFactsByParameters(speciesFacts[0].Period);
            Assert.IsNotNull(subsetWithPeriod);
            Assert.AreEqual(speciesFacts[0].Period, subsetWithPeriod[0].Period);

            Data.ArtDatabankenService.SpeciesFactList subsetWithCombination = speciesFacts.GetSpeciesFactsByParameters(
                speciesFacts[0].Taxon,
                speciesFacts[0].IndividualCategory,
                speciesFacts[0].Factor,
                speciesFacts[0].Period);
            Assert.IsNotNull(subsetWithCombination);
            Assert.AreEqual(1, subsetWithCombination.Count);
        }
        public void SpeciesFactsTest()
        {
            SpeciesInformationDocument target = GetTargetSpeciesInformationDocument();

            Data.ArtDatabankenService.SpeciesFactList list = target.SpeciesFacts;
            Assert.IsNotNull(list);
        }
        public void SpeciesFactsTest()
        {
            SpeciesEncyclopediaArticle target = GetTargetSpeciesEncyclopediaArticle();

            Data.ArtDatabankenService.SpeciesFactList list = target.SpeciesFacts;
            Assert.IsNotNull(list);
        }
        public void SpeciesInformationDocumentConstructor1Test()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetTargetSpeciesFacts();
            SpeciesInformationDocument target = new SpeciesInformationDocument(speciesFacts);

            Assert.IsNotNull(target);
        }
        public void ThreatsParagraphTest()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetTargetSpeciesFacts();
            SpeciesEncyclopediaArticle target = new SpeciesEncyclopediaArticle(speciesFacts);
            string actual = target.ThreatsParagraph;

            Assert.IsTrue(actual.Length > 50);
        }
        public void ThreatsParagraphTest()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetTargetSpeciesFacts();
            SpeciesInformationDocument target = new SpeciesInformationDocument(speciesFacts);
            string actual = target.ThreatsParagraph;

            Assert.IsTrue(actual.Length > 50);
        }
        public void GetSpeciesFactsByQuality()
        {
            Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetSpeciesFacts();

            Data.ArtDatabankenService.SpeciesFactList subset = speciesFacts.GetSpeciesFactsByQuality(speciesFacts[0].Quality);
            Assert.IsNotNull(subset);
            Assert.AreEqual(speciesFacts[0].Quality, subset[0].Quality);
        }
 private Data.ArtDatabankenService.SpeciesFactList GetTargetSpeciesFacts()
 {
     if (_targetSpeciesFacts.IsNull())
     {
         SpeciesEncyclopediaArticle target = GetTargetSpeciesEncyclopediaArticle();
         _targetSpeciesFacts = target.SpeciesFacts;
     }
     return(_targetSpeciesFacts);
 }
 private Data.ArtDatabankenService.SpeciesFactList GetTargetSpeciesFacts()
 {
     if (_targetSpeciesFacts.IsNull())
     {
         SpeciesInformationDocument target = GetTargetSpeciesInformationDocument();
         _targetSpeciesFacts = target.SpeciesFacts;
     }
     return(_targetSpeciesFacts);
 }
 public void CountChanges()
 {
     Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetSpeciesFacts();
     Data.ArtDatabankenService.SpeciesFact     testFact     = speciesFacts[1];
     Assert.IsFalse(testFact.HasChanged);
     Assert.AreEqual(speciesFacts.CountChanges(), 0);
     testFact.MainField.EnumValue = testFact.Factor.FactorDataType.MainField.FactorFieldEnum.Values[0];
     Assert.IsTrue(testFact.HasChanged);
     Assert.AreEqual(speciesFacts.CountChanges(), 1);
 }
        public void ExpandSpeciesFactListWithEmptySpeciesFactsSpeciesFactsNull()
        {
            UserParameterSelection userparams = new UserParameterSelection();

            userparams.Taxa.Merge(TaxonManagerTest.GetTaxaList());
            Assert.AreNotEqual(0, userparams.Taxa.Count);
            userparams.Factors.Clear();
            userparams.Factors.AddRange(GetSomeNoHeaderNoPeriodicFactors());
            Assert.AreNotEqual(0, userparams.Factors.Count);
            Data.ArtDatabankenService.SpeciesFactList facts = null;
            Data.ArtDatabankenService.SpeciesFactManager.ExpandSpeciesFactListWithEmptySpeciesFacts(userparams, facts);
        }
 public void GetSpeciesFactByUniqueParameterCombination()
 {
     Data.ArtDatabankenService.SpeciesFactList speciesFacts = GetSpeciesFacts();
     Data.ArtDatabankenService.SpeciesFact     testFact     = speciesFacts[0];
     Data.ArtDatabankenService.SpeciesFact     speciesFact  = speciesFacts.Get(
         testFact.Taxon,
         testFact.IndividualCategory,
         testFact.Factor,
         testFact.Host,
         testFact.Period);
     Assert.IsNotNull(speciesFact);
     Assert.AreEqual(testFact, speciesFact);
 }
        public void ExpandSpeciesFactListWithEmptySpeciesFactsUsingTwoCategories()
        {
            UserParameterSelection userparams = new UserParameterSelection();

            userparams.Taxa.Merge(TaxonManagerTest.GetTaxaList());
            Assert.AreNotEqual(0, userparams.Taxa.Count);
            userparams.Factors.Merge(GetSomeNoHeaderNoPeriodicFactors());
            Assert.AreNotEqual(0, userparams.Factors.Count);

            // add some categories
            userparams.IndividualCategories.Merge(GetTwoIndividualCategories());
            Assert.AreNotEqual(0, userparams.IndividualCategories.Count);

            Data.ArtDatabankenService.SpeciesFactList facts = new Data.ArtDatabankenService.SpeciesFactList();
            Data.ArtDatabankenService.SpeciesFactManager.ExpandSpeciesFactListWithEmptySpeciesFacts(userparams, facts);

            //The real test
            Assert.AreEqual((userparams.Taxa.Count * userparams.Factors.Count * userparams.IndividualCategories.Count), facts.Count);
        }
        private Data.ArtDatabankenService.SpeciesFactList GetSpeciesFacts()
        {
            if (_speciesFacts.IsNull())
            {
                List <Int32> factorIds;
                factorIds = new List <Int32>();
                List <Int32> taxonIds;
                taxonIds = new List <Int32>();

                factorIds.Add((Int32)FactorId.LandscapeFactors);
                factorIds.Add((Int32)FactorId.LandscapeFactor_Agricultural);
                factorIds.Add((Int32)FactorId.LandscapeFactor_Alpin);
                factorIds.Add((Int32)FactorId.LandscapeFactor_Coast);

                taxonIds.Add(1);

                UserParameterSelection userParameterSelection = new UserParameterSelection();
                userParameterSelection.Factors.Merge(Data.ArtDatabankenService.FactorManager.GetFactors(factorIds));
                userParameterSelection.Taxa.Merge(ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxa(taxonIds, ArtDatabanken.Data.WebService.TaxonInformationType.Basic));

                _speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParameterSelection);
            }
            return(_speciesFacts);
        }
 public SpeciesEncyclopediaArticleTest()
 {
     _targetSpeciesFacts = null;
     _targetSpeciesEncyclopediaArticle = null;
 }
        public void UpdateSpeciesFacts()
        {
            DateTime oldUpdateDate;
            Int32    fieldIndex, oldReferenceId, oldQualityId;

            Data.ArtDatabankenService.Reference        reference;
            Data.ArtDatabankenService.SpeciesFact      changedSpeciesFact;
            Data.ArtDatabankenService.SpeciesFactField field;
            Data.ArtDatabankenService.SpeciesFactList  changedSpeciesFacts, speciesFacts;
            String oldUpdateUser;
            String stringValue;
            UserParameterSelection userParameterSelection;

            // Test delete of species fact.
            using (WebTransaction transaction = new WebTransaction(5))
            {
                // Delete some species facts.
                speciesFacts = GetSomeSpeciesFacts();
                foreach (Data.ArtDatabankenService.SpeciesFact speciesFact in speciesFacts)
                {
                    if (speciesFact.AllowManualUpdate)
                    {
                        for (fieldIndex = 0; fieldIndex < speciesFact.Fields.Count; fieldIndex++)
                        {
                            speciesFact.Fields[fieldIndex].Value = null;
                        }
                    }
                }
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(speciesFacts, ReferenceManagerTest.GetAReference());

                // Verify that delete has been done.
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(speciesFacts);
                foreach (Data.ArtDatabankenService.SpeciesFact speciesFact in speciesFacts)
                {
                    if (speciesFact.AllowManualUpdate)
                    {
                        Assert.IsTrue(!speciesFact.HasId ||
                                      (speciesFact.MainField.Type.DataType == FactorFieldDataTypeId.Enum));
                    }
                }
            }
            Thread.Sleep(6000);

            // Test creation of species fact.
            using (WebTransaction transaction = new WebTransaction(5))
            {
                // Create some species facts.
                changedSpeciesFacts    = new Data.ArtDatabankenService.SpeciesFactList();
                userParameterSelection = new UserParameterSelection();
                userParameterSelection.Taxa.Merge(ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxa(TaxonManagerTest.GetTaxaIds(), TaxonInformationType.Basic));
                userParameterSelection.Factors.Merge(Data.ArtDatabankenService.FactorManager.GetFactors(FactorManagerTest.GetFactorIds()));
                speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParameterSelection);
                foreach (Data.ArtDatabankenService.SpeciesFact speciesFact in speciesFacts)
                {
                    if (speciesFact.AllowManualUpdate &&
                        !speciesFact.HasId)
                    {
                        switch (speciesFact.MainField.Type.DataType)
                        {
                        case FactorFieldDataTypeId.Boolean:
                            speciesFact.MainField.Value = true;
                            break;

                        case FactorFieldDataTypeId.Double:
                            speciesFact.MainField.Value = 1;
                            break;

                        case FactorFieldDataTypeId.Int32:
                            speciesFact.MainField.Value = 1;
                            break;

                        case FactorFieldDataTypeId.String:
                            speciesFact.MainField.Value = "1";
                            break;

                        default:
                            continue;
                        }
                        changedSpeciesFacts.Add(speciesFact);
                    }
                }
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(speciesFacts, ReferenceManagerTest.GetAReference());

                // Verify that creation of species facts has been done.
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(speciesFacts);
                foreach (Data.ArtDatabankenService.SpeciesFact speciesFact in speciesFacts)
                {
                    if (changedSpeciesFacts.Exists(speciesFact))
                    {
                        Assert.IsTrue(speciesFact.HasId);
                        Assert.IsTrue(speciesFact.HasUpdateDate);
                        Assert.IsTrue(speciesFact.UpdateUserFullName.IsNotEmpty());
                        Assert.AreEqual(1, Int32.Parse(speciesFact.MainField.Value.ToString()));
                    }
                }
            }
            Thread.Sleep(6000);

            // Test update of data.
            using (WebTransaction transaction = new WebTransaction(5))
            {
                // Get species fact.
                changedSpeciesFacts = new Data.ArtDatabankenService.SpeciesFactList();
                foreach (Data.ArtDatabankenService.SpeciesFact speciesFact in GetSomeSpeciesFacts())
                {
                    if (speciesFact.AllowManualUpdate &&
                        speciesFact.HasId)
                    {
                        changedSpeciesFacts.Add(speciesFact);
                        break;
                    }
                }
                changedSpeciesFact = changedSpeciesFacts[0];

                // Test change of reference id.
                oldReferenceId = changedSpeciesFact.Reference.Id;
                oldUpdateUser  = changedSpeciesFact.UpdateUserFullName;
                reference      = Data.ArtDatabankenService.ReferenceManager.GetReferences()[3];
                changedSpeciesFact.Reference = reference;
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts, ReferenceManagerTest.GetAReference());
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts);
                Assert.AreNotEqual(oldReferenceId, changedSpeciesFact.Reference.Id);
                Assert.AreEqual(reference.Id, changedSpeciesFact.Reference.Id);

                // Test change of update date.
                oldUpdateDate = changedSpeciesFact.UpdateDate;
                changedSpeciesFact.Reference = Data.ArtDatabankenService.ReferenceManager.GetReferences()[4];
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts, ReferenceManagerTest.GetAReference());
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts);
                Assert.IsTrue(oldUpdateDate <= changedSpeciesFact.UpdateDate);

                // Test change of update user.
                Assert.AreNotEqual(oldUpdateUser, changedSpeciesFact.UpdateUserFullName);

                // Test change of field values.
                field       = changedSpeciesFact.Field5;
                stringValue = "4232";
                Assert.AreNotEqual(stringValue, field.Value.ToString());
                field.Value = stringValue;
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts, ReferenceManagerTest.GetAReference());
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts);
                Assert.IsTrue(field.HasValue);
                Assert.AreEqual(stringValue, field.Value.ToString());

                // Test change of quality.
                oldQualityId = changedSpeciesFact.Quality.Id;
                changedSpeciesFact.Quality = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactQualities()[5];
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts, ReferenceManagerTest.GetAReference());
                Data.ArtDatabankenService.SpeciesFactManager.UpdateSpeciesFacts(changedSpeciesFacts);
                Assert.AreNotEqual(oldQualityId, changedSpeciesFact.Quality.Id);
                Assert.AreEqual(Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactQualities()[5].Id, changedSpeciesFact.Quality.Id);
            }
        }
 public SpeciesFactListTest()
 {
     _speciesFacts = null;
 }
 public SpeciesInformationDocumentTest()
 {
     _targetSpeciesFacts = null;
     _targetSpeciesInformationDocument = null;
 }