public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
return new List<Type>
{
typeof (FooBarBazQuxController)
};
}
public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
return this.httpControllerTypeResolvers
.SelectMany(a => a.GetControllerTypes(assembliesResolver))
.Distinct()
.ToList();
}
static AssembliesResolver()
{
var resolver = new ResourceAssemblyResolver();
resourceAssemblyResolver = resolver;
AppDomain.CurrentDomain.AssemblyResolve += (s, e) => resolver.OnAssemblyResolve(e);
}
public ICollection<Type> GetControllerTypes(IAssembliesResolver _)
{
var httpControllerType = typeof(IHttpController);
return typeof(WebApiConfig)
.Assembly
.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract && httpControllerType.IsAssignableFrom(t))
.ToList();
}
/// <summary>
/// Returns a list of handlers available for the application.
/// </summary>
/// <param name="assembliesResolver">
/// The <see cref="IAssembliesResolver"/>.
/// </param>
/// <returns>
/// An <see cref="ICollection{Type}"/> of handlers.
/// </returns>
public ICollection<Type> GetCommandHandlerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
return this.GetHandlerTypes(assembliesResolver);
}
/// <summary>
/// Returns a list of handlers available for the application.
/// </summary>
/// <param name="assembliesResolver">
/// The <see cref="IAssembliesResolver"/>.
/// </param>
/// <returns>
/// An <see cref="ICollection{Type}"/> of handlers.
/// </returns>
public IEnumerable<Type> GetEventHandlerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
return this.GetHandlerTypes(assembliesResolver);
}
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
var list = base.GetControllerTypes(assembliesResolver).ToList();
var dynamicApis = ApiConfig.DynamicApiAssembly.GetTypes();
list.AddRange(dynamicApis); //Dynamic de sadece api controller olur.
return list;
}
public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw new ArgumentNullException("assembliesResolver");
}
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
return (_controllerTypes ?? (_controllerTypes = GetControllerTypesInternal(assemblies))).ToList();
}
public HttpControllerTypeCache(HttpConfiguration configuration)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
_configuration = configuration;
_assembliesResolver = _configuration.ServiceResolver.GetAssembliesResolver();
_controllersResolver = _configuration.ServiceResolver.GetHttpControllerTypeResolver();
_cache = InitializeCache();
}
private static HttpSelfHostConfiguration CrearConfiguracion(String baseAddress, IAssembliesResolver assemblyResovler)
{
var config = new HttpSelfHostConfiguration(baseAddress);
config.Services.Replace(typeof(IAssembliesResolver), assemblyResovler);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: ConfigurationManager.AppSettings["routeTemplate"],
defaults: new { id = RouteParameter.Optional }
);
return config;
}
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType,
IEdmModel model, TransformationNode transformation)
: base(model, assembliesResolver, settings)
{
Contract.Assert(elementType != null);
Contract.Assert(transformation != null);
_elementType = elementType;
_transformation = transformation;
this._lambdaParameter = Expression.Parameter(this._elementType, "$it");
switch (transformation.Kind)
{
case TransformationNodeKind.Aggregate:
var aggregateClause = this._transformation as AggregateTransformationNode;
_aggregateExpressions = aggregateClause.Expressions;
ResultClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model, null,
_aggregateExpressions);
break;
case TransformationNodeKind.GroupBy:
var groupByClause = this._transformation as GroupByTransformationNode;
_groupingProperties = groupByClause.GroupingProperties;
if (groupByClause.ChildTransformations != null)
{
if (groupByClause.ChildTransformations.Kind == TransformationNodeKind.Aggregate)
{
_aggregateExpressions =
((AggregateTransformationNode)groupByClause.ChildTransformations).Expressions;
}
else
{
throw new NotImplementedException();
}
}
_groupByClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model,
_groupingProperties, null);
ResultClrType = AggregationDynamicTypeProvider.GetResultType<DynamicTypeWrapper>(_model,
_groupingProperties, _aggregateExpressions);
break;
default:
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
SRResources.NotSupportedTransformationKind, transformation.Kind));
}
_groupByClrType = _groupByClrType ?? typeof(DynamicTypeWrapper);
}
private static Dictionary <Type, List <Type> > BuildDerivedTypesMapping(IAssembliesResolver assemblyResolver)
{
IEnumerable <Type> allTypes = TypeHelper.GetLoadedTypes(assemblyResolver).Where(t => t.IsVisible && t.IsClass && t != typeof(object));
Dictionary <Type, List <Type> > allTypeMapping = allTypes.ToDictionary(k => k, k => new List <Type>());
foreach (Type type in allTypes)
{
List <Type> derivedTypes;
if (type.BaseType != null && allTypeMapping.TryGetValue(type.BaseType, out derivedTypes))
{
derivedTypes.Add(type);
}
}
return(allTypeMapping);
}
// Trace beginning and end of GetControllerTypes() invocations. Error tracing should never occur since base
// implementation swallows all exceptions.
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
ICollection <Type> result = null;
_traceWriter.TraceBeginEnd(request: null,
category: TraceCategories.ControllersCategory,
level: TraceLevel.Debug,
operatorName: _innerTypeName,
operationName: "GetControllerTypes",
beginTrace: null,
execute: () => { result = _innerResolver.GetControllerTypes(assembliesResolver); },
endTrace: null,
errorTrace: null);
return(result);
}
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
var controllerTypes = base.GetControllerTypes(assembliesResolver);
var dynamicControllerTypes = _dynamicAssembliesResolver
.GetDynamicAssemblies()
.SelectMany(x => x.GetTypes())
.Where(x => IsControllerTypePredicate(x));
foreach (var dynamicControllerType in dynamicControllerTypes)
{
controllerTypes.Add(dynamicControllerType);
}
return controllerTypes;
}
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType,
IEdmModel model, TransformationNode transformation)
: base(model, assembliesResolver, settings)
{
Contract.Assert(elementType != null);
Contract.Assert(transformation != null);
this._elementType = elementType;
this._transformation = transformation;
this._lambdaParameter = Expression.Parameter(this._elementType, "$it");
switch (transformation.Kind)
{
case TransformationNodeKind.Aggregate:
var aggregateClause = this._transformation as AggregateTransformationNode;
this._aggregateExpressions = this.FixCustomMethodReturnTypes(aggregateClause.Expressions);
this.ResultClrType = typeof(NoGroupByAggregationWrapper);
break;
case TransformationNodeKind.GroupBy:
var groupByClause = this._transformation as GroupByTransformationNode;
this._groupingProperties = groupByClause.GroupingProperties;
if (groupByClause.ChildTransformations != null)
{
if (groupByClause.ChildTransformations.Kind == TransformationNodeKind.Aggregate)
{
var aggregationNode = (AggregateTransformationNode)groupByClause.ChildTransformations;
this._aggregateExpressions = this.FixCustomMethodReturnTypes(aggregationNode.Expressions);
}
else
{
throw new NotImplementedException();
}
}
this._groupByClrType = typeof(GroupByWrapper);
this.ResultClrType = typeof(AggregationWrapper);
break;
default:
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
SRResources.NotSupportedTransformationKind, transformation.Kind));
}
this._groupByClrType = this._groupByClrType ?? typeof(NoGroupByWrapper);
}
private ConcurrentDictionary <string, HttpControllerDescriptor> InitializeControllerInfoCache()
{
var result = new ConcurrentDictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
var duplicateControllers = new HashSet <string>();
IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
var groupedByName = controllerTypes.GroupBy(
t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length),
StringComparer.OrdinalIgnoreCase);
var _controllerTypeCacheCache = groupedByName.ToDictionary(
g => g.Key,
g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase),
StringComparer.OrdinalIgnoreCase);
Dictionary <string, ILookup <string, Type> > controllerTypeGroups = _controllerTypeCacheCache;
foreach (KeyValuePair <string, ILookup <string, Type> > controllerTypeGroup in controllerTypeGroups)
{
string controllerName = controllerTypeGroup.Key;
foreach (IGrouping <string, Type> controllerTypesGroupedByNs in controllerTypeGroup.Value)
{
foreach (Type controllerType in controllerTypesGroupedByNs)
{
if (result.Keys.Contains(controllerName))
{
duplicateControllers.Add(controllerName);
break;
}
else
{
result.TryAdd(controllerName, new HttpControllerDescriptor(_configuration, controllerName, controllerType));
}
}
}
}
foreach (string duplicateController in duplicateControllers)
{
HttpControllerDescriptor descriptor;
result.TryRemove(duplicateController, out descriptor);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from
/// the <see cref="ODataQueryContext"/>.
/// </summary>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information.</param>
/// <param name="request">The incoming request message.</param>
public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
if (request.GetConfiguration() != null)
{
_assembliesResolver = request.GetConfiguration().Services.GetAssembliesResolver();
}
// fallback to the default assemblies resolver if none available.
_assembliesResolver = _assembliesResolver ?? new DefaultAssembliesResolver();
// remember the context and request
Context = context;
Request = request;
// Parse the query from request Uri
RawValues = new ODataRawQueryOptions();
IDictionary <string, string> queryParameters =
request.GetQueryNameValuePairs().ToDictionary(p => p.Key, p => p.Value);
_queryOptionParser = new ODataQueryOptionParser(
context.Model,
context.ElementType,
context.NavigationSource,
queryParameters);
HttpConfiguration configuration = Request.GetConfiguration();
if (configuration != null)
{
ODataUriResolverSetttings resolverSettings = configuration.GetResolverSettings();
_queryOptionParser.Resolver = resolverSettings.CreateResolver(context.Model);
}
BuildQueryOptions(queryParameters);
Validator = new ODataQueryValidator();
}
/// <summary>
/// 初始化字典
/// </summary>
/// <returns></returns>
private Dictionary <string, HttpControllerDescriptor> InitializeControllerDictionary()
{
var dictionary = new Dictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
// Create a lookup table where key is "namespace.controller". The value of "namespace" is the last
// segment of the full namespace. For example:
// MyApplication.Controllers.V1.ProductsController => "V1.Products"
IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
foreach (Type t in controllerTypes)
{
if (t.Namespace != null)
{
var segments = t.Namespace.Split(Type.Delimiter);
// For the dictionary key, strip "Controller" from the end of the type name.
// This matches the behavior of DefaultHttpControllerSelector.
var controllerName = t.Name.Remove(t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length);
string version = segments[segments.Length - 1];
var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", version, controllerName);
if (version == "Controllers")
{
key = String.Format(CultureInfo.InvariantCulture, "{0}", controllerName);
}
// Check for duplicate keys.
if (dictionary.Keys.Contains(key))
{
_duplicates.Add(key);
}
else
{
dictionary[key] = new HttpControllerDescriptor(_configuration, t.Name, t);
}
}
}
// Remove any duplicates from the dictionary, because these create ambiguous matches.
// For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products".
foreach (string s in _duplicates)
{
dictionary.Remove(s);
}
return(dictionary);
}
public SelectExpandBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver,
SelectExpandQueryOption selectExpandQuery)
{
Contract.Assert(settings != null);
Contract.Assert(assembliesResolver != null);
Contract.Assert(selectExpandQuery != null);
Contract.Assert(selectExpandQuery.Context != null);
Contract.Assert(selectExpandQuery.Context.Model != null);
Contract.Assert(settings.HandleNullPropagation != HandleNullPropagationOption.Default);
_selectExpandQuery = selectExpandQuery;
_context = selectExpandQuery.Context;
_model = _context.Model;
_modelID = ModelContainer.GetModelID(_model);
_settings = settings;
_assembliesResolver = assembliesResolver;
}
/// <summary>
/// Initializes a new <see cref="OwinRestService"/>.
/// </summary>
/// <param name="kernel">Ninject kernel instance.</param>
/// <param name="logService">Service used for logging.</param>
/// <param name="configStore">Configuration storage instance.</param>
/// <param name="antFactory">Factory used for instantiating <see cref="IAnt"/>.</param>
/// <param name="assembliesResolverFactory">Factory used for instantiating <see cref="IAssembliesResolver"/>.</param>
public OwinRestService(
IKernel kernel,
ILog logService,
IConfigStore configStore,
IAntFactory antFactory,
IAssembliesResolverFactory assembliesResolverFactory)
{
hostKernel = new ChildKernel(kernel);
this.logService = logService;
this.configStore = configStore;
this.antFactory = antFactory;
assembliesResolver = assembliesResolverFactory
.CreateNew(typeof(OwinRestService).Assembly);
}
public virtual ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
List <Type> result = new List <Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetTypes on a null (or dynamic?) assembly
continue;
}
try
{
exportedTypes = _getTypesFunc(assembly);
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
// We deliberately ignore all exceptions when building the cache. If
// a controller type is not found then we will respond later with a 404.
// However, until then we don't know whether an exception at all will
// have an impact on finding a controller.
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(x => TypeIsVisible(x) && IsControllerTypePredicate(x)));
}
}
return(result);
}
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
List <Type> list = new List <Type>();
var controllerType = typeof(System.Web.Http.Controllers.IHttpController);
if (Directory.Exists(contollerPath))
{
foreach (var dllFile in Directory.GetFiles(contollerPath, "*.dll"))
{
Assembly assembly = Assembly.LoadFrom(dllFile);
var types = assembly.GetExportedTypes();
list.AddRange(types.Where(i => controllerType.IsAssignableFrom(i)).ToList());
}
}
return(list);
}
public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
List<Type> result = new List<Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetExportedTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
// We deliberately ignore all exceptions when building the cache. If
// a controller type is not found then we will respond later with a 404.
// However, until then we don't know whether an exception at all will
// have an impact on finding a controller.
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(x => IsControllerTypePredicate(x)));
}
}
return result;
}
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
var ret = base.GetControllerTypes(assembliesResolver);
var parts = _container.Catalog.Parts.Where(
partDef =>
partDef.ExportDefinitions.Any(
p => string.Equals(p.ContractName, ContractNames.ApiController, StringComparison.Ordinal)));
foreach (var composablePartDefinition in parts)
{
// TODO this isn't fantastic as it makes a lot of assumption about the CPD
var lazyType = ReflectionModelServices.GetPartType(composablePartDefinition);
ret.Add(lazyType.Value);
}
return(ret);
}
public override HttpControllerDescriptor SelectController(HttpRequestMessage request)
{
var controllerName = base.GetControllerName(request);
if (controllerName.Contains("_"))
{
IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver httpControllerTypeResolver = this._configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = httpControllerTypeResolver.GetControllerTypes(assembliesResolver);
controllerName = controllerName.Replace("_", "");
var matchedController =
controllerTypes.FirstOrDefault(i => i.Name.ToLower() == controllerName.ToLower() + "controller");
return(new HttpControllerDescriptor(_configuration, controllerName, matchedController));
}
return(base.SelectController(request));
}
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
var ret = base.GetControllerTypes(assembliesResolver);
var parts = _container.Catalog.Parts.Where(
partDef =>
partDef.ExportDefinitions.Any(
p => string.Equals(p.ContractName, ContractNames.ApiController, StringComparison.Ordinal)));
foreach (var composablePartDefinition in parts)
{
// TODO this isn't fantastic as it makes a lot of assumption about the CPD
var lazyType = ReflectionModelServices.GetPartType(composablePartDefinition);
ret.Add(lazyType.Value);
}
return ret;
}
private Dictionary <string, Dictionary <string, HttpControllerDescriptor> > InitializeCache()
{
IAssembliesResolver assembliesResolver = this._configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver httpControllerTypeResolver = this._configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = httpControllerTypeResolver.GetControllerTypes(assembliesResolver);
IEnumerable <IGrouping <string, Type> > source = controllerTypes.GroupBy(t =>
t.Name.EndsWith(NamespaceControllerSelector.ControllerSuffix, StringComparison.OrdinalIgnoreCase) ?
t.Name.Substring(0, t.Name.Length - NamespaceControllerSelector.ControllerSuffix.Length)
: t.Name, StringComparer.OrdinalIgnoreCase);
return(source.ToDictionary(g => g.Key, g => g.ToDictionary(
t => t.Namespace ?? string.Empty,
t => new HttpControllerDescriptor(this._configuration, g.Key, t),
StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase));
}
internal AggregationBinder(ODataQuerySettings settings, IAssembliesResolver assembliesResolver, Type elementType, IEdmModel model, TransformationNode transformation)
: base(model, assembliesResolver, settings)
{
Contract.Assert(elementType != null);
Contract.Assert(transformation != null);
_elementType = elementType;
_transformation = transformation;
this._lambdaParameter = Expression.Parameter(this._elementType, "$it");
switch (transformation.Kind)
{
case TransformationNodeKind.Aggregate:
var aggregateClause = this._transformation as AggregateTransformationNode;
_aggregateStatements = aggregateClause.Statements;
ResultClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, null, _aggregateStatements);
break;
case TransformationNodeKind.GroupBy:
var groupByClause = this._transformation as GroupByTransformationNode;
_groupingProperties = groupByClause.GroupingProperties;
if (groupByClause.ChildTransformation != null)
{
if (groupByClause.ChildTransformation.Kind == TransformationNodeKind.Aggregate)
{
_aggregateStatements = ((AggregateTransformationNode)groupByClause.ChildTransformation).Statements;
}
else
{
throw new NotImplementedException();
}
}
_groupByClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, _groupingProperties, null);
ResultClrType = AggregationDynamicTypeProvider.GetResultType <DynamicTypeWrapper>(_model, _groupingProperties, _aggregateStatements);
break;
default:
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, SRResources.NotSupportedTransformationKind, transformation.Kind));
}
_groupByClrType = _groupByClrType ?? typeof(DynamicTypeWrapper);
}
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw new ArgumentNullException(nameof(assembliesResolver));
}
var result = new List <Type>();
result.AddRange(base.GetControllerTypes(assembliesResolver));
var assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies.Where(assembly => (assembly == null || assembly.IsDynamic) && _dynamicAssemblies.Contains(assembly)))
{
result.AddRange(assembly.GetTypes().Where(x => !result.Contains(x)).Where(x => IsControllerTypePredicate(x)).ToArray());
}
return(result);
}
/// <summary>
/// Returns a list of controllers available for the application.
/// </summary>
/// <returns>An <see cref="ICollection{Type}" /> of controllers.</returns>
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
HttpControllerTypeCacheSerializer serializer = new HttpControllerTypeCacheSerializer();
// First, try reading from the cache on disk
List<Type> matchingTypes = ReadTypesFromCache(TypeCacheName, IsControllerTypePredicate, serializer);
if (matchingTypes != null)
{
return matchingTypes;
}
// If reading from the cache failed, enumerate over every assembly looking for a matching type
matchingTypes = base.GetControllerTypes(assembliesResolver).ToList();
// Finally, save the cache back to disk
SaveTypesToCache(TypeCacheName, matchingTypes, serializer);
return matchingTypes;
}
public ICollection<Type> GetHandlerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
List<Type> result = new List<Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
// We deliberately ignore all exceptions when building the cache.
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(type => TypeIsVisible(type) && this.isHandlerTypePredicate(type)));
}
}
return result;
}
private ConcurrentDictionary <string, HttpControllerDescriptor> InitializeControllerInfoCache()
{
var result = new ConcurrentDictionary <string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
// Create a lookup table where key is "version.controller". The value of "version" is the last
// segment of the full namespace. For example:
// MyApplication.Controllers.V1.ProductsController => "V1.Products"
IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
foreach (Type controllerType in controllerTypes)
{
var segments = controllerType.Namespace.Split(Type.Delimiter);
// For the dictionary key, strip "Controller" from the end of the type name.
// This matches the behavior of DefaultHttpControllerSelector.
var controllerName = controllerType.Name.Remove(controllerType.Name.Length - ControllerSuffix.Length);
var key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", segments[segments.Length - 1], controllerName);
// Check for duplicate keys.
if (result.Keys.Contains(key))
{
_duplicateControllers.Add(key);
}
else
{
result.TryAdd(key, new HttpControllerDescriptor(_configuration, controllerName, controllerType));
}
}
// Remove any duplicates from the dictionary, because these create ambiguous matches.
// For example, "Foo.V1.ProductsController" and "Bar.V1.ProductsController" both map to "v1.products".
foreach (string duplicateController in _duplicateControllers)
{
HttpControllerDescriptor descriptor;
result.TryRemove(duplicateController, out descriptor);
}
return(result);
}
public ICollection <Type> GetHandlerTypes(IAssembliesResolver assembliesResolver)
{
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
List <Type> result = new List <Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
// We deliberately ignore all exceptions when building the cache.
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(type => TypeIsVisible(type) && this.isHandlerTypePredicate(type)));
}
}
return(result);
}
/// <summary>
/// Returns a list of controllers available for the application.
/// </summary>
/// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns>
public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
// Go through all assemblies referenced by the application and search for types matching a predicate
IEnumerable<Type> typesSoFar = Type.EmptyTypes;
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
typesSoFar = typesSoFar.Concat(assembly.GetExportedTypes());
}
return typesSoFar.Where(x => IsControllerTypePredicate(x)).ToList();
}
protected static TestServer CreateTestServer(IAssembliesResolver assembliesResolver, Action <Type, IFilter> filterProvider, Func <Type, object> dependencyResolver, string baseUrl = "http://localhost")
{
var testServer = TestServer.Create(app =>
{
var config = new HttpConfiguration();
config.Services.Replace(typeof(IAssembliesResolver), assembliesResolver);
WebApiConfig.Register(config);
config.Services.Add((typeof(IFilterProvider)), new DelegateFilterProvider(filterProvider));
config.DependencyResolver = new DelegateDependencyResolver(dependencyResolver);
app.UseWebApi(config);
});
testServer.BaseAddress = new Uri(baseUrl);
return(testServer);
}
/// <summary>
/// Initializes a new instance of the routing configuration class.
/// </summary>
/// <returns>A new instance of the routing configuration class.</returns>
internal static IWebApiAssembliesResolver Create(MockAssembly assembly = null)
{
IAssembliesResolver resolver = null;
if (assembly != null)
{
resolver = new TestAssemblyResolver(assembly);
}
else
{
Mock <IAssembliesResolver> mockAssembliesResolver = new Mock <IAssembliesResolver>();
mockAssembliesResolver
.Setup(r => r.GetAssemblies())
.Returns(new Assembly[0]);
resolver = mockAssembliesResolver.Object;
}
return(new WebApiAssembliesResolver(resolver));
}
private ConcurrentDictionary <string, HttpControllerDescriptor> InitTypeCache()
{
IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();
ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
var dict = new ConcurrentDictionary <string, HttpControllerDescriptor>();
foreach (Type type in controllerTypes)
{
if (type.FullName != null)
{
string controllerName = type.Name.Substring(0, type.Name.Length - ControllerSuffix.Length);
dict.TryAdd(type.FullName.ToLowerInvariant(), new HttpControllerDescriptor(_configuration, controllerName, type));
}
}
return(dict);
}
private Dictionary <ControllerIdentification, ILookup <string, Type> > InitializeCache()
{
IAssembliesResolver assembliesResolver = this._configuration.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllersResolver =
this._configuration.Services.GetHttpControllerTypeResolver();
IControllerIdentificationDetector controllerIdentificationDetector =
this._configuration.DependencyResolver.GetControllerIdentificationDetector();
// group controllers by name
ICollection <Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
IEnumerable <IGrouping <ControllerIdentification, Type> > groupedByName =
controllerTypes.Select(
x => new { ClrType = x, Id = controllerIdentificationDetector.GetIdentification(x) })
.GroupBy(x => x.Id, x => x.ClrType);
return(groupedByName.ToDictionary(
g => g.Key,
g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase),
ControllerIdentification.Comparer));
}
/// <summary>
/// Returns a list of controllers available for the application.
/// </summary>
/// <returns>An <see cref="ICollection{Type}" /> of controllers.</returns>
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
HttpControllerTypeCacheSerializer serializer = new HttpControllerTypeCacheSerializer();
// First, try reading from the cache on disk
List <Type> matchingTypes = ReadTypesFromCache(TypeCacheName, IsControllerTypePredicate, serializer);
if (matchingTypes != null)
{
return(matchingTypes);
}
// If reading from the cache failed, enumerate over every assembly looking for a matching type
matchingTypes = base.GetControllerTypes(assembliesResolver).ToList();
// Finally, save the cache back to disk
SaveTypesToCache(TypeCacheName, matchingTypes, serializer);
return(matchingTypes);
}
/// <summary>
/// Returns a list of controllers available for the application.
/// </summary>
/// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns>
public virtual ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
// Go through all assemblies referenced by the application and search for types matching a predicate
IEnumerable <Type> typesSoFar = Type.EmptyTypes;
ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
typesSoFar = typesSoFar.Concat(assembly.GetExportedTypes());
}
return(typesSoFar.Where(x => IsControllerTypePredicate(x)).ToList());
}
internal static HashSet <string> GetMobileAppControllerNames(this HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
IAssembliesResolver assemblyResolver = config.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllerTypeResolver = config.Services.GetHttpControllerTypeResolver();
Type[] controllerTypes = controllerTypeResolver.GetControllerTypes(assemblyResolver).ToArray();
// Add controllers that have the MobileAppController attribute
IEnumerable <string> matches = controllerTypes
.Where(t => t.GetCustomAttributes(typeof(MobileAppControllerAttribute), true).Any())
.Select(t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length));
HashSet <string> result = new HashSet <string>(matches, StringComparer.OrdinalIgnoreCase);
return(result);
}
public ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
return(new Type[] {
typeof(ActivitiesController),
typeof(AlarmsController),
typeof(AuthenticationController),
typeof(ConfigurationController),
typeof(ContainersController),
typeof(DocumentationController),
typeof(EventsController),
typeof(FilesController),
typeof(ManifestsController),
typeof(ReportsController),
typeof(PlanNodesController),
typeof(PlansController),
typeof(TerminalsController),
typeof(UsersController),
typeof(WarehousesController),
typeof(WebServicesController)
});
}
/// <summary>
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static HashSet <string> GetTableControllerNames(this HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
IAssembliesResolver assemblyResolver = config.Services.GetAssembliesResolver();
IHttpControllerTypeResolver controllerTypeResolver = config.Services.GetHttpControllerTypeResolver();
Type[] controllerTypes = controllerTypeResolver.GetControllerTypes(assemblyResolver).ToArray();
// Add controllers deriving from TableController
IEnumerable <string> matches = controllerTypes
.Where(t => typeof(TableController).IsAssignableFrom(t))
.Select(t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length));
HashSet <string> result = new HashSet <string>(matches, StringComparer.OrdinalIgnoreCase);
return(result);
}
public override ICollection <Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
HashSet <Type> allControllers = base.GetControllerTypes(assembliesResolver).ToHashSet();
Dictionary <string, BinaryContentUtils.DbBinaryConfig> proxyBinaryConfigs = new Dictionary <string, BinaryContentUtils.DbBinaryConfig>();
// load controllers from dependencies
HashSet <IScreenControllerProxy> visited = new HashSet <IScreenControllerProxy>();
foreach (var controller in allControllers.ToArray())
{
var controllerProxy = ScreenServicesApiController.TryGetControllerProxy(controller);
if (controllerProxy != null)
{
CollectDependenciesControllerTypesAndBinaryConfigs(controllerProxy, visited, allControllers, proxyBinaryConfigs);
}
}
ScreenServicesApiController.SetDatabaseBinaries(proxyBinaryConfigs);
return(allControllers);
}
/// <summary>
/// Activa la configuración para diagnosticar la inicialización del WebApi.
/// </summary>
/// <param name="config">Objeto con la configuración del WebApi</param>
private static void EnabelDiagnosticWebApi(HttpConfiguration config)
{
IAssembliesResolver assembliesResolver = config.Services.GetAssembliesResolver();
ICollection <Assembly> assemblies = assembliesResolver.GetAssemblies();
StringBuilder errorsBuilder = new StringBuilder();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetExportedTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch (Exception ex)
{
errorsBuilder.AppendLine(ex.ToString());
}
}
if (errorsBuilder.Length > 0)
{
//Log errors into Event Log
Trace.TraceError(errorsBuilder.ToString());
}
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
//config.EnableSystemDiagnosticsTracing();
//var ev = new System.Diagnostics.EventLogTraceListener();
}
// This code is copied from DefaultHttpControllerTypeResolver.GetControllerTypes.
internal static IEnumerable <Type> GetLoadedTypes(IAssembliesResolver assembliesResolver)
{
Contract.Requires(assembliesResolver != null);
var result = new List <Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
var assemblies = assembliesResolver.GetAssemblies();
Contract.Assume(assemblies != null);
foreach (var assembly in assemblies)
{
Type[] exportedTypes;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetTypes on a null (or dynamic?) assembly
continue;
}
try
{
exportedTypes = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(t => t != null && t.IsVisible));
}
}
return(result);
}
public IQueryable ApplyTo(IQueryable query, IAssembliesResolver assembliesResolver)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
if (assembliesResolver == null)
{
throw new ArgumentNullException("assembliesResolver");
}
var typeQuery = query as IQueryable <T>;
if (typeQuery == null)
{
return(query);
}
var facetFields = RawValue.Split(',');
return(facetFields.Aggregate(typeQuery, (current, facetField) => current.FacetOn(GenerateMemberExpression <string>(facetField), 1)));
}
internal static IEnumerable<Type> GetLoadedTypes(IAssembliesResolver assembliesResolver)
{
List<Type> result = new List<Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetExportedTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(t => t != null));
}
}
return result;
}
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
Contract.Requires(edmTypeReference != null);
Contract.Requires(edmModel != null);
Contract.Requires(assembliesResolver != null);
var primitiveClrType = BuiltInTypesMapping.Where(kvp => edmTypeReference.GetDefinition().IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key))).Select(kvp => kvp.Key).FirstOrDefault();
if (primitiveClrType != null)
{
return primitiveClrType;
}
var edmType = edmTypeReference.GetDefinition();
Contract.Assume(edmType is IEdmSchemaType);
var clrType = GetClrType(edmType, edmModel, assembliesResolver);
if (clrType != null && clrType.IsEnum && edmTypeReference.IsNullable)
{
return clrType.ToNullable();
}
return clrType;
}
private static IEnumerable<Type> GetMatchingTypes(string edmFullName, IAssembliesResolver assembliesResolver)
{
return TypeHelper.GetLoadedTypes(assembliesResolver).Where(t => t.IsPublic && t.EdmFullName() == edmFullName);
}
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType;
Contract.Assert(edmSchemaType != null);
ClrTypeAnnotation annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmSchemaType);
if (annotation != null)
{
return annotation.ClrType;
}
string typeName = edmSchemaType.FullName();
IEnumerable<Type> matchingTypes = GetMatchingTypes(typeName, assembliesResolver);
if (matchingTypes.Count() > 1)
{
throw Error.Argument("edmTypeReference", SRResources.MultipleMatchingClrTypesForEdmType,
typeName, String.Join(",", matchingTypes.Select(type => type.AssemblyQualifiedName)));
}
edmModel.SetAnnotationValue<ClrTypeAnnotation>(edmSchemaType, new ClrTypeAnnotation(matchingTypes.SingleOrDefault()));
return matchingTypes.SingleOrDefault();
}
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
if (edmTypeReference == null)
{
throw Error.ArgumentNull("edmTypeReference");
}
Type primitiveClrType = _builtInTypesMapping
.Where(kvp => edmTypeReference.Definition.IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key)))
.Select(kvp => kvp.Key)
.FirstOrDefault();
if (primitiveClrType != null)
{
return primitiveClrType;
}
else
{
Type clrType = GetClrType(edmTypeReference.Definition, edmModel, assembliesResolver);
if (clrType != null && clrType.IsEnum && edmTypeReference.IsNullable)
{
return clrType.ToNullable();
}
return clrType;
}
}
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
var controllers = base.GetControllerTypes(assembliesResolver);
controllers = this.resolver(controllers);
return controllers;
}
/// <summary>
/// Apply the apply query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssembliesResolver assembliesResolver)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (querySettings == null)
{
throw Error.ArgumentNull("querySettings");
}
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
ApplyClause applyClause = ApplyClause;
Contract.Assert(applyClause != null);
// Ensure we have decided how to handle null propagation
ODataQuerySettings updatedSettings = querySettings;
if (querySettings.HandleNullPropagation == HandleNullPropagationOption.Default)
{
updatedSettings = new ODataQuerySettings(updatedSettings);
updatedSettings.HandleNullPropagation = HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query);
}
foreach (var transformation in applyClause.Transformations)
{
if (transformation.Kind == TransformationNodeKind.Aggregate || transformation.Kind == TransformationNodeKind.GroupBy)
{
var binder = new AggregationBinder(updatedSettings, assembliesResolver, ResultClrType, Context.Model, transformation as TransformationNode);
query = binder.Bind(query);
this.ResultClrType = binder.ResultClrType;
}
else if (transformation.Kind == TransformationNodeKind.Filter)
{
var filterTransformation = transformation as FilterTransformationNode;
Expression filter = FilterBinder.Bind(filterTransformation.FilterClause, ResultClrType, Context.Model, assembliesResolver, updatedSettings);
query = ExpressionHelpers.Where(query, filter, ResultClrType);
}
}
return query;
}
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
Contract.Requires(edmType is IEdmSchemaType);
Contract.Requires(edmModel != null);
Contract.Requires(assembliesResolver != null);
var edmSchemaType = (IEdmSchemaType) edmType;
var annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmSchemaType);
if (annotation != null)
{
return annotation.ClrType;
}
var typeName = edmSchemaType.FullName();
var matchingTypes = GetMatchingTypes(typeName, assembliesResolver);
var matchingTypesList = matchingTypes as IList<Type> ?? matchingTypes.ToList();
if (matchingTypesList.Count > 1)
{
throw new Exception("Multiple Matching ClrTypes For EdmType");
}
edmModel.SetAnnotationValue(edmSchemaType, new ClrTypeAnnotation(matchingTypesList.SingleOrDefault()));
return matchingTypesList.SingleOrDefault();
}
public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
{
Contract.Invariant(_controllerTypes != null);
return _controllerTypes;
}
/// <summary>
/// Applies the $select and $expand query options to the given entity using the given <see cref="ODataQuerySettings"/>.
/// </summary>
/// <param name="entity">The original entity.</param>
/// <param name="settings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param>
/// <returns>The new entity after the $select and $expand query has been applied to.</returns>
public object ApplyTo(object entity, ODataQuerySettings settings, IAssembliesResolver assembliesResolver)
{
if (entity == null)
{
throw Error.ArgumentNull("entity");
}
if (settings == null)
{
throw Error.ArgumentNull("settings");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
// Ensure we have decided how to handle null propagation
ODataQuerySettings updatedSettings = settings;
if (settings.HandleNullPropagation == HandleNullPropagationOption.Default)
{
updatedSettings = new ODataQuerySettings(updatedSettings);
updatedSettings.HandleNullPropagation = HandleNullPropagationOption.True;
}
return SelectExpandBinder.Bind(entity, updatedSettings, assembliesResolver, this);
}
public static Type GetClrType(IEdmTypeReference edmTypeReference, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
if (edmTypeReference == null)
{
throw Error.ArgumentNull("edmTypeReference");
}
Type primitiveClrType = _builtInTypesMapping
.Where(kvp => edmTypeReference.Definition.IsEquivalentTo(kvp.Value) && (!edmTypeReference.IsNullable || IsNullable(kvp.Key)))
.Select(kvp => kvp.Key)
.FirstOrDefault();
if (primitiveClrType != null)
{
return primitiveClrType;
}
else
{
ClrTypeAnnotation annotation = edmModel.GetAnnotationValue<ClrTypeAnnotation>(edmTypeReference.Definition);
if (annotation != null)
{
return annotation.ClrType;
}
IEnumerable<Type> matchingTypes = GetMatchingTypes(edmTypeReference.FullName(), assembliesResolver);
if (matchingTypes.Count() > 1)
{
throw Error.Argument("edmTypeReference", SRResources.MultipleMatchingClrTypesForEdmType,
edmTypeReference.FullName(), String.Join(",", matchingTypes.Select(type => type.AssemblyQualifiedName)));
}
edmModel.SetAnnotationValue<ClrTypeAnnotation>(edmTypeReference.Definition, new ClrTypeAnnotation(matchingTypes.SingleOrDefault()));
return matchingTypes.SingleOrDefault();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from
/// the <see cref="ODataQueryContext"/>.
/// </summary>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information</param>
/// <param name="request">The incoming request message</param>
public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
if (request.GetConfiguration() != null)
{
_assembliesResolver = request.GetConfiguration().Services.GetAssembliesResolver();
}
// fallback to the default assemblies resolver if none available.
_assembliesResolver = _assembliesResolver ?? new DefaultAssembliesResolver();
// remember the context
Context = context;
// Parse the query from request Uri
RawValues = new ODataRawQueryOptions();
IEnumerable<KeyValuePair<string, string>> queryParameters = request.GetQueryNameValuePairs();
foreach (KeyValuePair<string, string> kvp in queryParameters)
{
switch (kvp.Key)
{
case "$filter":
RawValues.Filter = kvp.Value;
ThrowIfEmpty(kvp.Value, "$filter");
Filter = new FilterQueryOption(kvp.Value, context);
break;
case "$orderby":
RawValues.OrderBy = kvp.Value;
ThrowIfEmpty(kvp.Value, "$orderby");
OrderBy = new OrderByQueryOption(kvp.Value, context);
break;
case "$top":
RawValues.Top = kvp.Value;
ThrowIfEmpty(kvp.Value, "$top");
Top = new TopQueryOption(kvp.Value, context);
break;
case "$skip":
RawValues.Skip = kvp.Value;
ThrowIfEmpty(kvp.Value, "$skip");
Skip = new SkipQueryOption(kvp.Value, context);
break;
case "$select":
RawValues.Select = kvp.Value;
break;
case "$inlinecount":
RawValues.InlineCount = kvp.Value;
break;
case "$expand":
RawValues.Expand = kvp.Value;
break;
case "$skiptoken":
RawValues.SkipToken = kvp.Value;
break;
default:
// we don't throw if we can't recognize the query
break;
}
}
}
/// <summary>
/// Apply the filter query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assembliesResolver">The <see cref="IAssembliesResolver"/> to use.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssembliesResolver assembliesResolver)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (querySettings == null)
{
throw Error.ArgumentNull("querySettings");
}
if (assembliesResolver == null)
{
throw Error.ArgumentNull("assembliesResolver");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
FilterClause filterClause = FilterClause;
Contract.Assert(filterClause != null);
// Ensure we have decided how to handle null propagation
ODataQuerySettings updatedSettings = querySettings;
if (querySettings.HandleNullPropagation == HandleNullPropagationOption.Default)
{
updatedSettings = new ODataQuerySettings(updatedSettings);
updatedSettings.HandleNullPropagation = HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query);
}
Expression filter = FilterBinder.Bind(filterClause, Context.ElementClrType, Context.Model, assembliesResolver, updatedSettings);
query = ExpressionHelpers.Where(query, filter, Context.ElementClrType);
return query;
}
