private static void ResolveResourceLink(IDomLink domLink,
IHypermediaContext hypermediaContext,
IHypermediaAssembler hypermediaAssembler,
IResourcePathContext resourcePathContext,
Type clrResourceType,
object clrResource,
DomReadWriteLinks domReadWriteLinks)
{
if (domLink.IsReadOnly)
{
return;
}
// Resolve read-write resource link
var domReadWriteLink = (DomReadWriteLink)domLink;
var apiLinkRel = domReadWriteLink.Rel;
var apiLinkMeta = default(Meta);
var domLinkMeta = (IDomMeta)domReadWriteLink.GetNode(DomNodeType.Meta);
if (domLinkMeta != null)
{
apiLinkMeta = domLinkMeta.Meta;
}
// Create link.
var linkContext = new LinkContext(apiLinkRel, apiLinkMeta);
var apiResourceLink = hypermediaAssembler.CreateResourceLink(hypermediaContext, resourcePathContext, clrResourceType, clrResource, linkContext);
// Replace the old DOM read-write link node with a new DOM read-only link created by the framework.
var domReadOnlyLink = DomReadOnlyLink.Create(apiLinkRel, apiResourceLink);
domReadWriteLinks.ReplaceNode(domReadWriteLink, domReadOnlyLink);
}
private void ResolveResourceRelationships(DomReadWriteResource domReadWriteResource,
IHypermediaContext hypermediaContext,
IHypermediaAssembler hypermediaAssembler,
IResourcePathContext resourcePathContext,
Type clrResourceType,
object clrResource)
{
var domRelationships = (IDomRelationships)domReadWriteResource.GetNode(DomNodeType.Relationships);
if (domRelationships == null || domRelationships.IsReadOnly)
{
return;
}
var domReadWriteRelationships = (DomReadWriteRelationships)domRelationships;
foreach (var domRelationship in domReadWriteRelationships.Nodes().Cast <IDomRelationship>())
{
this.ResolveResourceRelationship(domRelationship, hypermediaContext, hypermediaAssembler, resourcePathContext, clrResourceType, clrResource, domReadWriteRelationships);
}
}
private static void ResolveResourceLinks(DomReadWriteResource domReadWriteResource,
IHypermediaContext hypermediaContext,
IHypermediaAssembler hypermediaAssembler,
IResourcePathContext resourcePathContext,
Type clrResourceType,
object clrResource)
{
var domLinks = (IDomLinks)domReadWriteResource.GetNode(DomNodeType.Links);
if (domLinks == null || domLinks.IsReadOnly)
{
return;
}
var domReadWriteLinks = (DomReadWriteLinks)domLinks;
foreach (var domLink in domReadWriteLinks.Nodes().Cast <IDomLink>())
{
ResolveResourceLink(domLink, hypermediaContext, hypermediaAssembler, resourcePathContext, clrResourceType, clrResource, domReadWriteLinks);
}
}
private void ResolveResourceRelationship(IDomRelationship domRelationship,
IHypermediaContext hypermediaContext,
IHypermediaAssembler hypermediaAssembler,
IResourcePathContext resourcePathContext,
Type clrResourceType,
object clrResource,
DomReadWriteRelationships domReadWriteRelationships)
{
if (domRelationship.IsReadOnly)
{
return;
}
// Resolve read-write relationship
var domReadWriteRelationship = (DomReadWriteRelationship)domRelationship;
// .. Rel
var apiRelationshipRel = domReadWriteRelationship.Rel;
// .. Links
var linkContexts = new List <ILinkContext>();
var domRelationshipLinks = (IDomLinks)domReadWriteRelationship.GetNode(DomNodeType.Links);
if (domRelationshipLinks != null)
{
if (domRelationshipLinks.IsReadOnly)
{
// A read-write relationship contains unexpected read-only relationship links.
var detail = ServerErrorStrings.DomExceptionDetailReadWriteNodeHasUnexpectedReadOnlyChildNode
.FormatWith(DomNodeType.Relationship, DomNodeType.Links);
throw new DomException(detail);
}
var domReadWriteRelationshipLinks = (DomReadWriteLinks)domRelationshipLinks;
foreach (var domLink in domReadWriteRelationshipLinks.Nodes().Cast <IDomLink>())
{
if (domLink.IsReadOnly)
{
// A read-write relationship contains unexpected read-only relationship link.
var detail = ServerErrorStrings.DomExceptionDetailReadWriteNodeHasUnexpectedReadOnlyChildNode
.FormatWith(DomNodeType.Relationship, DomNodeType.Link);
throw new DomException(detail);
}
// Resolve read-write relationship link
var domReadWriteLink = (DomReadWriteLink)domLink;
var apiLinkRel = domReadWriteLink.Rel;
var apiLinkMeta = default(Meta);
var domMeta = (IDomMeta)domReadWriteLink.GetNode(DomNodeType.Meta);
if (domMeta != null)
{
apiLinkMeta = domMeta.Meta;
}
var linkContext = new LinkContext(apiLinkRel, apiLinkMeta);
linkContexts.Add(linkContext);
}
}
// .. Data
var resourceType = this.ServiceModel.GetResourceType(clrResourceType);
var fromApiResourceIdentifier = resourceType.GetApiResourceIdentifier(clrResource);
var resourceLinkageKey = new ResourceLinkageKey(fromApiResourceIdentifier, apiRelationshipRel);
ResourceLinkage resourceLinkage;
var hasResourceLinkage = this.DocumentBuilderContext.TryGetResourceLinkage(resourceLinkageKey, out resourceLinkage);
// .. Meta
var apiRelationshipMeta = default(Meta);
var domRelationshipMeta = (IDomMeta)domReadWriteRelationship.GetNode(DomNodeType.Meta);
if (domRelationshipMeta != null)
{
apiRelationshipMeta = domRelationshipMeta.Meta;
}
// Create the correct relationship context based on resource linkage (if any).
RelationshipContext relationshipContext;
if (hasResourceLinkage)
{
var resourceLinkageType = resourceLinkage.Type;
switch (resourceLinkageType)
{
case ResourceLinkageType.ToOneResourceLinkage:
{
var toOneResourceLinkage = resourceLinkage.ToOneResourceLinkage;
relationshipContext = new ToOneRelationshipContext(apiRelationshipRel, linkContexts, toOneResourceLinkage, apiRelationshipMeta);
}
break;
case ResourceLinkageType.ToManyResourceLinkage:
{
var toManyResourceLinkage = resourceLinkage.ToManyResourceLinkage;
relationshipContext = new ToManyRelationshipContext(apiRelationshipRel, linkContexts, toManyResourceLinkage, apiRelationshipMeta);
}
break;
default:
{
var detail = InfrastructureErrorStrings.InternalErrorExceptionDetailUnknownEnumerationValue
.FormatWith(typeof(ResourceLinkageType).Name, resourceLinkageType);
throw new InternalErrorException(detail);
}
}
}
else
{
relationshipContext = new RelationshipContext(apiRelationshipRel, linkContexts, apiRelationshipMeta);
}
// Create relationship.
var apiResourceRelationship = hypermediaAssembler.CreateResourceRelationship(hypermediaContext, resourcePathContext, clrResourceType, clrResource, relationshipContext);
// Replace the old DOM read-write relationship node with a new DOM read-only relationship created by the framework.
var domReadOnlyRelationship = DomReadOnlyRelationship.Create(apiRelationshipRel, apiResourceRelationship);
domReadWriteRelationships.ReplaceNode(domReadWriteRelationship, domReadOnlyRelationship);
}
public void TestHypermediaAssemblerRegistryGetAssembler(string name, IEnumerable <IHypermediaAssembler> hypermediaAssemblers, Func <IHypermediaAssemblerRegistry, IHypermediaAssembler> getAssemblerFunc, IHypermediaAssembler expectedHypermediaAssembler)
{
this.Output.WriteLine("Test Name: {0}", name);
this.Output.WriteLine(String.Empty);
// Arrange
var hypermediaAssemblerRegistry = new HypermediaAssemblerRegistry(hypermediaAssemblers);
// Act
var actualHypermediaAssembler = getAssemblerFunc(hypermediaAssemblerRegistry);
// Assert
HypermediaAssemblerAssert.Equal(expectedHypermediaAssembler, actualHypermediaAssembler);
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Assert Methods
public static void Equal(IHypermediaAssembler expected, IHypermediaAssembler actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
var expectedType = expected.GetType();
Assert.IsType(expectedType, actual);
if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <, , , , , ,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes7(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes7(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
Assert.Equal(expectedTypes.Item3, actualTypes.Item3);
Assert.Equal(expectedTypes.Item4, actualTypes.Item4);
Assert.Equal(expectedTypes.Item5, actualTypes.Item5);
Assert.Equal(expectedTypes.Item6, actualTypes.Item6);
Assert.Equal(expectedTypes.Item7, actualTypes.Item7);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <, , , , ,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes6(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes6(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
Assert.Equal(expectedTypes.Item3, actualTypes.Item3);
Assert.Equal(expectedTypes.Item4, actualTypes.Item4);
Assert.Equal(expectedTypes.Item5, actualTypes.Item5);
Assert.Equal(expectedTypes.Item6, actualTypes.Item6);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <, , , ,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes5(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes5(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
Assert.Equal(expectedTypes.Item3, actualTypes.Item3);
Assert.Equal(expectedTypes.Item4, actualTypes.Item4);
Assert.Equal(expectedTypes.Item5, actualTypes.Item5);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <, , ,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes4(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes4(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
Assert.Equal(expectedTypes.Item3, actualTypes.Item3);
Assert.Equal(expectedTypes.Item4, actualTypes.Item4);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <, ,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes3(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes3(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
Assert.Equal(expectedTypes.Item3, actualTypes.Item3);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <,>)))
{
var expectedTypes = GetHypermediaAssemblerTypes2(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes2(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
Assert.Equal(expectedTypes.Item2, actualTypes.Item2);
}
else if (expectedType.IsImplementationOf(typeof(IHypermediaAssembler <>)))
{
var expectedTypes = GetHypermediaAssemblerTypes1(expectedType, expected);
var actualTypes = GetHypermediaAssemblerTypes1(expectedType, expected);
Assert.Equal(expectedTypes.Item1, actualTypes.Item1);
}
else if (expectedType == DefaultHypermediaAssemblerType)
{
// NOOP
}
else
{
Assert.True(false, "Unknown hypermedia assembler types.");
}
}
