public async Task Serialize_relationship_with_self_link_and_related_link()
{
var mockSelfLink = new Mock <ILink>(MockBehavior.Strict);
var mockRelatedLink = new Mock <ILink>(MockBehavior.Strict);
var mockLinkFormatter = new Mock <ILinkFormatter>(MockBehavior.Strict);
mockLinkFormatter
.Setup(s => s.Serialize(mockSelfLink.Object, It.IsAny <JsonWriter>()))
.Returns((ILink metadata, JsonWriter writer) =>
{
writer.WriteValue("some self link");
return(Task.FromResult(0));
}).Verifiable();
mockLinkFormatter
.Setup(s => s.Serialize(mockRelatedLink.Object, It.IsAny <JsonWriter>()))
.Returns((ILink metadata, JsonWriter writer) =>
{
writer.WriteValue("some related link");
return(Task.FromResult(0));
}).Verifiable();
var formatter = new RelationshipObjectFormatter(mockLinkFormatter.Object, null, null);
IRelationshipObject resourceObject = new RelationshipObject(mockSelfLink.Object, mockRelatedLink.Object);
await AssertSerializeOutput(formatter, resourceObject, "Json/Fixtures/RelationshipObjectFormatter/Serialize_relationship_with_self_link_and_related_link.json");
mockLinkFormatter.Verify(s => s.Serialize(mockSelfLink.Object, It.IsAny <JsonWriter>()), Times.Once);
mockLinkFormatter.Verify(s => s.Serialize(mockRelatedLink.Object, It.IsAny <JsonWriter>()), Times.Once);
}
public void testRelationshipsPagination()
{
string typeId = getAndAssertBaseRelationshipTypeId();
RelationshipObject relationship = createAndAssertRelationship(typeId, getAndAssertRootFolder(), false, false, true);
RelationshipsSearcher searcher = new RelationshipsSearcher(getAndAssertRelationshipSourceTypeId(), getAndAssertRelationshipTargetTypeId());
cmisTypeContainer[] descendants = getAndAssertTypeDescendants(typeId, -1, false);
enumerateAndAssertTypesForAction(descendants, searcher, false);
// TODO: resolve several relationships creation for one pair of source and target objects
}
public static RelationshipObjectViewModel MapDbModelToViewModel(RelationshipObject dbModel)
{
var viewModel = new RelationshipObjectViewModel();
viewModel.ID = dbModel.ID;
viewModel.RelationshipMetaID = dbModel.RelationshipMetaID;
viewModel.PkAOMFieldObjectID = dbModel.PkAOMFieldObjectID;
viewModel.FkAOMFieldObjectID = dbModel.FkAOMFieldObjectID;
return(viewModel);
}
public async Task Serialize_relationship_with_all_possible_members()
{
var mockSelfLink = new Mock <ILink>(MockBehavior.Strict);
var mockRelatedLink = new Mock <ILink>(MockBehavior.Strict);
var mockLinkFormatter = new Mock <ILinkFormatter>(MockBehavior.Strict);
mockLinkFormatter
.Setup(s => s.Serialize(mockSelfLink.Object, It.IsAny <JsonWriter>()))
.Returns((ILink metadata, JsonWriter writer) =>
{
writer.WriteValue("some self link");
return(Task.FromResult(0));
}).Verifiable();
mockLinkFormatter
.Setup(s => s.Serialize(mockRelatedLink.Object, It.IsAny <JsonWriter>()))
.Returns((ILink metadata, JsonWriter writer) =>
{
writer.WriteValue("some related link");
return(Task.FromResult(0));
}).Verifiable();
var mockLinkage = new Mock <IResourceLinkage>(MockBehavior.Strict);
var mockLinkageFormatter = new Mock <IResourceLinkageFormatter>(MockBehavior.Strict);
mockLinkageFormatter
.Setup(s => s.Serialize(mockLinkage.Object, It.IsAny <JsonWriter>()))
.Returns((IResourceLinkage metadata, JsonWriter writer) =>
{
writer.WriteValue("linkage goes here");
return(Task.FromResult(0));
}).Verifiable();
var mockMetadata = new Mock <IMetadata>(MockBehavior.Strict);
var mockMetadataFormatter = new Mock <IMetadataFormatter>(MockBehavior.Strict);
mockMetadataFormatter
.Setup(s => s.Serialize(mockMetadata.Object, It.IsAny <JsonWriter>()))
.Returns((IMetadata metadata, JsonWriter writer) =>
{
writer.WriteValue("metadata goes here");
return(Task.FromResult(0));
}).Verifiable();
var formatter = new RelationshipObjectFormatter(mockLinkFormatter.Object, mockLinkageFormatter.Object, mockMetadataFormatter.Object);
IRelationshipObject resourceObject = new RelationshipObject(mockLinkage.Object, mockSelfLink.Object, mockRelatedLink.Object, mockMetadata.Object);
await AssertSerializeOutput(formatter, resourceObject, "Json/Fixtures/RelationshipObjectFormatter/Serialize_relationship_with_all_possible_members.json");
mockLinkFormatter.Verify(s => s.Serialize(mockSelfLink.Object, It.IsAny <JsonWriter>()), Times.Once);
mockLinkFormatter.Verify(s => s.Serialize(mockRelatedLink.Object, It.IsAny <JsonWriter>()), Times.Once);
mockLinkageFormatter.Verify(s => s.Serialize(mockLinkage.Object, It.IsAny <JsonWriter>()), Times.Once);
mockMetadataFormatter.Verify(s => s.Serialize(mockMetadata.Object, It.IsAny <JsonWriter>()), Times.Once);
}
public static RelationshipObject MapInsertModelToDbModel(RelationshipObjectViewModel model, RelationshipObject newDomainModel = null)
{
if (newDomainModel == null)
{
newDomainModel = new RelationshipObject();
}
newDomainModel.ID = model.ID;
newDomainModel.RelationshipMetaID = model.RelationshipMetaID;
newDomainModel.PkAOMFieldObjectID = model.PkAOMFieldObjectID;
newDomainModel.FkAOMFieldObjectID = model.FkAOMFieldObjectID;
return(newDomainModel);
}
public void Serialize_relationship_with_no_required_fields()
{
var formatter = new RelationshipObjectFormatter(null, null, null);
IRelationshipObject relationshipObject = new RelationshipObject(null, null, null);
Func <Task> action = async() =>
{
await
GetSerializedString(formatter, relationshipObject);
};
action.ShouldThrow <JsonSerializationException>()
.WithMessage("At least one of `links`, `data`, or `meta` must be present in a relationship object.");
}
public async Task Serialize_relationship_with_meta_only()
{
var mockMetadata = new Mock <IMetadata>(MockBehavior.Strict);
var mockMetadataFormatter = new Mock <IMetadataFormatter>(MockBehavior.Strict);
mockMetadataFormatter
.Setup(s => s.Serialize(mockMetadata.Object, It.IsAny <JsonWriter>()))
.Returns((IMetadata metadata, JsonWriter writer) =>
{
writer.WriteValue("IMetadata placeholder 1");
return(Task.FromResult(0));
}).Verifiable();
var formatter = new RelationshipObjectFormatter(null, null, mockMetadataFormatter.Object);
IRelationshipObject resourceObject = new RelationshipObject(null, null, mockMetadata.Object);
await AssertSerializeOutput(formatter, resourceObject, "Json/Fixtures/RelationshipObjectFormatter/Serialize_relationship_with_meta_only.json");
mockMetadataFormatter.Verify(s => s.Serialize(mockMetadata.Object, It.IsAny <JsonWriter>()), Times.Once);
}
public async Task Serialize_relationship_with_linkage_only()
{
var mockLinkage = new Mock <IResourceLinkage>(MockBehavior.Strict);
var mockLinkageFormatter = new Mock <IResourceLinkageFormatter>(MockBehavior.Strict);
mockLinkageFormatter
.Setup(s => s.Serialize(mockLinkage.Object, It.IsAny <JsonWriter>()))
.Returns((IResourceLinkage metadata, JsonWriter writer) =>
{
writer.WriteValue("linkage goes here");
return(Task.FromResult(0));
}).Verifiable();
var formatter = new RelationshipObjectFormatter(null, mockLinkageFormatter.Object, null);
IRelationshipObject resourceObject = new RelationshipObject(mockLinkage.Object);
await AssertSerializeOutput(formatter, resourceObject, "Json/Fixtures/RelationshipObjectFormatter/Serialize_relationship_with_linkage_only.json");
mockLinkageFormatter.Verify(s => s.Serialize(mockLinkage.Object, It.IsAny <JsonWriter>()), Times.Once);
}
private cmisObjectListType getAndAssertRelationship(bool includeSubTypes, enumIncludeRelationships relationshipDirection, string typeId, string filter, bool allowableActions, Nullable <long> maxItems, Nullable <long> skipCount)
{
RelationshipObject relationship = createAndAssertRelationship(getAndAssertRelationshipTypeId(), getAndAssertRootFolder(), false, false, false);
string objectId = null;
enumRelationshipDirection direction = enumRelationshipDirection.either;
switch (relationshipDirection)
{
case enumIncludeRelationships.source:
{
objectId = relationship.SourceObject.ObjectId;
direction = enumRelationshipDirection.source;
break;
}
case enumIncludeRelationships.target:
{
objectId = relationship.TargetObject.ObjectId;
direction = enumRelationshipDirection.target;
break;
}
case enumIncludeRelationships.both:
{
objectId = relationship.SourceObject.ObjectId;
break;
}
}
logger.log("[RelationshipService->getObjectRelationships]");
logger.log("Getting relationships for object with objectId='" + objectId + "', direction=" + relationshipDirection);
cmisObjectListType response = relationshipServiceClient.getObjectRelationships(getAndAssertRepositoryId(), objectId, includeSubTypes, direction, typeId, filter, allowableActions, maxItems, skipCount, null);
Assert.IsNotNull(response, "Object Relationships were not returned");
assertRelationships(objectId, response.objects, relationshipDirection);
logger.log("Relationships were successfully received");
logger.log("");
deleteAndAssertRelationship(relationship);
return(response);
}
/// <summary>
/// Save relationship b/w 2 entities on special relationship type.
/// </summary>
/// <param name="objectId"></param>
/// <param name="relationship"></param>
public void Save(Guid objectId, RelationshipObject relationship)
{
this.Save(objectId, new[] { relationship });
}
/// <summary>
/// Save relationship b/w 2 entities on special relationship type.
/// </summary>
/// <param name="objectXId"></param>
/// <param name="objectYId"></param>
/// <param name="relationshipType"></param>
/// <param name="Ordinal"></param>
public void SaveJson(string objectXId, string objectYId, string relationshipType, string Ordinal)
{
if (string.IsNullOrEmpty(objectXId))
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, "objectId cannot be empty"));
if (string.IsNullOrEmpty(objectYId))
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, "referenceobject's Id cannot be empty"));
if (string.IsNullOrEmpty(relationshipType))
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, "relationshipType cannot be empty"));
try
{
RelationshipObject relationship = new RelationshipObject() { ReferenceObjectId = new Guid(objectYId), RelationshipType = relationshipType, Ordinal = string.IsNullOrEmpty(Ordinal) ? 0 : Convert.ToInt32(Ordinal) };
relationshipApi.Save(new Guid(objectXId), relationship);
}
catch (ArgumentException ex)
{
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, ex.Message));
}
catch (BadRequestException bad)
{
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, bad.Message));
}
catch (FormatException formatEx)
{
throw new BadRequestException(string.Format(CultureInfo.InvariantCulture, formatEx.Message));
}
catch (Exception exp)
{
Logger.Instance(this).Error(exp);
throw new InternalServerErrorException();
}
}
public void HierarchyTreeStory()
{
_story = new Story("Save the Hierarchy data And Bind to Organization Type");
_story.AsA("User")
.IWant("Create Hierarchy Data")
.SoThat("I can bind the Hierarchy to the object that have cascade relationship");
_story.WithScenario("Save Hierarchy Data")
.Given("a Hierarchy data which is new ", () =>
{
_HierarchyDataObject = new HierarchyDataObject()
{
Code = "1111",
Description = "Sample",
HierarchyType = "Tree",
Name = "Root"
};
_HierarchyApi.Save(_HierarchyDataObject);
createHierarchyIds.Add(_HierarchyDataObject.Id);
})
.And("create More than one Organization ", () =>
{
_OrganizationTypeObject1 = _Organutils.CreateOrganizationTypeOject("Root", "Inc");
_OrganizationApi.Save(_OrganizationTypeObject1);
createdOrganizationTypeIds.Add(_OrganizationTypeObject1.OrganizationTypeId);
_OrganizationObject1 = _Organutils.CreateOrganizationObject(_OrganizationTypeObject1.OrganizationTypeId, "Tim", "sh");
_OrganizationObject2 = _Organutils.CreateOrganizationObject(_OrganizationTypeObject1.OrganizationTypeId, "Euge", "sc");
_OrganizationApi.Save(_OrganizationObject1);
_OrganizationApi.Save(_OrganizationObject2);
createdOrganizationIds.Add(_OrganizationObject1.OrganizationId);
createdOrganizationIds.Add(_OrganizationObject2.OrganizationId);
})
.When("Have the Hierarchy Data", () =>
{
_HierarchyDataObject1 = _HierarchyApi.GetHierarchyData(_HierarchyDataObject.Id);
_HierarchyDataObject2 = _HierarchyApi.GetHierarchyData("Tree", "Root");
_HierarchyDataObject1.Id.ShouldEqual(_HierarchyDataObject.Id);
_HierarchyDataObject2.Id.ShouldEqual(_HierarchyDataObject.Id);
})
.Then("I can use the Hierarchy Data to bind to Organization object", () =>
{
_RelationshipObject1 = new RelationshipObject()
{
ReferenceObjectId = _HierarchyDataObject.Id,
RelationshipType = "Tree"
};
_RelationShipApi.Save(_OrganizationObject1.OrganizationId, _RelationshipObject1);
_RelationShipApi.Save(_OrganizationObject2.OrganizationId, _RelationshipObject1);
_RelationshipObject2 = _RelationShipApi.GetOneToOne(_OrganizationObject1.OrganizationId, _RelationshipObject1.RelationshipType);
_RelationshipObject3 = _RelationShipApi.GetOneToOne(_OrganizationObject2.OrganizationId, _RelationshipObject1.RelationshipType);
_RelationshipObject2.ReferenceObjectId.ShouldEqual(_RelationshipObject3.ReferenceObjectId);
_RelationshipObject2.Ordinal.ShouldEqual(_RelationshipObject3.Ordinal);
})
.WithScenario("How to create Hierarchy in Organization")
.Given("Remove the relationship between Organ1 and Organ2", () =>
{
_RelationShipApi.Remove(_OrganizationObject1.OrganizationId);
_RelationShipApi.Remove(_OrganizationObject2.OrganizationId, "Tree");
})
.And("Create a child Hierarchy data ", () =>
{
_HierarchyDataObject2 = new HierarchyDataObject()
{
Code = "1111",
Description = "Sample",
HierarchyType = "Tree",
Name = "Leaf",
ParentHierarchyDataId = _HierarchyDataObject.Id
};
_HierarchyApi.Save(_HierarchyDataObject2);
})
.When("I add the hierarchy data to Organization", () =>
{
_OrganizationObject1.Hierarchies.Add("Tree", _HierarchyDataObject.Id);
_OrganizationObject2.Hierarchies.Add("Tree", _HierarchyDataObject2.Id);
_OrganizationApi.Save(_OrganizationObject1);
_OrganizationApi.Save(_OrganizationObject2);
})
.Then("I can get children HierarchyData by Hierarchy", () =>
{
_HierarchyDataObject1 = null;
_HierarchyDataObject1 = _HierarchyApi.GetImmediateChildren("Tree", _HierarchyDataObject.Id).FirstOrDefault();
_HierarchyDataObject1.Id.ShouldEqual(_HierarchyDataObject2.Id);
})
.WithScenario("Delete the children Hierarchy Data")
.Given("an Existing parent Hierarchy Data and an existing child", () => { })
.When("I delete the parent hierarchy Data", () =>
{
_HierarchyApi.DeleteHierarchyData(_HierarchyDataObject.Id);
})
.Then("I cannot get the parent data, and Organization should not have this Hierarchy data", () =>
{
});
this.CleanUp();
}
public void deleteAndAssertRelationship(RelationshipObject relationship)
{
deleteAndAssertObject(relationship, false);
deleteAndAssertObject(relationship.SourceObject, true);
deleteAndAssertObject(relationship.TargetObject, true);
}
protected RelationshipObject createAndAssertRelationship(bool reset, bool createPropertiesIfNull, string typeId, string folderId, bool sourceIsNull, bool targetIsNull, bool onlySourceAndTargetObjects)
{
cmisTypeDefinitionType sourceTypeDefinition = getAndAssertTypeDefinition(getAndAssertRelationshipSourceTypeId());
FileableObject sourceObject = null;
if (!sourceIsNull)
{
if (enumBaseObjectTypeIds.cmisdocument.Equals(sourceTypeDefinition.baseId))
{
sourceObject = createAndAssertObject(new FileableObject(enumTypesOfFileableObjects.documents, sourceTypeDefinition.id, folderId));
}
else
{
sourceObject = createAndAssertObject(new FileableObject(enumTypesOfFileableObjects.folders, sourceTypeDefinition.id, folderId));
}
Assert.IsNotNull(sourceObject.ObjectId, "Id of Created Source Object is undefined");
}
cmisTypeDefinitionType targetTypeDefinition = getAndAssertTypeDefinition(getAndAssertRelationshipTargetTypeId());
FileableObject targetObject = null;
if (!targetIsNull)
{
if (enumBaseObjectTypeIds.cmisdocument.Equals(targetTypeDefinition.baseId))
{
targetObject = createAndAssertObject(new FileableObject(enumTypesOfFileableObjects.documents, targetTypeDefinition.id, folderId));
}
else
{
targetObject = createAndAssertObject(new FileableObject(enumTypesOfFileableObjects.folders, targetTypeDefinition.id, folderId));
}
Assert.IsNotNull(targetObject.ObjectId, "Id of Created Target Object is undefined");
}
RelationshipObject result = new RelationshipObject(folderId, relationshipTypeId, sourceObject, targetObject);
if (!onlySourceAndTargetObjects)
{
result = (RelationshipObject)result.createObject(createPropertiesIfNull, reset, folderId, relationshipTypeId);
Assert.IsNotNull(result.ObjectId, "Id of Created Relationship is undefined");
logger.log("Relationship was successfully created");
}
logger.log("");
return result;
}
public void SaveRelationshipStories()
{
_story = new Story("Save Relationship among objects");
_story.WithScenario("Save RelationShip between Users")
.Given("Create an RelationShipOBject firstly", () =>
{
_RelationshipObject = new RelationshipObject() { RelationshipType = "Parnter" };
})
.And("Create two Users", () =>
{
_memberUtils = new BehaveMemberShipUtils();
_User1 = _memberUtils.CreateUserObject("Tim Yi", true);
_User2 = _memberUtils.CreateUserObject("Eunge", true);
_MembershipApi.Save(_User1, "123456Hello", "123456Hello");
_MembershipApi.Save(_User2, "123456Hello", "123456Hello");
_createUserIds.Add(_User1.UserId);
_createUserIds.Add(_User2.UserId);
})
.When("Save the relationshipobject with ", () =>
{
_RelationshipApi.Save(_User2.UserId, _RelationshipObject);
})
.And("Save the relation between two Users , and the Relationship Type already have", () =>
{
_RelationshipApi.Save(_User1.UserId, _User2.UserId, "Parnter");
})
.And("Save the relation between two Users , and the Relationship Type doesn't exist", () =>
{
_RelationshipApi.Save(_User1.UserId, _User2.UserId, "Who Knows");
})
.And("Save the relation between one Users ", () =>
{
_RelationshipApi.Save(_User1.UserId, _User1.UserId, "Parnter");
})
.Then("Get the relation ship ", () =>
{
_RelationshipApi.GetOneToOne(_User2.UserId, _RelationshipObject.RelationshipType).RelationshipType.ShouldEqual("Parnter");
})
.WithScenario("Update Existing Relationship")
.Given("An Existing RelationshipObject", () =>
{
})
.And("Update the relationship type", () =>
{
_RelationshipObject.RelationshipType = "NEWPARNTER";
})
.And("Save the relationship to User who already have this relationshipobject before", () =>
{
_RelationshipApi.Save(_User2.UserId, _RelationshipObject);
})
.When("I get the relationship", () =>
{
_RelationshipApi.GetOneToOne(_User2.UserId, _RelationshipObject.RelationshipType).RelationshipType.ShouldEqual("NEWPARNTER");
}).
Then("I can get the relationship")
;
this.CleanUp();
}
