public async Task Bind(ILinkExchange destination, ILinkExchange source, string routingKey = null,
IDictionary <string, object> arguments = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if (routingKey == null)
{
routingKey = string.Empty;
}
if (arguments == null)
{
arguments = new Dictionary <string, object>();
}
await _invoker
.InvokeAsync(model => model.ExchangeBind(destination.Name, source.Name, routingKey, arguments))
.ConfigureAwait(false);
_logger.Debug(
$"Bound destination exchange {destination.Name} to source exchange {source.Name} with routing key {routingKey} and arguments: {string.Join(", ", arguments.Select(x => $"{x.Key} = {x.Value}"))}");
}
public Task RouteAsync(RouteContext context)
{
String?path = GetPath(context.HttpContext.Request.Path.Value);
if (path == null)
{
throw new InvalidOperationException("Cannot resolve path " + context.HttpContext.Request.Path.Value);
}
IReadOnlyList <ActionDescriptor> candidates = SelectCandidates(_actionDescriptors.Items,
context.HttpContext, context.RouteData.Values, path, context.HttpContext.Request.Method);
if (candidates.Count == 0)
{
return(Task.CompletedTask);
}
if (candidates.Count > 1)
{
throw new InvalidOperationException("Ambiguous action " + path + " " + String.Join(";", candidates.Select(c => c.DisplayName)));
}
context.Handler = async ctx =>
{
var actionContext = new ActionContext(context.HttpContext, ctx.GetRouteData(), candidates[0]);
IActionInvoker actionInvoker = _actionInvokerFactory.CreateInvoker(actionContext);
if (actionInvoker == null)
{
return;
}
await actionInvoker.InvokeAsync().ConfigureAwait(false);
};
return(Task.CompletedTask);
}
/// <summary>
/// Handle exception.
/// </summary>
/// <param name="context">The cu<see cref="Filters.ExceptionContext"/>.</param>
/// <returns>The task to handle exception.</returns>
public override async Task OnExceptionAsync(Filters.ExceptionContext context)
{
Guard.ArgumentNotNull(context, nameof(context));
context.ExceptionHandled = true;
_options = context.HttpContext.RequestServices.GetRequiredService <IOptions <HandleExceptionFilterOptions> >().Value;
if (context.Exception == null)
{
return;
}
ExceptionManager manager = context.HttpContext.RequestServices.GetRequiredService <ExceptionManager>();
string exceptionPolicy = this.GetExceptionPolicy(context);
try
{
if (!string.IsNullOrEmpty(exceptionPolicy))
{
await manager.HandleExceptionAsync(context.Exception, exceptionPolicy);
}
else
{
manager.HandleExceptionAsync(context.Exception).Wait();
}
}
catch (Exception ex)
{
ex = (ex as AggregateException)?.InnerException ?? ex;
var exceptionInfo = new ExceptionInfo(ex, _options.IncludeInnerException);
if (this.TryGetHandlerAction(context, out ActionDescriptor handlerAction))
{
context.HttpContext.SetExceptionInfo(exceptionInfo);
ActionContext actionContext = new ActionContext(context.HttpContext, context.RouteData, handlerAction);
IActionInvoker actionInvoker = context.HttpContext.RequestServices.GetRequiredService <IActionInvokerFactory>().CreateInvoker(actionContext);
await actionInvoker.InvokeAsync();
return;
}
if (context.HttpContext.IsAjaxRequest())
{
JsonResult json = new JsonResult(exceptionInfo, _options.JsonSerializerSettings);
await json.ExecuteResultAsync(new ActionContext(context));
return;
}
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), context.ModelState)
{
Model = exceptionInfo
};
ViewResult view = new ViewResult {
ViewData = viewData
};
await view.ExecuteResultAsync(context);
}
}
public Task RouteAsync(RouteContext context)
{
IReadOnlyList <ActionDescriptor> candidates = _actionSelector.SelectCandidates(context);
if (candidates.Count == 0)
{
String path = GetPath(context.HttpContext.Request.Path.Value);
if (path == null)
{
path = context.HttpContext.Request.Path.Value;
String[] segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
candidates = GetOperationCadidates(segments);
int length = path.Length - segments.Last().Length - 2;
if (length > 0)
{
candidates = candidates.Where(c => String.Compare(c.AttributeRouteInfo.Template, 0, path, 1, length, StringComparison.OrdinalIgnoreCase) == 0).ToList();
}
}
else
{
String[] segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
candidates = SelectCandidates(_actionDescriptorCollectionProvider.ActionDescriptors.Items, segments, context.HttpContext.Request.Method);
if (candidates.Count == 0)
{
candidates = GetOperationCadidates(segments);
}
}
if (candidates.Count == 0)
{
return(Task.CompletedTask);
}
}
ActionDescriptor actionDescriptor = _actionSelector.SelectBestCandidate(context, candidates);
if (actionDescriptor != null)
{
context.Handler = async ctx =>
{
var actionContext = new ActionContext(context.HttpContext, ctx.GetRouteData(), actionDescriptor);
IActionInvoker actionInvoker = _actionInvokerFactory.CreateInvoker(actionContext);
if (actionInvoker == null)
{
return;
}
await actionInvoker.InvokeAsync();
}
}
;
return(Task.CompletedTask);
}
public static HttpHandler to_api_controller <TController>(string prefix = "", RouteValueDictionary defaultRouteValues = null)
{
return(HttpHandler.FromFunc(async ctx =>
{
var currentPath = prefix + GetPath(ctx);
// REVIEW: cache all this?
var appModelProvider = ctx.RequestServices.GetServices <IApplicationModelProvider>().OfType <DefaultApplicationModelProvider>().Single();
ApplicationModelProviderContext appModelProviderCtx = new ApplicationModelProviderContext(new[] { typeof(TController).GetTypeInfo() });
appModelProvider.OnProvidersExecuting(appModelProviderCtx);
var descriptors = ControllerActionDescriptorBuilder.Build(appModelProviderCtx.Result);
var matchedDescriptors = new List <ActionDescriptor>();
var parsedValues = new Dictionary <ActionDescriptor, RouteValueDictionary>();
foreach (var d in descriptors)
{
var templateMatcher = new TemplateMatcher(TemplateParser.Parse(d.AttributeRouteInfo.Template), defaultRouteValues ?? new RouteValueDictionary());
var parsedRouteValues = new RouteValueDictionary();
if (templateMatcher.TryMatch(new PathString(currentPath), parsedRouteValues))
{
matchedDescriptors.Add(d);
parsedValues[d] = parsedRouteValues;
}
}
var actionSelector = ctx.RequestServices.GetRequiredService <IActionSelector>();
var best = actionSelector.SelectBestCandidate(new RouteContext(ctx), matchedDescriptors);
var routeCtx = new RouteContext(ctx);
routeCtx.RouteData.Values.Clear();
foreach (var kv in parsedValues[best])
{
routeCtx.RouteData.Values.Add(kv.Key, kv.Value);
}
var actx = new ActionContext(ctx, routeCtx.RouteData, best);
var actionInvokerProvider = ctx.RequestServices.GetServices <IActionInvokerProvider>().OfType <ControllerActionInvokerProvider>().Single();
var fac = new ActionInvokerFactory(new[] { actionInvokerProvider });
IActionInvoker invoker = fac.CreateInvoker(actx);
await invoker.InvokeAsync();
return true;
}));
}
protected virtual async Task BatchCore()
{
var actionDescriptors = GetService <IActionDescriptorCollectionProvider>().ActionDescriptors;
var actionInvokerFactory = GetService <IActionInvokerFactory>();
String[] apiSegments = base.HttpContext.Request.Path.Value.Split(new[] { '/' }, 2, StringSplitOptions.RemoveEmptyEntries);
Uri baseUri = UriHelper.GetBaseUri(base.Request);
var messageContext = new OeMessageContext(baseUri, EdmModel, DataAdapter.EntitySetMetaAdapters);
OeBatchMessage batchMessage = OeBatchMessage.CreateBatchMessage(messageContext, base.HttpContext.Request.Body, base.HttpContext.Request.ContentType);
Object dataContext = null;
try
{
dataContext = DataAdapter.CreateDataContext();
foreach (OeOperationMessage operation in batchMessage.Changeset)
{
OeEntitySetAdapter entitySetAdapter = DataAdapter.GetEntitySetAdapter(operation.EntityItem.EntitySet.Name);
var segments = new String[apiSegments.Length];
Array.Copy(apiSegments, segments, 1);
segments[apiSegments.Length - 1] = entitySetAdapter.EntitySetMetaAdapter.EntitySetName;
var candidates = OeRouter.SelectCandidates(actionDescriptors.Items, segments, operation.Method);
if (candidates.Count > 1)
{
throw new AmbiguousActionException(String.Join(Environment.NewLine, candidates.Select(c => c.DisplayName)));
}
if (candidates.Count == 0)
{
throw new InvalidOperationException("Action " + operation.Method + " for controller " + segments.Last() + " not found");
}
var modelState = new OeFilterAttribute.BatchModelStateDictionary()
{
Entity = operation.EntityItem.Entity,
DataContext = new OeDataContext(ref entitySetAdapter, dataContext, operation)
};
OnBeforeInvokeController(modelState.DataContext, operation.EntityItem);
var actionContext = new ActionContext(base.HttpContext, base.HttpContext.GetRouteData(), candidates[0], modelState);
IActionInvoker actionInvoker = actionInvokerFactory.CreateInvoker(actionContext);
await actionInvoker.InvokeAsync();
}
await SaveChangesAsync(dataContext).ConfigureAwait(false);
}
finally
{
if (dataContext != null)
{
DataAdapter.CloseDataContext(dataContext);
}
}
base.HttpContext.Response.ContentType = base.HttpContext.Request.ContentType;
var batchWriter = new OeBatchWriter(baseUri, EdmModel);
batchWriter.Write(base.HttpContext.Response.Body, batchMessage);
}
protected virtual async Task BatchCore()
{
var actionDescriptors = GetService <IActionDescriptorCollectionProvider>().ActionDescriptors;
var actionInvokerFactory = GetService <IActionInvokerFactory>();
String basePath = "";
if (base.HttpContext.Request.PathBase.HasValue)
{
basePath = base.HttpContext.Request.PathBase;
}
else
{
int i = base.HttpContext.Request.Path.Value.IndexOf('/', 1);
if (i > 0)
{
basePath = base.HttpContext.Request.Path.Value.Substring(0, i);
}
}
Uri baseUri = UriHelper.GetBaseUri(base.Request);
OeBatchMessage batchMessage = OeBatchMessage.CreateBatchMessage(EdmModel, baseUri, base.HttpContext.Request.Body, base.HttpContext.Request.ContentType);
Object dataContext = null;
try
{
dataContext = DataAdapter.CreateDataContext();
foreach (OeOperationMessage operation in batchMessage.Changeset)
{
OeEntitySetAdapter entitySetAdapter = DataAdapter.EntitySetAdapters.FindByEntitySetName(operation.EntitySet.Name);
String path = basePath + "/" + entitySetAdapter.EntitySetName;
List <ActionDescriptor> candidates = OeRouter.SelectCandidates(actionDescriptors.Items, base.RouteData.Values, path, operation.Method);
if (candidates.Count > 1)
{
throw new AmbiguousActionException(String.Join(Environment.NewLine, candidates.Select(c => c.DisplayName)));
}
if (candidates.Count == 0)
{
throw new InvalidOperationException("Action " + operation.Method + " for controller " + basePath + " not found");
}
Object entity;
if (operation.Method == ODataConstants.MethodPatch)
{
var properties = new Dictionary <String, Object>();
foreach (ODataProperty odataProperty in operation.Entry.Properties)
{
PropertyInfo propertyInfo = entitySetAdapter.EntityType.GetProperty(odataProperty.Name);
properties[odataProperty.Name] = OeEdmClrHelper.GetClrValue(propertyInfo.PropertyType, odataProperty.Value);
}
entity = properties;
}
else
{
entity = OeEdmClrHelper.CreateEntity(entitySetAdapter.EntityType, operation.Entry);
}
var modelState = new OeFilterAttribute.BatchModelStateDictionary()
{
Entity = entity,
DataContext = new OeDataContext(entitySetAdapter, EdmModel, dataContext, operation)
};
OnBeforeInvokeController(modelState.DataContext, operation.Entry);
var actionContext = new ActionContext(base.HttpContext, base.HttpContext.GetRouteData(), candidates[0], modelState);
IActionInvoker actionInvoker = actionInvokerFactory.CreateInvoker(actionContext);
await actionInvoker.InvokeAsync();
}
await SaveChangesAsync(dataContext).ConfigureAwait(false);
}
finally
{
if (dataContext != null)
{
DataAdapter.CloseDataContext(dataContext);
}
}
base.HttpContext.Response.ContentType = base.HttpContext.Request.ContentType;
var batchWriter = new OeBatchWriter(EdmModel, baseUri);
batchWriter.Write(base.HttpContext.Response.Body, batchMessage);
}
public static Task <T> InvokeAsync <TActor, T>(this IActionInvoker <TActor> @this, Func <TActor, T> action)
{
return(@this.InvokeAsync(action, CancellationToken.None));
}
protected virtual async Task BatchCore()
{
String basePath = "";
if (base.HttpContext.Request.PathBase.HasValue)
{
basePath = base.HttpContext.Request.PathBase;
}
else
{
if (base.HttpContext.Request.Path.Value != null)
{
int i = base.HttpContext.Request.Path.Value.IndexOf('/', 1);
if (i > 0)
{
basePath = base.HttpContext.Request.Path.Value.Substring(0, i);
}
}
}
Uri baseUri = UriHelper.GetBaseUri(base.Request);
OeBatchMessage batchMessage = await OeBatchMessage.CreateBatchMessageAsync(EdmModel, baseUri,
base.HttpContext.Request.Body, base.HttpContext.Request.ContentType, OeParser.ServiceProvider);
if (batchMessage.Changeset == null)
{
return;
}
OeDataAdapter?dataAdapter = null;
Object? dataContext = null;
ActionDescriptorCollection actionDescriptors = GetService <IActionDescriptorCollectionProvider>().ActionDescriptors;
IActionInvokerFactory actionInvokerFactory = GetService <IActionInvokerFactory>();
try
{
IEdmModel?refModel = null;
foreach (OeOperationMessage operation in batchMessage.Changeset)
{
if (dataContext == null)
{
refModel = EdmModel.GetEdmModel(operation.EntitySet.Container);
dataAdapter = refModel.GetDataAdapter(operation.EntitySet.Container);
dataContext = dataAdapter.CreateDataContext();
}
OeEntitySetAdapter entitySetAdapter = refModel !.GetEntitySetAdapter(operation.EntitySet);
Object entity = OeDataContext.CreateEntity(operation, entitySetAdapter.EntityType);
if (operation.Method == ODataConstants.MethodPatch)
{
base.HttpContext.Request.Method = HttpMethods.Patch;
}
var oeDataContext = new OeDataContext(entitySetAdapter, refModel !, dataContext, operation);
var modelState = new OeBatchFilterAttributeAttribute.BatchModelStateDictionary(dataAdapter !, oeDataContext, entity);
OnBeforeInvokeController(modelState.DataContext, operation.Entry);
String path = basePath + "/" + entitySetAdapter.EntitySetName;
List <ActionDescriptor> candidates = OeRouter.SelectCandidates(actionDescriptors.Items, base.HttpContext, base.RouteData.Values, path, operation.Method);
if (candidates.Count > 1)
{
throw new InvalidOperationException("Ambiguous action " + String.Join(Environment.NewLine, candidates.Select(c => c.DisplayName)));
}
if (candidates.Count == 0)
{
throw new InvalidOperationException("Action " + operation.Method + " for controller " + basePath + " not found");
}
var actionContext = new ActionContext(base.HttpContext, base.HttpContext.GetRouteData(), candidates[0], modelState);
IActionInvoker actionInvoker = actionInvokerFactory.CreateInvoker(actionContext);
await actionInvoker.InvokeAsync().ConfigureAwait(false);
}
if (dataAdapter != null && dataContext != null)
{
await SaveChangesAsync(dataContext).ConfigureAwait(false);
foreach (OeOperationMessage operation in batchMessage.Changeset)
{
dataAdapter.EntitySetAdapters.Find(operation.EntitySet).UpdateEntityAfterSave(dataContext, operation.Entry);
}
}
}
finally
{
if (dataAdapter != null && dataContext != null)
{
dataAdapter.CloseDataContext(dataContext);
}
}
base.HttpContext.Response.ContentType = base.HttpContext.Request.ContentType;
var batchWriter = new OeBatchWriter(EdmModel, baseUri);
await batchWriter.WriteBatchAsync(base.HttpContext.Response.Body, batchMessage);
}