public override void DispatchToHandlerWith(Context context, Action.MappedParameters mappedParameters)
        {
            Action <SseStreamResource> consumer = null;

            try
            {
                switch (mappedParameters.ActionId)
                {
                case 0:     // GET /eventstreams/{streamName}
                    consumer = handler => handler.SubscribeToStream(
                        (string)mappedParameters.Mapped[0].Value,
                        (Type)mappedParameters.Mapped[1].Value,
                        (int)mappedParameters.Mapped[2].Value,
                        (int)mappedParameters.Mapped[3].Value,
                        (string)mappedParameters.Mapped[4].Value);

                    PooledHandler.HandleFor(context, consumer);
                    break;

                case 1:     // DELETE /eventstreams/{streamName}/{id}
                    consumer = handler => handler.UnsubscribeFromStream(
                        (string)mappedParameters.Mapped[0].Value,
                        (string)mappedParameters.Mapped[1].Value);

                    PooledHandler.HandleFor(context, consumer);
                    break;
                }
            }
            catch (Exception ex)
            {
                throw new ArgumentException($"Action mismatch: Request: {context.Request} Parameters: {mappedParameters}", ex);
            }
        }
    internal override ICompletes <Response> Execute(
        Request request,
        Action.MappedParameters mappedParameters,
        ILogger logger)
    {
        var param1 = ResolverParam1.Apply(request, mappedParameters);
        var param2 = ResolverParam2.Apply(request, mappedParameters);

        return(Execute(request, param1, param2, logger));
    }
Beispiel #3
0
        public void HandleFor(Context context, Action.MappedParameters mappedParameters, RequestHandler handler)
        {
            Action <ResourceHandler> consumer = resource =>
                                                handler
                                                .Execute(context.Request !, mappedParameters, resource.Logger !)
                                                .AndThen(outcome => RespondWith(context, outcome))
                                                .Otherwise <Response>(failure => RespondWith(context, failure))
                                                .RecoverFrom(exception => Response.Of(ResponseStatus.BadRequest, exception.Message));

            HandleFor(context, consumer);
        }
    internal override ICompletes <Response> Execute(
        Request request,
        Action.MappedParameters mappedParameters,
        ILogger logger)
    {
        var param1 = ResolverParam1.Apply(request, mappedParameters);
        var param2 = ResolverParam2.Apply(request, mappedParameters);
        var param3 = ResolverParam3.Apply(request, mappedParameters);
        var param4 = ResolverParam4.Apply(request, mappedParameters);
        var param5 = ResolverParam5.Apply(request, mappedParameters);
        var param6 = ResolverParam6.Apply(request, mappedParameters);
        var param7 = ResolverParam7.Apply(request, mappedParameters);

        return(Execute(request, param1, param2, param3, param4, param5, param6, param7, logger));
    }
Beispiel #5
0
 public void HandleFor(Context context, Action.MappedParameters mappedParameters, RequestHandler handler)
 {
     if (!_actor.IsStopped)
     {
         Action <IResourceRequestHandler> cons128873 = __ => __.HandleFor(context, mappedParameters, handler);
         if (_mailbox.IsPreallocated)
         {
             _mailbox.Send(_actor, cons128873, null, HandleForRepresentation2);
         }
         else
         {
             _mailbox.Send(
                 new LocalMessage <IResourceRequestHandler>(_actor, cons128873,
                                                            HandleForRepresentation2));
         }
     }
     else
     {
         _actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, HandleForRepresentation2));
     }
 }
 public T Apply(Request?request, Action.MappedParameters mappedParameters)
 => _resolver.Invoke(request !, mappedParameters);
 object IParameterResolver.Apply(Request request, Action.MappedParameters mappedParameters)
 => _resolver.Invoke(request, mappedParameters) !;
Beispiel #8
0
 internal override ICompletes <Response> Execute(Request request, Action.MappedParameters mappedParameters, ILogger logger)
 => Execute(request, logger);
 internal abstract ICompletes <Response> Execute(
     Request request,
     Action.MappedParameters mappedParameters,
     ILogger logger);