public void CreateDyntaxaRevisionReferenceRelation_WithValidData_ThenDyntaxaRevisionReferenceRelationIsCreated()
{
// Arrange
const string relatedObjectGUID = "urn:lsid:dyntaxa.se:Taxon:6010174";
const string action = "Add";
const int revisionId = 1;
WebDyntaxaRevisionReferenceRelation dyntaxaReferenceRelation, newDyntaxaReferenceRelation;
dyntaxaReferenceRelation = WebDyntaxaRevisionReferenceRelationTestFactory.Create(
revisionId, relatedObjectGUID, action);
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
// Create test Dyntaxa revision reference relation.
dyntaxaReferenceRelation.ReferenceId = 3342;
newDyntaxaReferenceRelation = WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(
GetClientInformation(),
dyntaxaReferenceRelation);
// Assert
Assert.IsNotNull(newDyntaxaReferenceRelation);
Assert.AreNotEqual(dyntaxaReferenceRelation.Id, newDyntaxaReferenceRelation.Id);
Assert.AreEqual(dyntaxaReferenceRelation.RelatedObjectGUID,
newDyntaxaReferenceRelation.RelatedObjectGUID);
Assert.AreEqual(3342, newDyntaxaReferenceRelation.ReferenceId);
}
}
public void GetDyntaxaRevisionReferenceRelationById_WhenDyntaxaRevisionReferenceRelationCreated_ThenCreatedRevisionReferenceRelationIsReturned()
{
// Arrange
const int revisionId = 24;
const string relatedObjectGUID = "urn:lsid:dyntaxa.se:Taxon:6010174";
const string action = "Add";
const int referenceId = 252;
WebDyntaxaRevisionReferenceRelation dyntaxaReferenceRelation = WebDyntaxaRevisionReferenceRelationTestFactory.Create(
revisionId, relatedObjectGUID, action);
dyntaxaReferenceRelation.ReferenceId = referenceId;
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
var newReferenceRelations = WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(
GetClientInformation(), dyntaxaReferenceRelation);
WebDyntaxaRevisionReferenceRelation getReferenceRelations = WebServiceProxy.DyntaxaInternalService
.GetDyntaxaRevisionReferenceRelationById(
GetClientInformation(), newReferenceRelations.Id);
// Assert
Assert.IsNotNull(getReferenceRelations);
Assert.AreEqual(relatedObjectGUID, getReferenceRelations.RelatedObjectGUID);
Assert.AreEqual(action, getReferenceRelations.Action);
Assert.AreEqual(referenceId, getReferenceRelations.ReferenceId);
}
}
public void GetDyntaxaRevisionReferenceRelation_WhenTwoReferenceRelationWithSameRelatedObjectGUIDExists_ThenTwoReferenceRelationIsReturned()
{
// Arrange
const int revisionId = 24;
const string relatedObjectGUID = "urn:lsid:dyntaxa.se:Taxon:6010174";
const string rel1Action = "Add";
const string rel2Action = "Delete";
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(
GetClientInformation(),
WebDyntaxaRevisionReferenceRelationTestFactory.Create(revisionId, relatedObjectGUID, rel1Action));
WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(
GetClientInformation(),
WebDyntaxaRevisionReferenceRelationTestFactory.Create(revisionId, relatedObjectGUID, rel2Action));
var newReferenceRelations = WebServiceProxy.DyntaxaInternalService.GetDyntaxaRevisionReferenceRelation(
GetClientInformation(), revisionId, relatedObjectGUID);
// Assert
Assert.IsNotNull(newReferenceRelations);
Assert.AreEqual(2, newReferenceRelations.Count);
Assert.AreEqual(rel1Action, newReferenceRelations[0].Action);
Assert.AreEqual(rel2Action, newReferenceRelations[1].Action);
}
}
public void CreatePictureRelations()
{
Boolean isRecommended = false;
String objectGuid = "226679";
Int64 pictureId = 33;
Int32 typeId = 3;
List <WebPictureRelation> pictureRelations = new List <WebPictureRelation>
{
new WebPictureRelation
{
IsRecommended = isRecommended,
ObjectGuid = objectGuid,
PictureId = pictureId,
SortOrder = 2,
TypeId = typeId
},
};
List <WebPictureRelation> newPictureRelations;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
WebServiceProxy.PictureService.CreatePictureRelations(GetClientInformation(),
pictureRelations);
newPictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByPictureId(GetClientInformation(),
pictureId);
Assert.IsNotNull(newPictureRelations);
Assert.IsTrue(newPictureRelations.IsNotEmpty());
}
}
public void CreateTaxon()
{
WebTaxon taxon, refTaxon, taxon2;
refTaxon = GetReferenceTaxon();
taxon = new WebTaxon {
CreatedBy = Settings.Default.TestUserId,
ValidFromDate = new DateTime(1763, 02, 08),
ValidToDate = new DateTime(2447, 08, 01)
};
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonService))
{
// We now create the taxon and complete it with Id and GUID from DB
refTaxon = WebServiceProxy.TaxonService.CreateTaxon(GetClientInformation(), refTaxon, null);
// We now create the taxon and complete it with Id and GUID from DB
taxon = WebServiceProxy.TaxonService.CreateTaxon(GetClientInformation(), taxon, null);
Assert.IsNotNull(taxon);
Assert.IsTrue(taxon.Id > 0);
Assert.AreEqual(refTaxon.CreatedBy, taxon.CreatedBy);
Assert.IsNotNull(taxon.CreatedDate);
Assert.IsTrue(!string.IsNullOrEmpty(taxon.Guid));
Assert.AreEqual(refTaxon.ValidFromDate, taxon.ValidFromDate);
Assert.AreEqual(refTaxon.ValidToDate, taxon.ValidToDate);
}
// Create another taxon with different data..TODO Include test for ParentTaxa, ChildTaxa and TaxonNames when they exsit...
taxon2 = new WebTaxon()
{
CreatedBy = Settings.Default.TestUserId,
CreatedDate = DateTime.Now,
ValidFromDate = new DateTime(1763, 02, 08),
ValidToDate = new DateTime(2447, 08, 01)
};
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonService))
{
// We now create the taxon and complete it with Id and GUID from DB
WebTaxonName taxonName = GetReferenceTaxonName(taxon.Id);
WebTaxonName taxonName2 = GetReferenceTaxonName(taxon.Id);
List <WebTaxonName> taxonNameList = new List <WebTaxonName>();
taxonNameList.Add(taxonName);
taxonNameList.Add(taxonName2);
// taxon2.TaxonNames = taxonNameList;
taxon2 = WebServiceProxy.TaxonService.CreateTaxon(GetClientInformation(), taxon2, null);
Assert.IsNotNull(taxon2);
Assert.IsTrue(taxon2.Id > 0);
Assert.IsFalse(taxon.Id == taxon2.Id);
Assert.AreEqual(refTaxon.CreatedBy, taxon2.CreatedBy);
Assert.IsNotNull(taxon2.CreatedDate);
Assert.IsTrue(!string.IsNullOrEmpty(taxon2.Guid));
Assert.AreEqual(refTaxon.ValidFromDate, taxon2.ValidFromDate);
Assert.AreEqual(refTaxon.ValidToDate, taxon2.ValidToDate);
}
}
public void UpdatePictureMetaData()
{
Int64 pictureId = 33;
List <WebPictureMetaData> oldPictureMetaData = WebServiceProxy.PictureService.GetPictureMetaDataById(GetClientInformation(), pictureId, null);
List <WebPictureMetaData> updatePictureMetaData = new List <WebPictureMetaData>
{
new WebPictureMetaData
{
HasPictureMetaDataId = true,
PictureMetaDataId = 1,
Value = "Test (C)"
},
new WebPictureMetaData
{
HasPictureMetaDataId = true,
PictureMetaDataId = 2,
Value = "Test Author"
}
};
String updatedBy = "test test";
Int32 affectedRows;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
affectedRows = WebServiceProxy.PictureService.UpdatePictureMetaData(GetClientInformation(), pictureId, updatedBy, updatePictureMetaData);
Assert.IsTrue((affectedRows > 0) && (affectedRows == updatePictureMetaData.Count + 1)); // + 1: updatedBy.
affectedRows = WebServiceProxy.PictureService.UpdatePictureMetaData(GetClientInformation(), pictureId, updatedBy, oldPictureMetaData);
Assert.IsTrue((affectedRows > 0) && (affectedRows == oldPictureMetaData.Count + 1)); // + 1: updatedBy.
}
}
public void CreateSpeciesFacts()
{
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
List <WebSpeciesFact> inSpeciesFacts;
// Create species facts.
inSpeciesFacts = new List <WebSpeciesFact>
{
new WebSpeciesFact
{
FactorId = 34,
HostId = 23,
IndividualCategoryId = 3,
PeriodId = 2,
TaxonId = 345
},
new WebSpeciesFact
{
FactorId = 57,
HostId = 34,
IndividualCategoryId = 1,
PeriodId = 3,
TaxonId = 678
}
};
WebServiceProxy.TaxonAttributeService.CreateSpeciesFacts(GetClientInformation(), inSpeciesFacts);
}
}
public void GetPictureMetaDataDescriptionsByIds()
{
List <Int32> metaDataIds = new List <int> {
2, 4
};
List <WebPictureMetaDataDescription> pictureMetaDataDescriptions;
WebLocale locale = new WebLocale();
WebClientInformation clientInformation = GetClientInformation();
locale.Id = 49; // English
clientInformation.Locale = locale;
using (IWebServiceTransaction transaction = new WebServiceTransaction(clientInformation, WebServiceProxy.PictureService))
{
pictureMetaDataDescriptions = WebServiceProxy.PictureService.GetPictureMetaDataDescriptionsByIds(clientInformation, metaDataIds);
Assert.IsTrue(pictureMetaDataDescriptions.IsNotEmpty());
}
pictureMetaDataDescriptions = WebServiceProxy.PictureService.GetPictureMetaDataDescriptionsByIds(clientInformation, metaDataIds);
Assert.IsTrue(pictureMetaDataDescriptions.IsNotEmpty());
locale.Id = 175; // Swedish
clientInformation.Locale = locale;
using (IWebServiceTransaction transaction = new WebServiceTransaction(clientInformation, WebServiceProxy.PictureService))
{
pictureMetaDataDescriptions = WebServiceProxy.PictureService.GetPictureMetaDataDescriptionsByIds(clientInformation, metaDataIds);
Assert.IsTrue(pictureMetaDataDescriptions.IsNotEmpty());
}
pictureMetaDataDescriptions = WebServiceProxy.PictureService.GetPictureMetaDataDescriptionsByIds(clientInformation, metaDataIds);
Assert.IsTrue(pictureMetaDataDescriptions.IsNotEmpty());
}
public void CreateSpeciesFact_WithSpeciesFactStatusNullData_ThenDyntaxaRevisionSpeciesFactCreated()
{
Int32 revisionId = 1;
WebDyntaxaRevisionSpeciesFact speciesFact = GetReferenceDyntaxaRevisionSpeciesFact((Int32)TaxonId.Bear);
speciesFact.FactorId = (Int32)FactorId.SwedishHistory;
speciesFact.RevisionId = revisionId;
speciesFact.IsPublished = false;
speciesFact.StatusId = null;
speciesFact.ReferenceId = null;
speciesFact.QualityId = null;
speciesFact.SpeciesFactExists = true;
speciesFact.Description = null;
speciesFact.OriginalStatusId = 2;
speciesFact.OriginalQualityId = 3;
speciesFact.OriginalReferenceId = 4;
speciesFact.OriginalDescription = "test test";
WebTaxonRevisionEvent revisionEvent;
revisionEvent = new WebTaxonRevisionEvent()
{
CreatedBy = 2,
CreatedDate = DateTime.Now,
TypeId = 1,
RevisionId = revisionId,
AffectedTaxa = "Bear",
OldValue = "StatusId=Unknown",
NewValue = "StatusId=400"
};
//using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.DyntaxaInternalService))
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
// We now create revision event.
WebTaxonRevisionEvent createdRevisionEvent = WebServiceProxy.DyntaxaInternalService.CreateCompleteRevisionEvent(GetClientInformation(), revisionEvent);
speciesFact.RevisionEventId = createdRevisionEvent.Id;
// We now create the revision species fact.
speciesFact = WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionSpeciesFact(GetClientInformation(), speciesFact);
var currentDyntaxaRevisionSpeciesFact = WebServiceProxy.DyntaxaInternalService.GetDyntaxaRevisionSpeciesFact(
GetClientInformation(), (Int32)FactorId.SwedishHistory, (Int32)TaxonId.Bear, revisionId);
// Assert first Insert.
Assert.AreEqual(createdRevisionEvent.Id, speciesFact.RevisionEventId);
Assert.IsFalse(currentDyntaxaRevisionSpeciesFact.IsChangedInRevisionEventIdSpecified);
Assert.IsNull(currentDyntaxaRevisionSpeciesFact.StatusId);
Assert.IsNull(currentDyntaxaRevisionSpeciesFact.ReferenceId);
Assert.IsNull(currentDyntaxaRevisionSpeciesFact.QualityId);
Assert.IsNull(currentDyntaxaRevisionSpeciesFact.Description);
Assert.AreEqual(speciesFact.StatusId, currentDyntaxaRevisionSpeciesFact.StatusId);
Assert.IsTrue(currentDyntaxaRevisionSpeciesFact.SpeciesFactExists);
Assert.AreEqual(2, speciesFact.OriginalStatusId);
Assert.AreEqual(3, speciesFact.OriginalQualityId);
Assert.AreEqual(4, speciesFact.OriginalReferenceId);
Assert.AreEqual("test test", speciesFact.OriginalDescription);
}
}
public void GetTaxonCategoriesForTaxonInTree()
{
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonService))
{
/* TODO This test is to be used when relation between taxon and taxoncategory is implemented....
* // Create taxa in a tree first
* List<WebTaxon> taxa = new List<WebTaxon>();
* WebTaxon lastTaxon = GetReferenceTaxon("Root taxon");
* //Here is my root taxon
* lastTaxon = ArtDatabanken.WebService.TaxonService.Data.TaxonManager.CreateTaxon(GetContext(), lastTaxon);
* for (int i = 0; i < 10; i++)
* {
* // Create a taxon and set its parents
* WebTaxon taxon = GetReferenceTaxon("Child taxon 1");
* //Create the relation and set it to child taxon
* WebTaxonRelation taxonRelation = new WebTaxonRelation() { Id = 77 + i, RelatedTaxon = lastTaxon};
* List<WebTaxonRelation> parentTaxonRelation = new List<WebTaxonRelation>();
* parentTaxonRelation.Add(taxonRelation);
* taxon.ParentTaxa = parentTaxonRelation;
* // Create category for taxon
* WebTaxonCategory refTaxonCategory = GetReferenceTaxonCategory(i);
* refTaxonCategory = ArtDatabanken.WebService.TaxonService.Data.TaxonManager.CreateTaxonCategory(GetContext(), refTaxonCategory);
* taxon.TaxonCategories = refTaxonCategory;
* }*/
// For the time beeing we are testing on existing taxon...
// Arrange
int taxonId = 100049; // Detta är en spillkråka...
// Act
List <WebTaxonCategory> categoryList = WebServiceProxy.TaxonService.GetTaxonCategoriesByTaxonId(GetClientInformation(), taxonId);
// Assert
Assert.IsNotNull(categoryList);
Assert.AreEqual(categoryList[0].Name, "Rike");
//Root category
Assert.AreEqual(categoryList[0].ParentId, 0);
Assert.AreEqual(categoryList[1].Name, "Stam");
Assert.AreEqual(categoryList[2].Name, "Understam");
Assert.AreEqual(categoryList[3].Name, "Klass");
Assert.AreEqual(categoryList[4].Name, "Ordning");
Assert.AreEqual(categoryList[5].Name, "Familj");
//spillkråkans släkte
Assert.AreEqual(categoryList[6].ParentId, 11);
Assert.AreEqual(categoryList[6].Name, "Släkte");
Assert.AreEqual(categoryList[6].Id, 14);
Assert.AreEqual(categoryList[6].SortOrder, 33);
// Detta är en spillkråka...
Assert.AreEqual(categoryList[7].ParentId, 14);
Assert.AreEqual(categoryList[7].Name, "Art");
Assert.AreEqual(categoryList[7].Id, 17);
Assert.AreEqual(categoryList[7].SortOrder, 42);
// det finns en underart till denna ...
Assert.AreEqual(categoryList[8].Name, "Underart");
}
}
public void CreateDeletePictureFilename()
{
Int64 pictureId = 33;
List <WebPictureMetaData> pictureMetaData = new List <WebPictureMetaData>
{
new WebPictureMetaData
{
PictureMetaDataId = 1,
HasPictureMetaDataId = true,
Value = "(C) Test 2014"
},
new WebPictureMetaData
{
PictureMetaDataId = 2,
HasPictureMetaDataId = true,
Value = "Test Author"
},
new WebPictureMetaData
{
PictureMetaDataId = 3,
HasPictureMetaDataId = true,
Value = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss")
}
};
WebPicture picture = WebServiceProxy.PictureService.GetPictureById(GetClientInformation(), pictureId, null, null, 0, false, string.Empty);
String filename = @"\Temp\JN_Leiobunum-blackwalli_226679_Hane_new.jpg";
Int32 affectedRows;
DateTime lastModified = DateTime.Now;
List <Int32> pictureMetaDataIds = new List <int> {
1, 2, 3
};
String updatedBy = "test test";
List <WebPictureMetaData> newPictureMetaData;
WebPictureResponse webPictureResponse;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
webPictureResponse = WebServiceProxy.PictureService.CreatePictureFilename(GetClientInformation(), picture.Image, filename, lastModified, true, picture.VersionId + 1, updatedBy, pictureMetaData);
Assert.AreEqual(webPictureResponse.AffectedRows, 1);
Assert.IsTrue(webPictureResponse.Id > 0);
newPictureMetaData = WebServiceProxy.PictureService.GetPictureMetaDataById(GetClientInformation(), webPictureResponse.Id, pictureMetaDataIds);
Assert.IsNotNull(newPictureMetaData);
Assert.IsTrue(newPictureMetaData.IsNotEmpty());
Assert.AreEqual(pictureMetaData.Count, newPictureMetaData.Count);
for (int i = 0; i < newPictureMetaData.Count; i++)
{
Assert.AreEqual(pictureMetaData[i].PictureMetaDataId, newPictureMetaData[i].PictureMetaDataId);
Assert.AreEqual(pictureMetaData[i].Value, newPictureMetaData[i].Value);
}
affectedRows = WebServiceProxy.PictureService.DeletePictureMetaData(GetClientInformation(), webPictureResponse.Id, pictureMetaData);
Assert.AreEqual(affectedRows, pictureMetaData.Count);
affectedRows = WebServiceProxy.PictureService.DeletePictureFilename(GetClientInformation(), null, filename, picture.PictureStringId);
Assert.AreEqual(affectedRows, 4);
}
}
public void GetTaxonNamesByTaxonId()
{
Int32 taxonId = Settings.Default.TestTaxonId;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonService))
{
var taxonNames = WebServiceProxy.TaxonService.GetTaxonNamesByTaxonId(GetClientInformation(), taxonId);
Assert.IsNotNull(taxonNames);
Assert.IsTrue(taxonNames.Count > 0);
}
}
public void TestSetRevisionReferenceRelationPublished()
{
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
var result = WebServiceProxy.DyntaxaInternalService.SetRevisionReferenceRelationPublished(GetClientInformation(), 24);
// Assert
Assert.AreEqual(true, result);
}
}
public void GetPeriods()
{
List <WebPeriod> periods;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
periods = WebServiceProxy.TaxonAttributeService.GetPeriods(GetClientInformation());
Assert.IsTrue(periods.IsNotEmpty());
}
periods = WebServiceProxy.TaxonAttributeService.GetPeriods(GetClientInformation());
Assert.IsTrue(periods.IsNotEmpty());
}
public void GetSpeciesFactQualities()
{
List <WebSpeciesFactQuality> speciesFactQualities;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
speciesFactQualities = WebServiceProxy.TaxonAttributeService.GetSpeciesFactQualities(GetClientInformation());
Assert.IsTrue(speciesFactQualities.IsNotEmpty());
}
speciesFactQualities = WebServiceProxy.TaxonAttributeService.GetSpeciesFactQualities(GetClientInformation());
Assert.IsTrue(speciesFactQualities.IsNotEmpty());
}
public void GetPictureRelationTypes()
{
List <WebPictureRelationType> pictureRelationTypes;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
pictureRelationTypes = WebServiceProxy.PictureService.GetPictureRelationTypes(GetClientInformation());
Assert.IsTrue(pictureRelationTypes.IsNotEmpty());
}
pictureRelationTypes = WebServiceProxy.PictureService.GetPictureRelationTypes(GetClientInformation());
Assert.IsTrue(pictureRelationTypes.IsNotEmpty());
}
public void GetIndividualCategories()
{
List <WebIndividualCategory> individualCategories;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
individualCategories = WebServiceProxy.TaxonAttributeService.GetIndividualCategories(GetClientInformation());
Assert.IsTrue(individualCategories.IsNotEmpty());
}
individualCategories = WebServiceProxy.TaxonAttributeService.GetIndividualCategories(GetClientInformation());
Assert.IsTrue(individualCategories.IsNotEmpty());
}
public void GetFactorOrigins()
{
List <WebFactorOrigin> factorOrigins;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
factorOrigins = WebServiceProxy.TaxonAttributeService.GetFactorOrigins(GetClientInformation());
Assert.IsTrue(factorOrigins.IsNotEmpty());
}
factorOrigins = WebServiceProxy.TaxonAttributeService.GetFactorOrigins(GetClientInformation());
Assert.IsTrue(factorOrigins.IsNotEmpty());
}
public void GetSpeciesFactsByIds()
{
List <WebSpeciesFact> speciesFacts;
List <int> speciesFactIds = new List <int> {
1, 2
};
bool speciesFactFound;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
speciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
Assert.IsTrue(speciesFacts.IsNotEmpty());
Assert.AreEqual(speciesFacts.Count, speciesFactIds.Count);
foreach (WebSpeciesFact speciesFact in speciesFacts)
{
Assert.IsNotNull(speciesFact.TaxonId);
speciesFactFound = false;
foreach (int speciesFactId in speciesFactIds)
{
if (speciesFactId == speciesFact.Id)
{
speciesFactFound = true;
break;
}
}
Assert.IsTrue(speciesFactFound);
}
}
speciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
Assert.IsTrue(speciesFacts.IsNotEmpty());
Assert.AreEqual(speciesFacts.Count, speciesFactIds.Count);
foreach (WebSpeciesFact speciesFact in speciesFacts)
{
Assert.IsNotNull(speciesFact.TaxonId);
speciesFactFound = false;
foreach (int speciesFactId in speciesFactIds)
{
if (speciesFactId == speciesFact.Id)
{
speciesFactFound = true;
break;
}
}
Assert.IsTrue(speciesFactFound);
}
}
public void GetPictureRelationsByPictureId()
{
Int64 pictureId;
List <WebPictureRelation> pictureRelations;
pictureId = 2;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
pictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByPictureId(GetClientInformation(), pictureId);
Assert.IsTrue(pictureRelations.IsNotEmpty());
}
pictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByPictureId(GetClientInformation(), pictureId);
Assert.IsTrue(pictureRelations.IsNotEmpty());
}
public void UpdatePictureRelations()
{
Boolean pictureRelationFound;
WebPictureRelation pictureRelation = new WebPictureRelation
{
Id = 1,
IsRecommended = false,
ObjectGuid = "1",
PictureId = 1,
SortOrder = 2,
TypeId = 3
};
List <WebPictureRelation> pictureRelations = new List <WebPictureRelation> {
pictureRelation
};
Int32 affectedRows;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
affectedRows = WebServiceProxy.PictureService.UpdatePictureRelations(GetClientInformation(),
pictureRelations);
Assert.IsTrue((affectedRows > 0) && (affectedRows == pictureRelations.Count));
List <WebPictureRelation> updatedPictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByPictureId(GetClientInformation(),
pictureRelation.PictureId);
Assert.IsNotNull(updatedPictureRelations);
Assert.IsTrue(updatedPictureRelations.IsNotEmpty());
pictureRelationFound = false;
foreach (WebPictureRelation updatedPictureRelation in updatedPictureRelations)
{
if (pictureRelation.Id == updatedPictureRelation.Id)
{
Assert.AreEqual(pictureRelation.Id, updatedPictureRelation.Id);
Assert.AreEqual(pictureRelation.IsRecommended, updatedPictureRelation.IsRecommended);
Assert.AreEqual(pictureRelation.ObjectGuid, updatedPictureRelation.ObjectGuid);
Assert.AreEqual(pictureRelation.PictureId, updatedPictureRelation.PictureId);
Assert.AreEqual(pictureRelation.SortOrder, updatedPictureRelation.SortOrder);
Assert.AreEqual(pictureRelation.TypeId, updatedPictureRelation.TypeId);
pictureRelationFound = true;
}
}
Assert.IsTrue(pictureRelationFound);
}
}
public void GetPictureRelationsByObjectGuid()
{
Int32 pictureRelationTypeId;
List <WebPictureRelation> pictureRelations;
String objectGuid;
objectGuid = "2581";
pictureRelationTypeId = 1;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
pictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByObjectGuid(GetClientInformation(), objectGuid, pictureRelationTypeId);
Assert.IsTrue(pictureRelations.IsNotEmpty());
}
pictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByObjectGuid(GetClientInformation(), objectGuid, pictureRelationTypeId);
Assert.IsTrue(pictureRelations.IsNotEmpty());
}
public void UpdateSpeciesFacts()
{
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
List <WebSpeciesFact> inSpeciesFacts, outSpeciesFacts;
// Create species facts.
inSpeciesFacts = new List <WebSpeciesFact>
{
new WebSpeciesFact
{
FactorId = 34,
HostId = 23,
IndividualCategoryId = 3,
PeriodId = 2,
TaxonId = 345
},
new WebSpeciesFact
{
FactorId = 57,
HostId = 34,
IndividualCategoryId = 1,
PeriodId = 3,
TaxonId = 678
}
};
WebServiceProxy.TaxonAttributeService.CreateSpeciesFacts(GetClientInformation(), inSpeciesFacts);
// Update species facts.
List <int> speciesFactIds = new List <int> {
1, 2
};
inSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
WebServiceProxy.TaxonAttributeService.UpdateSpeciesFacts(GetClientInformation(), inSpeciesFacts);
outSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
foreach (WebSpeciesFact speciesFact in outSpeciesFacts)
{
Assert.AreEqual(speciesFact.ModifiedBy, "TestFirstName TestLastName");
}
// Delete species facts.
WebServiceProxy.TaxonAttributeService.DeleteSpeciesFacts(GetClientInformation(), outSpeciesFacts);
}
}
public void DeletePictureRelations()
{
List <Int64> pictureRelationIds = new List <Int64> {
1, 16
};
Int32 affectedRows;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.PictureService))
{
affectedRows = WebServiceProxy.PictureService.DeletePictureRelations(GetClientInformation(),
pictureRelationIds);
Assert.IsTrue((affectedRows > 0) && (affectedRows == pictureRelationIds.Count));
List <WebPictureRelation> deletedPictureRelations = WebServiceProxy.PictureService.GetPictureRelationsByPictureId(GetClientInformation(), 1);
Assert.IsTrue(deletedPictureRelations.IsEmpty());
}
}
public void GetSpeciesFactsByIdentifiers()
{
List <WebSpeciesFact> inSpeciesFacts, outSpeciesFacts;
List <int> speciesFactIds = new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
};
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
inSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
outSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIdentifiers(GetClientInformation(), inSpeciesFacts);
Assert.AreEqual(inSpeciesFacts.Count, outSpeciesFacts.Count);
}
inSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIds(GetClientInformation(), speciesFactIds);
outSpeciesFacts = WebServiceProxy.TaxonAttributeService.GetSpeciesFactsByIdentifiers(GetClientInformation(), inSpeciesFacts);
Assert.AreEqual(inSpeciesFacts.Count, outSpeciesFacts.Count);
}
public void GetFactorDataTypes()
{
List <WebFactorDataType> factorDataTypes;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
factorDataTypes = WebServiceProxy.TaxonAttributeService.GetFactorDataTypes(GetClientInformation());
Assert.IsTrue(factorDataTypes.IsNotEmpty());
foreach (WebFactorDataType factorDataType in factorDataTypes)
{
Assert.IsTrue(factorDataType.Fields.IsNotEmpty());
}
}
factorDataTypes = WebServiceProxy.TaxonAttributeService.GetFactorDataTypes(GetClientInformation());
Assert.IsTrue(factorDataTypes.IsNotEmpty());
foreach (WebFactorDataType factorDataType in factorDataTypes)
{
Assert.IsTrue(factorDataType.Fields.IsNotEmpty());
}
}
public void GetAllDyntaxaRevisionReferenceRelations_WhenReferenceRelationExists_ThenReferenceRelationIsReturned()
{
//Arrange
List <WebDyntaxaRevisionReferenceRelation> referenceRelations;
const int revisionId = 24;
const string relatedObjectGUID = "urn:lsid:dyntaxa.se:Taxon:6010174";
const string action = "Add";
var dyntaxaReferenceRelation = WebDyntaxaRevisionReferenceRelationTestFactory.Create(
revisionId, relatedObjectGUID, action);
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(GetClientInformation(), dyntaxaReferenceRelation);
referenceRelations = WebServiceProxy.DyntaxaInternalService.GetAllDyntaxaRevisionReferenceRelations(
GetClientInformation(), revisionId);
// Assert
Assert.AreEqual(1, referenceRelations.Count);
}
}
public void GetFactorFieldEnums()
{
List <WebFactorFieldEnum> factorFieldEnums;
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.TaxonAttributeService))
{
factorFieldEnums = WebServiceProxy.TaxonAttributeService.GetFactorFieldEnums(GetClientInformation());
Assert.IsTrue(factorFieldEnums.IsNotEmpty());
foreach (WebFactorFieldEnum factorFieldEnum in factorFieldEnums)
{
Assert.IsTrue(factorFieldEnum.Values.IsNotEmpty());
}
}
factorFieldEnums = WebServiceProxy.TaxonAttributeService.GetFactorFieldEnums(GetClientInformation());
Assert.IsTrue(factorFieldEnums.IsNotEmpty());
foreach (WebFactorFieldEnum factorFieldEnum in factorFieldEnums)
{
Assert.IsTrue(factorFieldEnum.Values.IsNotEmpty());
}
}
public void GetDyntaxaRevisionReferenceRelation_WhenWrongRevisionId_ThenEmptyListIsReturned()
{
// Arrange
const int revisionId = 24;
const int wrongRevisionId = 25;
const string relatedObjectGUID = "urn:lsid:dyntaxa.se:Taxon:6010174";
const string action = "Add";
var dyntaxaReferenceRelation = WebDyntaxaRevisionReferenceRelationTestFactory.Create(
revisionId, relatedObjectGUID, action);
// Act
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionReferenceRelation(GetClientInformation(), dyntaxaReferenceRelation);
var newReferenceRelations = WebServiceProxy.DyntaxaInternalService.GetDyntaxaRevisionReferenceRelation(
GetClientInformation(), wrongRevisionId, relatedObjectGUID);
// Assert
Assert.IsNotNull(newReferenceRelations);
Assert.AreEqual(0, newReferenceRelations.Count);
}
}
public void GetAllDyntaxaRevisionSpeciesFacts_WhenOneRevisionSpeciesFactIsCreated_ThenOneChangedRevisionSpeciesFactIsReturned()
{
WebDyntaxaRevisionSpeciesFact dyntaxaRevisionSpeciesFact1;
WebTaxonRevisionEvent revisionEvent1;
Int32 revisionId = 1;
//-------------------------------------------------------------------
// Create first dyntaxa revision species fact and revision event.
dyntaxaRevisionSpeciesFact1 = GetReferenceDyntaxaRevisionSpeciesFact((Int32)TaxonId.Bear);
dyntaxaRevisionSpeciesFact1.FactorId = (Int32)FactorId.SwedishHistory;
dyntaxaRevisionSpeciesFact1.RevisionId = revisionId;
dyntaxaRevisionSpeciesFact1.IsPublished = false;
dyntaxaRevisionSpeciesFact1.StatusId = 400;
revisionEvent1 = new WebTaxonRevisionEvent()
{
CreatedBy = 2,
CreatedDate = DateTime.Now,
TypeId = 1,
RevisionId = revisionId,
AffectedTaxa = "Bear",
OldValue = "StatusId=Unknown",
NewValue = "StatusId=400"
};
//using (IWebServiceTransaction transaction = new WebServiceTransaction(GetClientInformation(), WebServiceProxy.DyntaxaInternalService))
using (IWebServiceTransaction transaction = new WebServiceTransaction(GetRevisionClientInformation(), WebServiceProxy.TaxonService))
{
revisionEvent1 = WebServiceProxy.DyntaxaInternalService.CreateCompleteRevisionEvent(GetClientInformation(), revisionEvent1);
dyntaxaRevisionSpeciesFact1.RevisionEventId = revisionEvent1.Id;
dyntaxaRevisionSpeciesFact1 = WebServiceProxy.DyntaxaInternalService.CreateDyntaxaRevisionSpeciesFact(GetClientInformation(),
dyntaxaRevisionSpeciesFact1);
var currentDyntaxaRevisionSpeciesFacts = WebServiceProxy.DyntaxaInternalService.GetAllDyntaxaRevisionSpeciesFacts(
GetClientInformation(), revisionId);
//Assert first Insert
Assert.AreEqual(1, currentDyntaxaRevisionSpeciesFacts.Count);
}
}
