private static object GenerateForEmbeddedRule(EntityRule rule, IActionConfiguration actionConfiguration,
Dictionary <string, List <string> > routeRelations, object originalObject)
{
var actionExecutedContext = ActionCallContext.Get <HttpActionExecutedContext>();
var entityActionConfiguration = HypermediaControllerConfiguration.Instance.GetcontrollerActionConfiguration(rule.ControllerType, rule.ControllerAction, actionExecutedContext.Request.Headers.Accept);
if (entityActionConfiguration == null)
{
return(null);
}
var referencedObject = rule.GetReferencedObjectInstance(originalObject);
if (referencedObject == null)
{
return(null);
}
var transformed = ActionResponseTransformer.TransformPayload(entityActionConfiguration, referencedObject);
if (transformed == null)
{
return(null);
}
if (transformed is IEnumerable)
{
throw new Exception(string.Format("Unable to generate enumerable entity object from controller {0} action {1}. Consider using outer object.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
}
AssignRelName(transformed, rule.Rel);
return(transformed);
}
public static MetadataPlainObjects.Actions Generate(IActionConfiguration actionConfiguration, Dictionary <string, List <string> > routeRelations, object originalObject)
{
var result = new MetadataPlainObjects.Actions();
var mappingRules = actionConfiguration.MappingRules;
var routeNameSubstitution = new DefaultRouteValueSubstitution();
result.AddRange(from mappingRule in mappingRules
let apiDescription = mappingRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault()
let isAction = mappingRule.Type == MappingRule.RuleType.ActionRule || (mappingRule.Type == MappingRule.RuleType.Default && apiDescription.HttpMethod != HttpMethod.Get)
where apiDescription != null && isAction
let absolutePath = LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(apiDescription.RelativePath, mappingRule, originalObject))
let routeNames = routeRelations[apiDescription.ID]
select new MetadataPlainObjects.Action()
{
Href = absolutePath,
Method = apiDescription.HttpMethod.Method,
Title = apiDescription.Documentation,
ActionName = routeNames.FirstOrDefault(),
ActionFields = ActionFieldsGenerator.Generate(mappingRule, apiDescription, originalObject),
ContentType = DeduceContentType(mappingRule, apiDescription, originalObject),
Class = GetClassArray(mappingRule)
});
return(result);
}
private static object GenerateForEmbeddedRule(EntityRule rule, IActionConfiguration actionConfiguration,
Dictionary<string, List<string>> routeRelations, object originalObject)
{
var actionExecutedContext = ActionCallContext.Get<HttpActionExecutedContext>();
var entityActionConfiguration = HypermediaControllerConfiguration.Instance.GetcontrollerActionConfiguration(rule.ControllerType, rule.ControllerAction, actionExecutedContext.Request.Headers.Accept);
if (entityActionConfiguration == null)
return null;
var referencedObject = rule.GetReferencedObjectInstance(originalObject);
if (referencedObject == null)
return null;
var transformed = ActionResponseTransformer.TransformPayload(entityActionConfiguration, referencedObject);
if (transformed == null)
return null;
if (transformed is IEnumerable)
throw new Exception(string.Format("Unable to generate enumerable entity object from controller {0} action {1}. Consider using outer object.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
AssignRelName(transformed, rule.Rel);
return transformed;
}
public static MetadataPlainObjects.Actions Generate(IActionConfiguration actionConfiguration, Dictionary<string, List<string>> routeRelations, object originalObject)
{
var result = new MetadataPlainObjects.Actions();
var mappingRules = actionConfiguration.MappingRules;
var routeNameSubstitution = new DefaultRouteValueSubstitution();
result.AddRange(from mappingRule in mappingRules
let apiDescription = mappingRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault()
let isAction = mappingRule.Type == MappingRule.RuleType.ActionRule || (mappingRule.Type == MappingRule.RuleType.Default && apiDescription.HttpMethod != HttpMethod.Get)
where apiDescription != null && isAction
let absolutePath = LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(apiDescription.RelativePath, mappingRule, originalObject))
let routeNames = routeRelations[apiDescription.ID]
select new MetadataPlainObjects.Action()
{
Href = absolutePath,
Method = apiDescription.HttpMethod.Method,
Title = apiDescription.Documentation,
ActionName = routeNames.FirstOrDefault(),
ActionFields = ActionFieldsGenerator.Generate(mappingRule, apiDescription, originalObject),
ContentType = DeduceContentType(mappingRule, apiDescription, originalObject),
Class = GetClassArray(mappingRule)
});
return result;
}
public override void ActivateInstance(object proxyInstance, object originalInstance,
IActionConfiguration actionConfiguration)
{
var routes = (Dictionary<string, string>)actionConfiguration.MetadataProvider.GetMetadataByType(typeof(Dictionary<string, string>), originalInstance);
proxyInstance.GetType().GetProperties().Where(p => routes.ContainsKey(p.Name)).ToList()
.ForEach(prop => prop.SetValue(proxyInstance, routes[prop.Name]));
}
public override void ActivateInstance(object proxyInstance, object originalInstance,
IActionConfiguration actionConfiguration)
{
var routes = (Dictionary <string, string>)actionConfiguration.MetadataProvider.GetMetadataByType(typeof(Dictionary <string, string>), originalInstance);
proxyInstance.GetType().GetProperties().Where(p => routes.ContainsKey(p.Name)).ToList()
.ForEach(prop => prop.SetValue(proxyInstance, routes[prop.Name]));
}
private static object GenerateForRule(EntityRule rule, IActionConfiguration actionConfiguration,
Dictionary <string, List <string> > routeRelations, object originalObject)
{
if (rule.EntityEmbeddingRule == EntityRule.EmbeddingRule.Embedded)
{
return(GenerateForEmbeddedRule(rule, actionConfiguration, routeRelations, originalObject));
}
return(GenerateForLinkedRule(rule, actionConfiguration, routeRelations, originalObject));
}
public static object TransformPayload(IActionConfiguration actionConfiguration, object payload)
{
var responseTransformer = actionConfiguration.ResponseTransformerFactory.Get(payload);
if (responseTransformer == null)
{
throw new Exception(string.Format("Unable to get response transformer for response type {0}", payload.GetType()));
}
return responseTransformer.Transform(actionConfiguration, payload);
}
public static MetadataPlainObjects.Entities Generate(IActionConfiguration actionConfiguration,
Dictionary<string, List<string>> routeRelations, object originalObject)
{
var rules = new MetadataPlainObjects.Entities();
actionConfiguration.EntityRules.ToList()
.ForEach(rule => rules.Add(GenerateForRule(rule, actionConfiguration, routeRelations, originalObject)));
var result = new Entities();
result.AddRange(rules.Where(r => r != null).ToList());
return result;
}
public static object TransformPayload(IActionConfiguration actionConfiguration, object payload)
{
var responseTransformer = actionConfiguration.ResponseTransformerFactory.Get(payload);
if (responseTransformer == null)
{
throw new Exception(string.Format("Unable to get response transformer for response type {0}", payload.GetType()));
}
return(responseTransformer.Transform(actionConfiguration, payload));
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
var aggregateFieldInfo = proxyInstance.GetType().GetField(PropertyVisitor.PropertyFieldName(_propertyName),
BindingFlags.NonPublic |
BindingFlags.Instance);
if (aggregateFieldInfo == null)
throw new Exception("Unable to activate instance");
aggregateFieldInfo.SetValue(proxyInstance, originalInstance);
}
public void Setup()
{
_fixture = new Fixture();
_fixture.Customize(new AutoMoqCustomization());
_fixture.Customize(new RandomNumericSequenceCustomization());
Expression <Func <ControllerSample, ModelSample, IEnumerable <ModelSample> > > lambda = (c, m)
=> c.ControllerQueryMethod(m.Id, m.Name, QueryParameter.Is <string>(), QueryParameter.Is <int>());
Expression <Func <ControllerSample, ModelSample, ModelSample> > lambda2 = (c, m)
=> c.ControllerMethodPut(m.Id, m);
var apiExplorerMoq = new Mock <IApiExplorer>();
apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection <ApiDescription>()
{
new ApiDescription()
{
}
});
var actionConfiguration = new Mock <IActionConfiguration>();
actionConfiguration.Setup(_ => _.MappingRules).Returns(() => new List <MappingRule>
{
new MappingRule((MethodCallExpression)lambda.Body, apiExplorerMoq.Object)
{
ApiDescriptions = new List <ApiDescription>()
{
new ApiDescription()
{
RelativePath = "/api/{id}?query={query}",
HttpMethod = HttpMethod.Get
}
},
Type = MappingRule.RuleType.Default
},
new MappingRule((MethodCallExpression)lambda2.Body, apiExplorerMoq.Object)
{
ApiDescriptions = new List <ApiDescription>()
{
new ApiDescription()
{
RelativePath = "/api/prod/{id}",
HttpMethod = HttpMethod.Put
}
},
Type = MappingRule.RuleType.Default
}
});
_actionConfiguration = actionConfiguration.Object;
}
public static MetadataPlainObjects.Entities Generate(IActionConfiguration actionConfiguration,
Dictionary <string, List <string> > routeRelations, object originalObject)
{
var rules = new MetadataPlainObjects.Entities();
actionConfiguration.EntityRules.ToList()
.ForEach(rule => rules.Add(GenerateForRule(rule, actionConfiguration, routeRelations, originalObject)));
var result = new Entities();
result.AddRange(rules.Where(r => r != null).ToList());
return(result);
}
public object Transform(IActionConfiguration actionConfiguration, object payload)
{
var strategyFactory = actionConfiguration.StrategyBuilderFactory;
var strategy = strategyFactory.Build(actionConfiguration, payload.GetType());
var typeBuilder = new TypeBuilder(payload.GetType(), strategy);
var proxyType = typeBuilder.BuildType();
var newinstance = Activator.CreateInstance(proxyType);
strategy.ActivateInstance(newinstance, payload, actionConfiguration);
return newinstance;
}
public object Transform(IActionConfiguration actionConfiguration, object payload)
{
var strategyFactory = actionConfiguration.StrategyBuilderFactory;
var strategy = strategyFactory.Build(actionConfiguration, payload.GetType());
var typeBuilder = new TypeBuilder(payload.GetType(), strategy);
var proxyType = typeBuilder.BuildType();
var newinstance = Activator.CreateInstance(proxyType);
strategy.ActivateInstance(newinstance, payload, actionConfiguration);
return(newinstance);
}
public void Setup()
{
_responseTransformerFactory = new ResponseTransformerFactory();
var strategy = new Mock<ITypeBuilderStrategy>();
strategy.Setup(_ => _.ClassKey(It.IsAny<Type>())).Returns((Type t) => t.Name);
var strategyFactory = new Mock<IStrategyBuilderFactory>();
strategyFactory.Setup(_ => _.Build(It.IsAny<IActionConfiguration>(), It.IsAny<Type>()))
.Returns(() => strategy.Object);
var actionConfiguration = new Mock<IActionConfiguration>();
actionConfiguration.Setup(_ => _.StrategyBuilderFactory).Returns(() => strategyFactory.Object);
actionConfiguration.Setup(_ => _.ResponseTransformerFactory).Returns(_responseTransformerFactory);
_actionConfiguration = actionConfiguration.Object;
}
private static object GenerateForLinkedRule(EntityRule rule,
IActionConfiguration actionConfiguration,
Dictionary <string, List <string> > routeRelations, object originalObject)
{
var actionExecutedContext = ActionCallContext.Get <HttpActionExecutedContext>();
var entityActionConfiguration = HypermediaControllerConfiguration.Instance.GetcontrollerActionConfiguration(rule.ControllerType, rule.ControllerAction, actionExecutedContext.Request.Headers.Accept);
if (entityActionConfiguration == null)
{
return(null);
}
var referencedObject = rule.GetReferencedObjectInstance(originalObject);
if (referencedObject == null)
{
return(null);
}
var selfRule = entityActionConfiguration.MappingRules.FirstOrDefault(r => r.Names.Contains("self"));
if (selfRule == null)
{
throw new Exception(string.Format("Unable to generate link to entity object from controller {0} action {1}. Can't find self rel.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
}
var selfApi = selfRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault();
if (selfApi == null)
{
throw new Exception(string.Format("Unable to generate link to entity object from controller {0} action {1}. Can't find self API.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
}
var routeNameSubstitution = new DefaultRouteValueSubstitution();
var absolutePath =
LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(selfApi.RelativePath, selfRule,
referencedObject));
return(new LinkedEntity()
{
Rels = rule.Rel,
ClassName = entityActionConfiguration.Class,
Href = absolutePath
});
}
public void Setup()
{
_responseTransformerFactory = new ResponseTransformerFactory();
var strategy = new Mock <ITypeBuilderStrategy>();
strategy.Setup(_ => _.ClassKey(It.IsAny <Type>())).Returns((Type t) => t.Name);
var strategyFactory = new Mock <IStrategyBuilderFactory>();
strategyFactory.Setup(_ => _.Build(It.IsAny <IActionConfiguration>(), It.IsAny <Type>()))
.Returns(() => strategy.Object);
var actionConfiguration = new Mock <IActionConfiguration>();
actionConfiguration.Setup(_ => _.StrategyBuilderFactory).Returns(() => strategyFactory.Object);
actionConfiguration.Setup(_ => _.ResponseTransformerFactory).Returns(_responseTransformerFactory);
_actionConfiguration = actionConfiguration.Object;
}
public object Transform(IActionConfiguration actionConfiguration, object payload)
{
var enumerable = payload as IEnumerable;
if (enumerable == null)
{
return(null);
}
IResponseTransformer innerTransformer = null;
IList resultList = null;
foreach (var item in enumerable)
{
if (innerTransformer == null)
{
innerTransformer = actionConfiguration.ResponseTransformerFactory.Get(item);
if (innerTransformer == null)
{
throw new Exception(string.Format("Unable to get response transformer for response type {0}", item.GetType()));
}
}
var transformed = innerTransformer.Transform(actionConfiguration, item);
if (transformed == null)
{
continue;
}
if (resultList == null)
{
var resultType = typeof(List <>).MakeGenericType(new [] { transformed.GetType() });
resultList = (IList)Activator.CreateInstance(resultType);
}
resultList.Add(transformed);
}
return(resultList);
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return StrategyCache.GetCachedOrAdd(key,
() =>
{
var sirenMetadataTypes = actionConfiguration.MetadataProvider.GetRegisteredMetadataTypes().ToList();
Func<CustomAttributeBuilder> jsonPropAttrNullValueHandling = () =>
{
var type = typeof (JsonPropertyAttribute);
var ctor = type.GetConstructor(Type.EmptyTypes);
return new CustomAttributeBuilder(ctor,
new object[] {},
new[] {type.GetProperty("NullValueHandling")}, new object[] {NullValueHandling.Ignore});
};
// Do not use IActionConfiguration from parameter list as configuration might be altered on call
Action<object, object, IActionConfiguration> classNameAssigner =
(proxyObject, originalObject, configuration) =>
{
var classProp = proxyObject.GetType().GetProperty("class");
classProp.SetValue(proxyObject, configuration.Class);
};
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithPayloadPropertyStrategy(returnType, "properties")
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "class", new [] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string), "href", new[] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "rel", new[] { jsonPropAttrNullValueHandling })
.WithCustomActivationStrategy(classNameAssigner);
sirenMetadataTypes.ForEach(metadataType => strategyBuilder.WithTypedMetadataProperty(metadataType, metadataType.Name.ToLower()));
return strategyBuilder.Build();
});
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return(StrategyCache.GetCachedOrAdd(key,
() =>
{
var sirenMetadataTypes = actionConfiguration.MetadataProvider.GetRegisteredMetadataTypes().ToList();
Func <CustomAttributeBuilder> jsonPropAttrNullValueHandling = () =>
{
var type = typeof(JsonPropertyAttribute);
var ctor = type.GetConstructor(Type.EmptyTypes);
return new CustomAttributeBuilder(ctor,
new object[] {},
new[] { type.GetProperty("NullValueHandling") }, new object[] { NullValueHandling.Ignore });
};
// Do not use IActionConfiguration from parameter list as configuration might be altered on call
Action <object, object, IActionConfiguration> classNameAssigner =
(proxyObject, originalObject, configuration) =>
{
var classProp = proxyObject.GetType().GetProperty("class");
classProp.SetValue(proxyObject, configuration.Class);
};
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithPayloadPropertyStrategy(returnType, "properties")
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "class", new [] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string), "href", new[] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "rel", new[] { jsonPropAttrNullValueHandling })
.WithCustomActivationStrategy(classNameAssigner);
sirenMetadataTypes.ForEach(metadataType => strategyBuilder.WithTypedMetadataProperty(metadataType, metadataType.Name.ToLower()));
return strategyBuilder.Build();
}));
}
public static MetadataPlainObjects.Links Generate(IActionConfiguration actionConfiguration, Dictionary<string, List<string>> routeRelations, object originalObject)
{
var result = new MetadataPlainObjects.Links();
var mappingRules = actionConfiguration.MappingRules;
var routeNameSubstitution = new DefaultRouteValueSubstitution();
result.AddRange(from mappingRule in mappingRules
let apiDescription = mappingRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault()
let isLink = mappingRule.Type == MappingRule.RuleType.LinkRule || (mappingRule.Type == MappingRule.RuleType.Default && apiDescription.HttpMethod == HttpMethod.Get)
where apiDescription != null && isLink
let absolutePath = LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(apiDescription.RelativePath, mappingRule, originalObject))
select new MetadataPlainObjects.SirenLink()
{
Href = absolutePath,
RelList = GetRelList(mappingRule, apiDescription, routeRelations[apiDescription.ID])
});
return result;
}
public static MetadataPlainObjects.Links Generate(IActionConfiguration actionConfiguration, Dictionary <string, List <string> > routeRelations, object originalObject)
{
var result = new MetadataPlainObjects.Links();
var mappingRules = actionConfiguration.MappingRules;
var routeNameSubstitution = new DefaultRouteValueSubstitution();
result.AddRange(from mappingRule in mappingRules
let apiDescription = mappingRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault()
let isLink = mappingRule.Type == MappingRule.RuleType.LinkRule || (mappingRule.Type == MappingRule.RuleType.Default && apiDescription.HttpMethod == HttpMethod.Get)
where apiDescription != null && isLink
let absolutePath = LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(apiDescription.RelativePath, mappingRule, originalObject))
select new MetadataPlainObjects.SirenLink()
{
Href = absolutePath,
RelList = GetRelList(mappingRule, apiDescription, routeRelations[apiDescription.ID])
});
return(result);
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return(StrategyCache.GetCachedOrAdd(key,
() =>
{
var rels =
(Dictionary <string, IList <string> >)
actionConfiguration.MetadataProvider.GetMetadataByType(
typeof(Dictionary <string, IList <string> >));
IList <string> topRels = rels.Values.ToList().ConvertAll(c => c.FirstOrDefault());
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithSimpleProperties()
.WithPlainRouteInformation(topRels);
return strategyBuilder.Build();
}));
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return StrategyCache.GetCachedOrAdd(key,
() =>
{
var rels =
(Dictionary<string, IList<string>>)
actionConfiguration.MetadataProvider.GetMetadataByType(
typeof (Dictionary<string, IList<string>>));
IList<string> topRels = rels.Values.ToList().ConvertAll(c => c.FirstOrDefault());
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithSimpleProperties()
.WithPlainRouteInformation(topRels);
return strategyBuilder.Build();
});
}
public object Transform(IActionConfiguration actionConfiguration, object payload)
{
var enumerable = payload as IEnumerable;
if (enumerable == null)
return null;
IResponseTransformer innerTransformer = null;
IList resultList = null;
foreach (var item in enumerable)
{
if (innerTransformer == null)
{
innerTransformer = actionConfiguration.ResponseTransformerFactory.Get(item);
if (innerTransformer == null)
throw new Exception(string.Format("Unable to get response transformer for response type {0}", item.GetType()));
}
var transformed = innerTransformer.Transform(actionConfiguration, item);
if (transformed == null)
continue;
if (resultList == null)
{
var resultType = typeof (List<>).MakeGenericType(new [] {transformed.GetType()});
resultList = (IList)Activator.CreateInstance(resultType);
}
resultList.Add(transformed);
}
return resultList;
}
public static IActionConfiguration WithStatus(this IActionConfiguration source, Status status)
{
return(new CompositeActionConfiguration(source, Status(status)));
}
private static object GenerateForRule(EntityRule rule, IActionConfiguration actionConfiguration,
Dictionary<string, List<string>> routeRelations, object originalObject)
{
if (rule.EntityEmbeddingRule == EntityRule.EmbeddingRule.Embedded)
return GenerateForEmbeddedRule(rule, actionConfiguration, routeRelations, originalObject);
return GenerateForLinkedRule(rule, actionConfiguration, routeRelations, originalObject);
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
_compositeStrategiesList.ForEach(a => a.ActivateInstance(proxyInstance, originalInstance, actionConfiguration));
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
var aggregateFieldInfo = proxyInstance.GetType().GetField(AggregateFieldName,
BindingFlags.NonPublic |
BindingFlags.Instance);
if (aggregateFieldInfo == null)
{
throw new Exception("Unable to activate instance");
}
aggregateFieldInfo.SetValue(proxyInstance, originalInstance);
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
_compositeStrategiesList.ForEach(a => a.ActivateInstance(proxyInstance, originalInstance, actionConfiguration));
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
if (_customActivator != null)
_customActivator(proxyInstance, originalInstance, actionConfiguration);
}
public virtual void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
}
public SimpleMetadataProvider(IActionConfiguration actionConfiguration)
{
_actionConfiguration = actionConfiguration;
GenerateLinkNames();
}
public virtual void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
}
private static object GenerateForLinkedRule(EntityRule rule,
IActionConfiguration actionConfiguration,
Dictionary<string, List<string>> routeRelations, object originalObject)
{
var actionExecutedContext = ActionCallContext.Get<HttpActionExecutedContext>();
var entityActionConfiguration = HypermediaControllerConfiguration.Instance.GetcontrollerActionConfiguration(rule.ControllerType, rule.ControllerAction, actionExecutedContext.Request.Headers.Accept);
if (entityActionConfiguration == null)
return null;
var referencedObject = rule.GetReferencedObjectInstance(originalObject);
if (referencedObject == null)
return null;
var selfRule = entityActionConfiguration.MappingRules.FirstOrDefault(r => r.Names.Contains("self"));
if (selfRule == null)
throw new Exception(string.Format("Unable to generate link to entity object from controller {0} action {1}. Can't find self rel.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
var selfApi = selfRule.ApiDescriptions.OrderBy(d => d.RelativePath.Length).FirstOrDefault();
if (selfApi == null)
throw new Exception(string.Format("Unable to generate link to entity object from controller {0} action {1}. Can't find self API.", actionConfiguration.ControllerType.FullName, actionConfiguration.ActionMethodInfo));
var routeNameSubstitution = new DefaultRouteValueSubstitution();
var absolutePath =
LinkHelper.MakeAbsolutePath(routeNameSubstitution.Substitute(selfApi.RelativePath, selfRule,
referencedObject));
return new LinkedEntity()
{
Rels = rule.Rel,
ClassName = entityActionConfiguration.Class,
Href = absolutePath
};
}
public void Setup()
{
_fixture = new Fixture();
_fixture.Customize(new AutoMoqCustomization());
_fixture.Customize(new RandomNumericSequenceCustomization());
Expression<Func<ControllerSample, ModelSample, IEnumerable<ModelSample>>> lambda = (c, m)
=> c.ControllerQueryMethod(m.Id, m.Name, QueryParameter.Is<string>(), QueryParameter.Is<int>());
Expression<Func<ControllerSample, ModelSample, ModelSample>> lambda2 = (c, m)
=> c.ControllerMethodPut(m.Id, m);
var apiExplorerMoq = new Mock<IApiExplorer>();
apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection<ApiDescription>()
{
new ApiDescription()
{
}
});
var actionConfiguration = new Mock<IActionConfiguration>();
actionConfiguration.Setup(_ => _.MappingRules).Returns(() => new List<MappingRule>
{
new MappingRule( (MethodCallExpression)lambda.Body, apiExplorerMoq.Object)
{
ApiDescriptions = new List<ApiDescription>()
{
new ApiDescription()
{
RelativePath = "/api/{id}?query={query}",
HttpMethod = HttpMethod.Get
}
},
Type = MappingRule.RuleType.Default
},
new MappingRule( (MethodCallExpression)lambda2.Body, apiExplorerMoq.Object)
{
ApiDescriptions = new List<ApiDescription>()
{
new ApiDescription()
{
RelativePath = "/api/prod/{id}",
HttpMethod = HttpMethod.Put
}
},
Type = MappingRule.RuleType.Default
}
});
_actionConfiguration = actionConfiguration.Object;
}
// Next, some extension methods which allow you to chain things together
// This is really the glue that makes this whole solution easy to use
public static IActionConfiguration WithDamage(this IActionConfiguration source, int strength)
{
return(new CompositeActionConfiguration(source, Damage(strength)));
}
public SimpleMetadataProvider(IActionConfiguration actionConfiguration)
{
_actionConfiguration = actionConfiguration;
GenerateLinkNames();
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
if (_customActivator != null)
{
_customActivator(proxyInstance, originalInstance, actionConfiguration);
}
}
public override void ActivateInstance(object proxyInstance, object originalInstance, IActionConfiguration actionConfiguration)
{
var aggregateFieldInfo = proxyInstance.GetType().GetField(PropertyVisitor.PropertyFieldName(_propertyName),
BindingFlags.NonPublic |
BindingFlags.Instance);
if (aggregateFieldInfo == null)
{
throw new Exception("Unable to activate instance");
}
aggregateFieldInfo.SetValue(proxyInstance, actionConfiguration.MetadataProvider.GetMetadataByType(_propertyType, originalInstance));
}
