public override bool Process <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
if (registration.ArgumentDefinitions == null)
{
return(false);
}
var argumentDefinitionIndex = 0;
foreach (var argumentDefinition in registration.ArgumentDefinitions)
{
// Add the first argument as 'id' so it always can be used as named property 'id'
var keyOrigin = GetKey(data, ((MemberExpression)((UnaryExpression)argumentDefinition.Body).Operand).Member);
var key = argumentDefinitionIndex == 0 ? "id" : keyOrigin;
var value = argumentDefinition.Compile().DynamicInvoke(data);
linkBuilder.Arguments.Add(key, new Argument {
Name = key, Origin = keyOrigin, Type = value.GetType(), Value = value
});
argumentDefinitionIndex++;
}
return(true);
}
/// <summary>
/// Adds the arguments to the builder.
///
/// Remarkable at first sight might be adding the $$first$$
///
/// Example:
/// Session.MenuId = 5;
///
/// container
/// .Register<Session>(p => p.MenuId)
/// .Use<MenuController>()
///
/// MenuId becomes Id in a later process
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="registration"></param>
/// <param name="linkBuilder"></param>
/// <param name="data"></param>
/// <returns></returns>
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
if (!_idFromExpressionProcessor.Process(registration, linkBuilder, data))
{
_argumentDefinitionsProcessor.Process(registration, linkBuilder, data);
}
_templateArgumentsProcessor.Process(registration, linkBuilder, data);
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
var expression = registration.Expression;
linkBuilder.Controller = expression.Controller;
linkBuilder.Action = expression.Action != null
? expression.Action.GetTargetMethod(linkBuilder.Relation, linkBuilder.Method, linkBuilder.Arguments)
: expression.Controller.GetAction(linkBuilder.Relation, linkBuilder.Method ?? HttpMethod.Get, linkBuilder.Arguments);
}
public ILinkBuilder Process <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder resourceBuilder, object data)
{
if (CanProcess(registration, resourceBuilder))
{
ProcessInternal(registration, resourceBuilder, data);
}
return(_successor != null
? _successor.Process(registration, resourceBuilder, data)
: resourceBuilder);
}
public void Update(IHateoasRegistration registration)
{
var oldRegistration = _registrations.SingleOrDefault(p => p.Model == registration.Model &&
p.IsCollection == registration.IsCollection &&
p.Relation == registration.Relation);
if (oldRegistration != null)
{
_registrations.Remove(oldRegistration);
}
_registrations.Add(registration);
}
/// <summary>
/// Updates (or adds) an HATEOAS registration
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="registration">HATEOAS registration</param>
public static void UpdateRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration)
{
var definition = configuration.GetRegistrationFor(registration.Model, registration.Relation, registration.IsCollection);
if (definition == null)
{
configuration.AddRegistration(registration);
}
else
{
definition.Expression = registration.Expression;
}
}
public override bool Process <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
if (registration.Expression.IdFromExpression == null)
{
return(false);
}
var compiledExpression = registration.Expression.IdFromExpression.Compile();
var providerType = registration.Expression.IdFromExpression.Parameters[0].Type;
var provider = _dependencyResolver.GetService(providerType);
var value = compiledExpression.DynamicInvoke(provider, data);
linkBuilder.Arguments.Add("id", new Argument {
Name = "id", Type = value.GetType(), Value = value
});
return(true);
}
public override bool Process <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
var templateArguments = registration.Expression.TemplateParameters ?? new List <LambdaExpression>();
var templateArgumentIndex = 0;
foreach (var templateArgument in templateArguments)
{
var memberExpression = templateArgument.Body as MemberExpression ??
(MemberExpression)((UnaryExpression)templateArgument.Body).Operand;
var member = memberExpression.Member;
var keyOrigin = GetKey(data, member, registration.IsCollection);
var key = templateArgumentIndex == 0 && !linkBuilder.Arguments.Any() ? "id" : keyOrigin;
linkBuilder.Arguments.Add(key, CreateTemplateArgument(key, keyOrigin, ((PropertyInfo)member).PropertyType));
templateArgumentIndex++;
}
return(true);
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder)
{
return(registration.Expression.TemplateParameters != null && registration.Expression.TemplateParameters.Any());
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder)
{
return(!string.IsNullOrWhiteSpace(registration.Relation));
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder)
{
return(registration.ArgumentDefinitions != null && registration.ArgumentDefinitions.Any());
}
/// <summary>
/// Adds an HATEOAS registration
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="registration">HATEOAS registration</param>
public static void AddRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration)
{
var definitions = configuration.GetRegistrationsFor(registration.Model);
definitions.Add(registration);
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> definition, ILinkBuilder linkBuilder, object data)
{
linkBuilder.IsTemplate = definition.Expression.Template;
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder resourceBuilder)
{
return(_argumentDefinitionsProcessor.CanProcess(registration, resourceBuilder) ||
_templateArgumentsProcessor.CanProcess(registration, resourceBuilder) ||
_idFromExpressionProcessor.CanProcess(registration, resourceBuilder));
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> definition, ILinkBuilder linkBuilder, object data)
{
linkBuilder.Success = linkBuilder.Action != null && _authorizationProvider.IsAuthorized(linkBuilder.Action);
}
public void Add(IHateoasRegistration registration)
{
_registrations.Add(registration);
}
public abstract void ProcessInternal <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data);
public abstract bool Process <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data);
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> definition, ILinkBuilder resourceBuilder)
{
return(true);
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder)
{
return(registration.Expression.Command != null);
}
public void Add(IHateoasRegistration registration)
{
//Registrations.Add(registration);
_httpConfiguration.AddRegistration(registration);
}
public override bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder resourceBuilder)
{
var expression = registration.Expression;
return(expression.Controller != null && (expression.Action != null || expression.HttpMethod != null));
}
public void Update(IHateoasRegistration registration)
{
// TODO Move registrations to container (again) and always just update container
//_httpConfiguration.UpdateConfiguration(this);
_httpConfiguration.UpdateRegistration(registration);
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
linkBuilder.Command = registration.Expression.CreateCommand(registration.Relation + "-command");
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder, object data)
{
linkBuilder.Relation = registration.Relation;
linkBuilder.IsMember = registration.IsMember;
}
public override void ProcessInternal <TModel>(IHateoasRegistration <TModel> definition, ILinkBuilder linkBuilder, object data)
{
linkBuilder.Method = definition.Expression.HttpMethod;
}
public abstract bool CanProcess <TModel>(IHateoasRegistration <TModel> registration, ILinkBuilder linkBuilder);
