public static WebSpeciesObservationSearchCriteria GetOneWebSearchCriteria()
{
WebSpeciesObservationSearchCriteria searchCriteria;
searchCriteria = new WebSpeciesObservationSearchCriteria();
searchCriteria.TaxonIds = TaxonManagerTest.GetSomeTaxonIds(1);
searchCriteria.UserRoleId = Data.ArtDatabankenService.UserManager.GetUser().Roles[0].Id;
#if DATA_SPECIFIED_EXISTS
searchCriteria.UserRoleIdSpecified = true;
#endif
searchCriteria.IsAccuracySpecified = true;
#if DATA_SPECIFIED_EXISTS
searchCriteria.IsAccuracySpecifiedSpecified = true;
#endif
searchCriteria.Accuracy = 1000;
#if DATA_SPECIFIED_EXISTS
searchCriteria.AccuracySpecified = true;
#endif
searchCriteria.IsBirdNestActivityLevelSpecified = false;
#if DATA_SPECIFIED_EXISTS
searchCriteria.IsBirdNestActivityLevelSpecifiedSpecified = true;
#endif
searchCriteria.IncludePositiveObservations = true;
#if DATA_SPECIFIED_EXISTS
searchCriteria.IncludePositiveObservationsSpecified = true;
#endif
searchCriteria.IsRectangleSpecified = false;
#if DATA_SPECIFIED_EXISTS
searchCriteria.IsRectangleSpecifiedSpecified = true;
#endif
return(searchCriteria);
}
private ArtDatabanken.Data.ArtDatabankenService.Taxon GetTaxon()
{
if (_taxon.IsNull())
{
_taxon = TaxonManagerTest.GetOneTaxon();
}
return(_taxon);
}
public Data.ArtDatabankenService.TaxonTreeNode GetTaxonTree(Boolean refresh = false)
{
if (_taxonTree.IsNull() || refresh)
{
_taxonTree = TaxonManagerTest.GetHawkBirdsTaxonTree();
}
return(_taxonTree);
}
public void ExpandSpeciesFactListWithEmptySpeciesFactsFactorEmpty()
{
UserParameterSelection userparams = new UserParameterSelection();
userparams.Taxa.Merge(TaxonManagerTest.GetTaxaList());
Assert.IsFalse(userparams.Taxa.IsEmpty());
Data.ArtDatabankenService.SpeciesFactManager.ExpandSpeciesFactListWithEmptySpeciesFacts(userparams, new Data.ArtDatabankenService.SpeciesFactList());
}
private ArtDatabanken.Data.ArtDatabankenService.TaxonNameList GetTaxonNames()
{
if (_taxonNames.IsNull())
{
_taxonNames = TaxonManagerTest.GetSomeTaxonNames();
}
return(_taxonNames);
}
private DataId GetDataId(Boolean refresh)
{
if (_data.IsNull() || refresh)
{
_data = TaxonManagerTest.GetSpeciesTaxonType();
}
return(_data);
}
private Data.ArtDatabankenService.TaxonTreeNodeList GetTaxonTrees()
{
if (_taxonTrees.IsNull())
{
_taxonTrees = TaxonManagerTest.GetHawkBirdsTaxonTree().Children;
}
return(_taxonTrees);
}
public Data.ArtDatabankenService.TaxonTreeNode GetTaxonTreeNode(Boolean refresh)
{
if (_taxonTreeNode.IsNull() || refresh)
{
_taxonTreeNode = TaxonManagerTest.GetBearTaxonTreeNode();
}
return(_taxonTreeNode);
}
private ArtDatabanken.Data.ArtDatabankenService.TaxonList GetTaxa()
{
if (_taxa.IsNull())
{
_taxa = ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxa(TaxonManagerTest.GetTaxaIds(), TaxonInformationType.Basic);
}
return(_taxa);
}
private TaxonName GetTaxonName(Boolean refresh)
{
if (_taxoName.IsNull() || refresh)
{
_taxoName = TaxonManagerTest.GetTaxonName();
}
return(_taxoName);
}
public void AreNotEqual()
{
Assert.IsFalse(DataId.AreNotEqual(null, null));
Assert.IsTrue(DataId.AreNotEqual(GetDataId(), null));
Assert.IsTrue(DataId.AreNotEqual(null, GetDataId()));
Assert.IsTrue(DataId.AreNotEqual(GetDataId(), TaxonManagerTest.GetOneTaxon()));
Assert.IsFalse(DataId.AreNotEqual(GetDataId(), GetDataId()));
Assert.IsTrue(DataId.AreNotEqual(GetDataId(), ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxonTypes()[2]));
}
public static Data.ArtDatabankenService.SpeciesObservationSearchCriteria GetOneSearchCriteria()
{
Data.ArtDatabankenService.SpeciesObservationSearchCriteria searchCriteria;
searchCriteria = new Data.ArtDatabankenService.SpeciesObservationSearchCriteria();
searchCriteria.TaxonIds = TaxonManagerTest.GetSomeTaxonIds(1);
searchCriteria.Accuracy = 1000;
return(searchCriteria);
}
public void Taxa()
{
UserParameterSelection userParameterSelection = GetUserParameterSelection();
Assert.AreEqual(userParameterSelection.Taxa.IsNotEmpty(), userParameterSelection.HasTaxa);
userParameterSelection.Taxa.Merge(TaxonManagerTest.GetTaxaList());
Assert.IsTrue(userParameterSelection.Taxa.IsNotEmpty());
Assert.IsTrue(userParameterSelection.HasTaxa);
}
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);
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private UserDataSet GetUserDataSet()
{
if (_userDataSet.IsNull())
{
_userDataSet = new UserDataSet();
UserParameterSelection userParameterSelection = UserParameterSelectionTest.GetUserParameterSelection();
userParameterSelection.Taxa.Merge(TaxonManagerTest.GetTaxaList());
Data.ArtDatabankenService.FactorList factors = new Data.ArtDatabankenService.FactorList();
factors.Add(ArtDatabanken.Data.ArtDatabankenService.FactorManager.GetFactor(LANDSCAPE_FACTOR_ID));
userParameterSelection.Factors.Merge(factors);
_userDataSet = Data.ArtDatabankenService.SpeciesFactManager.GetUserDataSetByParameterSelection(userParameterSelection);
}
return(_userDataSet);
}
private Data.ArtDatabankenService.SpeciesObservationAreaList GetSpeciesObservationAreas(Boolean refresh)
{
if (_speciesObservationAreas.IsNull() || refresh)
{
_speciesObservationAreas = new Data.ArtDatabankenService.SpeciesObservationAreaList();
foreach (ArtDatabanken.Data.ArtDatabankenService.Taxon taxon in TaxonManagerTest.GetTaxaList())
{
_speciesObservationAreas.Add(new Data.ArtDatabankenService.SpeciesObservationArea(taxon,
543,
2000,
50000,
53450000000,
5435340000000000));
}
}
return(_speciesObservationAreas);
}
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);
}
public void GetUserDataSetByParameterSelection()
{
UserDataSet userDataSet = null, userDataSet2;
UserParameterSelection userParmeterSelection;
userParmeterSelection = new UserParameterSelection();
userParmeterSelection.Taxa.Merge(ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxa(TaxonManagerTest.GetTaxaIds(), TaxonInformationType.Basic));
Data.ArtDatabankenService.FactorList factors;
factors = new Data.ArtDatabankenService.FactorList();
factors.Add(Data.ArtDatabankenService.FactorManager.GetFactor(LANDSCAPE_FACTOR_ID));
userParmeterSelection.Factors.Merge(factors);
userDataSet = Data.ArtDatabankenService.SpeciesFactManager.GetUserDataSetByParameterSelection(userParmeterSelection);
Assert.IsNotNull(userDataSet);
Assert.IsTrue(userDataSet.SpeciesFacts.IsNotEmpty());
Assert.IsTrue(userDataSet.SpeciesFacts.Count > 2);
// Test problem where automatic SpeciesFact is
// added to the UserDataSet but dependent
// SpeicesFact is not in the UserDataSet.
userParmeterSelection = new UserParameterSelection();
userParmeterSelection.Taxa.Add(TaxonManagerTest.GetOneTaxon());
userParmeterSelection.Factors.Add(Data.ArtDatabankenService.FactorManager.GetFactor(Data.ArtDatabankenService.FactorId.RedListCategoryAutomatic));
userDataSet = Data.ArtDatabankenService.SpeciesFactManager.GetUserDataSetByParameterSelection(userParmeterSelection);
Assert.IsTrue(userDataSet.SpeciesFacts.IsNotEmpty());
Assert.IsTrue(userDataSet.Factors.Count > 30);
// Test problem where periodic SpeciesFact are combined
// with none default IndividualCategory.
userParmeterSelection = new UserParameterSelection();
userParmeterSelection.Taxa.Add(TaxonManagerTest.GetOneTaxon());
userParmeterSelection.Factors.Add(Data.ArtDatabankenService.FactorManager.GetFactor(Data.ArtDatabankenService.FactorId.PopulationSize_Total));
userDataSet = Data.ArtDatabankenService.SpeciesFactManager.GetUserDataSetByParameterSelection(userParmeterSelection);
userParmeterSelection.IndividualCategories.Add(IndividualCategoryManager.GetIndividualCategory(INDIVIDUAL_CATEGORY_ID_IMAGO));
userDataSet2 = Data.ArtDatabankenService.SpeciesFactManager.GetUserDataSetByParameterSelection(userParmeterSelection);
Assert.AreEqual(userDataSet.SpeciesFacts.Count, userDataSet2.SpeciesFacts.Count);
}
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);
}
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private TaxonNameType GetTaxonNameType()
{
return(TaxonManagerTest.GetScientificTaxonNameType());
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private TaxonNameUseType GetTaxonNameUseType()
{
return(TaxonManagerTest.GetValidTaxonNameUseType());
}
public static ArtDatabanken.Data.ArtDatabankenService.TaxonList GetTaxaList()
{
return(ArtDatabanken.Data.ArtDatabankenService.TaxonManager.GetTaxa(TaxonManagerTest.GetTaxaIds(), TaxonInformationType.Basic));
}
public void GetSpeciesFactByUserParameterSelection()
{
FactorList factors;
Data.ArtDatabankenService.IndividualCategoryList individualCategories;
Int32 count;
Data.ArtDatabankenService.PeriodList periods;
ReferenceList references;
Data.ArtDatabankenService.SpeciesFactList speciesFacts;
Data.ArtDatabankenService.TaxonList hosts, taxa;
UserParameterSelection userParmeterSelection;
userParmeterSelection = new UserParameterSelection();
factors = FactorManagerTest.GetSomeFactors();
hosts = TaxonManagerTest.GetSomeTaxa();
individualCategories = IndividualCategoryManagerTest.GetSomeIndividualCategories();
periods = PeriodManagerTest.GetSomePeriods();
references = ReferenceManagerTest.GetSomeReferences();
taxa = hosts;
userParmeterSelection.Taxa.Merge(taxa);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
Assert.IsTrue(speciesFacts.IsNotEmpty());
count = speciesFacts.Count;
userParmeterSelection.Factors.Merge(factors);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
if (speciesFacts.IsNotEmpty())
{
Assert.IsTrue(count > speciesFacts.Count);
}
userParmeterSelection.Factors.Clear();
userParmeterSelection.Hosts.Merge(hosts);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
if (speciesFacts.IsNotEmpty())
{
Assert.IsTrue(count > speciesFacts.Count);
}
userParmeterSelection.Hosts.Clear();
userParmeterSelection.IndividualCategories.Merge(individualCategories);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
if (speciesFacts.IsNotEmpty())
{
Assert.IsTrue(count > speciesFacts.Count);
}
userParmeterSelection.IndividualCategories.Clear();
userParmeterSelection.Periods.Merge(periods);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
if (speciesFacts.IsNotEmpty())
{
Assert.IsTrue(count > speciesFacts.Count);
}
userParmeterSelection.Periods.Clear();
userParmeterSelection.References.Merge(references);
speciesFacts = Data.ArtDatabankenService.SpeciesFactManager.GetSpeciesFactsByUserParameterSelection(userParmeterSelection);
if (speciesFacts.IsNotEmpty())
{
Assert.IsTrue(count > speciesFacts.Count);
}
userParmeterSelection.References.Clear();
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private TaxonType GetTaxonType()
{
return(TaxonManagerTest.GetSpeciesTaxonType());
}
private Data.ArtDatabankenService.SpeciesObservationArea GetSpeciesObservationArea(Boolean refresh)
{
if (_speciesObservationArea.IsNull() || refresh)
{
_speciesObservationArea = new Data.ArtDatabankenService.SpeciesObservationArea(TaxonManagerTest.GetOneTaxon(),
543,
2000,
50000,
53450000000,
5435340000000000);
}
return(_speciesObservationArea);
}
