protected override object OnGetArgument(HandlerParameter parameter, PomonaContext context, object state)
 {
     if (parameter == this.resourceParameter)
     {
         return(context.Node.Value);
     }
     return(base.OnGetArgument(parameter, context, state));
 }
 protected override object OnGetArgument(HandlerParameter parameter, PomonaContext context, InvokeState state)
 {
     if (parameter == this.targetResourceParameter)
     {
         return(context.Node.Value);
     }
     if (parameter == this.formParameter)
     {
         return(state.Form);
     }
     return(base.OnGetArgument(parameter, context, state));
 }
        public HandlerMethodTakingExistingResource(HandlerMethod method, ResourceType resourceType)
            : base(method)
        {
            if (resourceType == null)
            {
                throw new ArgumentNullException(nameof(resourceType));
            }
            this.resourceParameter =
                method.Parameters.LastOrDefault(x => x.Type == resourceType) ??
                method.Parameters.LastOrDefault(x => x.IsResource && x.Type.IsAssignableFrom(resourceType));

            if (this.resourceParameter == null)
            {
                throw new ArgumentException("Method has no argument accepting resource type.", nameof(method));
            }
        }
        protected override object OnGetArgument(HandlerParameter parameter, PomonaContext context, object state)
        {
            var node = context.Node;
            var resourceResultType = node.Route.ResultItemType as ResourceType;

            if (resourceResultType != null)
            {
                var primaryIdType = resourceResultType.PrimaryId.PropertyType;
                if (parameter.Type == primaryIdType)
                {
                    object parsedId;
                    if (!node.PathSegment.TryParse(primaryIdType, out parsedId))
                    {
                        throw new HandlerMethodInvocationException(context, this, "Unable to parse id from url segment");
                    }
                    return(parsedId);
                }
            }
            return(base.OnGetArgument(parameter, context, state));
        }
 public HandlerMethodTakingFormInvoker(HandlerMethod method,
                                       HandlerParameter formParameter,
                                       HandlerParameter targetResourceParameter = null)
     : base(method)
 {
     if (formParameter == null)
     {
         throw new ArgumentNullException(nameof(formParameter));
     }
     if (formParameter.Method != method)
     {
         throw new ArgumentException("Parameter provided does not belong to method.", nameof(formParameter));
     }
     if (targetResourceParameter != null && targetResourceParameter.Method != method)
     {
         throw new ArgumentException("Parameter provided does not belong to method.", nameof(targetResourceParameter));
     }
     this.formParameter           = formParameter;
     this.targetResourceParameter = targetResourceParameter;
 }
示例#6
0
        protected virtual object OnGetArgument(HandlerParameter parameter, PomonaContext context, TInvokeState state)
        {
            if (parameter.IsResource)
            {
                var parentNode = context
                                 .Node
                                 .Ascendants()
                                 .FirstOrDefault(x => x.ResultType == parameter.TypeSpec);
                if (parentNode != null)
                {
                    return(parentNode.Value);
                }
            }

            if (parameter.Type == typeof(PomonaContext))
            {
                return(context);
            }

            Exception innerEx = null;

            try
            {
                // Never get value of transformed type parameter from IOC container
                if (!parameter.Type.IsValueType && !parameter.IsTransformedType)
                {
                    return(context.Session.GetInstance(parameter.Type));
                }
            }
            catch (Exception ex)
            {
                innerEx = ex;
            }
            throw new HandlerMethodInvocationException(context,
                                                       this,
                                                       $"Unable to invoke handler {Method.MethodInfo.ReflectedType}.{Method.Name}, don't know how to provide value for parameter {parameter.Name}",
                                                       innerEx);
        }