Exemple #1
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            //config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
            //config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
            config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
            config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));

            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
            config.Formatters.JsonFormatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local;
            config.Formatters.JsonFormatter.SerializerSettings.DateFormatString = "yyyy-MM-ddTHH:mm:ss";
            
            config.AddODataQueryFilter();
            //Odata case insensitive
            config.EnableCaseInsensitive(true);

        }
Exemple #2
0
        private static void SetResolverSettings( this HttpConfiguration configuration, IODataPathHandler pathHandler )
        {
            Contract.Requires( configuration != null );

            // REMARKS: the DefaultODataPathHandler.ResolverSettings property is internal as is the ODataUriResolverSetttings class.
            // The MapODataServiceRoute normally hooks this up, but we are replacing that process. in order to retain functional
            // fidelity we'll build and compile a strong-typed delegate that can be used to set the property.
            //
            // in additional, the ODataUriResolverSetttings are created lazy-initialized from the property bag. instead of using
            // Reflection, we'll test for the known key. if the key is not present, we'll use a public extension method
            // (e.g. EnableCaseInsensitive) with the default, unconfigured value. this will trigger the creation of the
            // settings and populate the property.

            var handler = pathHandler as DefaultODataPathHandler;

            if ( handler == null )
            {
                return;
            }

            // REMARKS: this creates and populates the ODataUriResolverSetttings; OData URLs are case-sensitive by default.
            if ( !configuration.Properties.ContainsKey( ResolverSettingsKey ) )
            {
                configuration.EnableCaseInsensitive( false );
            }

            setResolverSettings.Value( handler, configuration.Properties[ResolverSettingsKey] );
        }
        public static void UpdateConfiguration(HttpConfiguration config)
        {
            var controllers = new[] { typeof(CustomersController), typeof(OrdersController), typeof(AddressesController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));

            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            config.Services.Replace(typeof(IAssembliesResolver), resolver);

            config.EnableCaseInsensitive(true);

            config.Routes.Clear();
            config.MapODataServiceRoute("odata", "", GetModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
        }
        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            var controllers = new[] { typeof(CustomersController), typeof(OrdersController), typeof(MetadataController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));

            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.Services.Replace(typeof(IAssembliesResolver), resolver);

            configuration.EnableCaseInsensitive(true);

            configuration.Routes.Clear();

            configuration.MapODataServiceRoute(routeName: "odata",
                routePrefix: "odata", model: UriParserExtenstionEdmModel.GetEdmModel());

            configuration.EnsureInitialized();
        }
        public void EnableCaseInsensitive_Sets_KeyWordAndMetadataFlag()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();

            // Act
            config.EnableCaseInsensitive(caseInsensitive: true);
            ODataUriResolverSetttings resolverSetttings = config.GetResolverSettings();

            // Assert
            Assert.True(resolverSetttings.CaseInsensitive);
        }
Exemple #6
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            config.EnableSystemDiagnosticsTracing();
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            // Web API routes
            config.MapHttpAttributeRoutes();

            //// OData configuration
            //ODataModelBuilder builder = new ODataConventionModelBuilder();

            //builder.Namespace = typeof(Team).Namespace;

            //builder.EntitySet<Team>("Teams")
            //    .EntityType
            //        .HasKey(t => t.Number);
            //builder.EntitySet<Event>("Events")
            //    .EntityType
            //        .HasKey(e => e.Sku)
            //        .ContainsMany(e => e.Divisions);
            //builder.EntityType<Division>()
            //        .HasKey(d => d.EventSku)
            //        .HasKey(d => d.Name);
            //// Add additional entity sets

            //var model = builder.GetEdmModel();
            ///*
            //var events = (EdmEntitySet)model.EntityContainer.FindEntitySet("Events");
            //var divisions = (EdmEntitySet)model.EntityContainer.FindEntitySet("Divisions");
            //var divisionsProperty = new EdmNavigationPropertyInfo
            //{
            //    TargetMultiplicity = Microsoft.OData.Edm.EdmMultiplicity.Many,
            //    Target = (EdmEntityType)model.FindDeclaredType(typeof(Division).FullName),
            //    ContainsTarget = true,
            //    OnDelete = Microsoft.OData.Edm.EdmOnDeleteAction.Cascade,
            //    Name = "Divisions"
            //};
            //events.AddNavigationTarget(((EdmEntityType)model.FindDeclaredType(typeof(Event).FullName)).AddUnidirectionalNavigation(divisionsProperty), events);
            //*/
            //var conventions = ODataRoutingConventions.CreateDefaultWithAttributeRouting(config, model);
            //// Add additional routing conventions
            //conventions.Insert(0, new NavigationIndexRoutingConvention());

            //config.MapODataServiceRoute(
            //    routeName: "ODataRoute",
            //    routePrefix: null,
            //    model: model,
            //    routingConventions: conventions,
            //    pathHandler: new DefaultODataPathHandler());

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            config.EnableCaseInsensitive(true);

            //config.Services.Replace(typeof(IHttpControllerSelector), new HttpControllerSelector(config));
            //config.Services.Replace(typeof())
        }
        private static ODataQueryOptions GetQueryOptions(string queryOption)
        {
            string uri = "Http://localhost/RoutingCustomers?" + queryOption;

            HttpConfiguration configuration = new HttpConfiguration();
            configuration.EnableCaseInsensitive(true);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            request.SetConfiguration(configuration);

            IEdmModel model = ODataRoutingModel.GetModel();

            IEdmEntitySet entityset = model.EntityContainer.FindEntitySet("RoutingCustomers");
            IEdmEntityType entityType =
                model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "RoutingCustomer");

            ODataPath path = new ODataPath(new[] { new EntitySetPathSegment(entityset) });
            ODataQueryContext context = new ODataQueryContext(model, entityType, path);
            return new ODataQueryOptions(context, request);
        }