/// <summary>
/// Creates view model filter delegate that runs before it is requested/updated.
/// </summary>
/// <param name="hubContext">DotNetify hub context.</param>
/// <param name="hubPipeline">Middleware/VM filter pipeline.</param>
/// <returns>View model filter delegate.</returns>
private VMController.FilterDelegate CreateVMFilter(DotNetifyHubContext hubContext, IHubPipeline hubPipeline)
{
return(async(vmId, vm, data, vmAction) =>
{
try
{
hubContext.Data = data;
await hubPipeline.RunVMFiltersAsync(hubContext, vm, async ctx =>
{
await vmAction(ctx.HubContext.Data);
});
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
});
}
/// <summary>
/// Invokes middleware.
/// </summary>
/// <param name="hubContext">DotNetify hub context.</param>
/// <param name="next">Next middleware delegate.</param>
public Task Invoke(DotNetifyHubContext hubContext, NextDelegate next)
{
try
{
var headers = ParseHeaders <HeaderData>(hubContext.Headers);
if (headers?.Authorization?.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase) == true)
{
var token = headers.Authorization.Substring("Bearer ".Length).Trim();
hubContext.Principal = new JwtSecurityTokenHandler().ValidateToken(token, _tokenValidationParameters, out SecurityToken validatedToken);
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
return(next(hubContext));
}
public override Task Invoke(DotNetifyHubContext hubContext, NextDelegate next)
{
if (hubContext.Headers != null)
{
try
{
ValidateBearerToken(ParseHeaders <HeaderData>(hubContext.Headers), out SecurityToken validatedToken);
if (validatedToken != null)
{
hubContext.PipelineData.Add("AccessToken", validatedToken);
}
}
catch (Exception)
{
}
}
return(next(hubContext));
}
/// <summary>
/// Creates view model filter delegate that runs before it is requested/updated.
/// </summary>
/// <param name="hubContext">DotNetify hub context.</param>
/// <param name="hubPipeline">Middleware/VM filter pipeline.</param>
/// <returns>View model filter delegate.</returns>
private VMController.FilterDelegate CreateVMFilter(DotNetifyHubContext hubContext, IHubPipeline hubPipeline)
{
return((vmId, vm, data, vmAction) =>
{
try
{
hubContext.Data = data;
hubPipeline.RunVMFilters(hubContext, vm, ctx =>
{
vmAction(ctx.HubContext.Data);
return Task.CompletedTask;
});
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
});
}
public async Task <string> Request_VM(
string vmId,
[FromQuery] string vmArg,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor
)
{
var taskCompletionSource = new TaskCompletionSource <string>();
var vmController = new VMController((arg1, arg2, arg3) => taskCompletionSource.TrySetResult(arg3), vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmArg)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
hubPipeline.RunMiddlewares(hubContext, ctx =>
{
vmController.OnRequestVM(connectionId, ctx.VMId, ctx.Data);
vmController.Dispose();
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
var finalEx = hubPipeline.RunExceptionMiddleware(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource.Task);
}
/// <summary>
/// Invokes middleware.
/// </summary>
/// <param name="context">DotNetify hub context.</param>
/// <param name="next">Next middleware delegate.</param>
public Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
// Set initial headers from previously cached headers.
context.Headers = _headersCache.Get(_headersKey(context.CallerContext.ConnectionId));
var tuple = ExtractHeaders(context.Data);
if (tuple.Item1 != null)
{
context.Headers = tuple.Item1;
_headersCache.Set(_headersKey(context.CallerContext.ConnectionId), context.Headers);
}
context.Data = tuple.Item2;
// If the incoming message is only for updating the headers, no need to continue down the pipeline.
if (context.Data == null && context.CallType == nameof(DotNetifyHub.Update_VM))
{
return(Task.CompletedTask);
}
return(next(context));
}
/// <summary>
/// Invokes middleware.
/// </summary>
/// <param name="context">DotNetify hub context.</param>
/// <param name="next">Next middleware delegate.</param>
public Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
// Make sure the data is JObject.
context.Data = NormalizeType(context);
// Skip if context already has headers (in the case of Web API mode).
if (context.Headers != null)
{
return(next(context));
}
// Set initial headers from previously cached headers.
if (context.CallerContext != null)
{
context.Headers = _headersCache.Get(_headersKey(context.ConnectionId));
}
var tuple = ExtractHeaders(context.Data);
if (tuple.Item1 != null)
{
context.Headers = tuple.Item1;
if (context.CallerContext != null)
{
_headersCache.Set(_headersKey(context.ConnectionId), context.Headers);
}
}
context.Data = tuple.Item2;
// If the incoming message is only for updating the headers, no need to continue down the pipeline.
if (context.Data == null && context.CallType == nameof(DotNetifyHub.Update_VM))
{
return(Task.CompletedTask);
}
return(next(context));
}
internal VMContext(DotNetifyHubContext hubContext, BaseVM instance)
{
HubContext = hubContext;
Instance = instance;
}
public Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
throw new OperationCanceledException();
}
public virtual Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
Invoked?.Invoke(this, context);
context.PipelineData.Add(GetType().Name, null);
return(next(context));
}
public Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
_eventAggregator.Context = context.CallerContext.ConnectionId;
return(next(context));
}
public async Task <string> Update_VM(
string vmId,
[FromQuery] string vmArg,
[FromBody] Dictionary <string, object> vmData,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor)
{
var taskCompletionSource1 = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
var taskCompletionSource2 = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
Task responseVM(string arg1, string arg2, string arg3)
{
if (!taskCompletionSource1.TrySetResult(arg3))
{
taskCompletionSource2.TrySetResult(arg3);
}
return(Task.CompletedTask);
}
var vmController = new VMController(responseVM, vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmData)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
await hubPipeline.RunMiddlewaresAsync(hubContext, async ctx =>
{
await vmController.OnRequestVMAsync(connectionId, ctx.VMId, ctx.Data);
});
}
catch (Exception ex)
{
var finalEx = await hubPipeline.RunExceptionMiddlewareAsync(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource1.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
await taskCompletionSource1.Task;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Update_VM), vmId, vmData, BuildHeaders(), httpCallerContext.User);
vmController.UpdateVMFilter = CreateVMFilter(hubContext, hubPipeline);
await hubPipeline.RunMiddlewaresAsync(hubContext, async ctx =>
{
await vmController.OnUpdateVMAsync(connectionId, ctx.VMId, ctx.Data as Dictionary <string, object>);
vmController.Dispose();
});
}
catch (Exception ex)
{
var finalEx = await hubPipeline.RunExceptionMiddlewareAsync(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource2.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource2.Task);
}
public Task Invoke(DotNetifyHubContext context, NextDelegate next)
{
return(Task.CompletedTask);
}
