Ejemplo n.º 1
1
        public static void RegisterWebApiRoutes(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "AccountApi",
                routeTemplate: "api/account/{action}/{id}",
                defaults: new { controller = "Account",  id = RouteParameter.Optional }
            );

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

            config.Routes.MapHttpRoute(
                name: "BreezeDefault",
                routeTemplate: "breeze/{action}",
                defaults: new { Controller = "Metadata" }
            );

            config.Routes.MapHttpRoute(
                name: "BreezeModule",
                routeTemplate: "breeze/{controller}/{action}"
            );

            config.EnableQuerySupport();
        }
Ejemplo n.º 2
0
        public void Configuration(IAppBuilder appBuilder)
        {
            HttpConfiguration config = new HttpConfiguration ();

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

            config.Routes.MapHttpRoute(
                name: "GenericDataApi",
                routeTemplate: "{controller}/{database}/{collection}/{id}",  // controller always == "data"
                defaults: new { id = RouteParameter.Optional }
            );

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

            //config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new DynamicBsonDocumentJsonConverter());
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new BsonDocumentJsonConverter());
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new CursorJsonConverter());

            config.EnableQuerySupport();

            appBuilder.UseWebApi (config);
        }
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
            name: "UsersApi",
            routeTemplate: "api/users/{action}",
            defaults: new
            {
                controller = "users"
            });

            config.Routes.MapHttpRoute(
            name: "CommentsApi",
            routeTemplate: "api/comments/{action}",
            defaults: new
            {
                controller = "comments"
            });

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

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }
Ejemplo n.º 4
0
        public static void Register(HttpConfiguration config)
        {
            ODataModelBuilder builder = new ODataConventionModelBuilder();

            //builder.EntitySet<Entities.Models.Customer>(typeof(Entities.Models.Customer).Name);
            //builder.EntitySet<Entities.Models.Order>(typeof(Entities.Models.Order).Name);

            //var orderDetailBuilder = builder.EntitySet<Entities.Models.OrderDetail>(typeof(Entities.Models.OrderDetail).Name);
            //orderDetailBuilder.EntityType.HasKey(x => x.ProductID);

            //var customerDemographicBuilder = builder.EntitySet<Entities.Models.CustomerDemographic>(typeof(Entities.Models.CustomerDemographic).Name);
            //customerDemographicBuilder.EntityType.HasKey(x => x.CustomerDesc);

            //var productBuilder = builder.EntitySet<Entities.Models.Product>(typeof(Entities.Models.Product).Name);
            //productBuilder.EntityType.HasKey(t => t.ProductID);

            //builder.EntitySet<Entities.Models.Category>(typeof(Entities.Models.Category).Name);
            //builder.EntitySet<Entities.Models.Supplier>(typeof(Entities.Models.Supplier).Name);

            //builder.EntitySet<Entities.Models.Employee>(typeof(Entities.Models.Employee).Name);
            //builder.EntitySet<Entities.Models.Shipper>(typeof(Entities.Models.Shipper).Name);

        //    var model = builder.GetEdmModel();
         //   config.Routes.MapODataRoute("odata", "odata", model);

            config.EnableQuerySupport();
        }
Ejemplo n.º 5
0
        public static void Register(HttpConfiguration config)
        {
            //config.Routes.MapHttpRoute(
            //    name: "DefaultApi",
            //    routeTemplate: "api/{controller}/{id}",
            //    defaults: new { id = RouteParameter.Optional }
            //);

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            //config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            //config.EnableSystemDiagnosticsTracing();

            ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<QueueModel>("Queues");
            modelBuilder.EntitySet<QueueDetailModel>("QueueDetails");
            //modelBuilder.EntitySet<TestModel>("Test");
            modelBuilder.EntitySet<CaseModel>("Cases");
            modelBuilder.EntitySet<CaseSummaryModel>("CasesSummary");
            modelBuilder.EntitySet<CaseNotesModel>("CasesNotes");
            modelBuilder.EntitySet<IssueWIModel>("IssueWI");
            modelBuilder.EntitySet<QueueActivityModel>("QueueActivity");
            modelBuilder.EntitySet<EmployeeDetailModel>("EmployeeDetails");

            Microsoft.Data.Edm.IEdmModel model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute("OdataRoute", "hapi", model);
            config.EnableQuerySupport();
        }
    public static void Register(HttpConfiguration config)
    {
        config.MapHttpAttributeRoutes();

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

        //config.EnableQuerySupport(queryAttribute);
        //config.AddODataQueryFilter();
        // System.Web.Http.OData.Extensions

        //System.Web.Http.OData.Extensions.HttpConfigurationExtensions
        //    .AddODataQueryFilter(config);

        config.EnableQuerySupport();

        config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling =
            Newtonsoft.Json.ReferenceLoopHandling.Ignore;

        GlobalConfiguration.Configuration
                   .Formatters
                   .XmlFormatter.SetSerializer<IQueryable<object> >(
                       new DataContractSerializer(typeof(IQueryable<object>)));
    }
Ejemplo n.º 7
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "AccountApi",
                routeTemplate: "api/account/{action}/{id}",
                defaults: new { controller = "Account",  id = RouteParameter.Optional }
            );

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

            config.Routes.MapHttpRoute(
                name: "BreezeDefault",
                routeTemplate: "breeze/{action}",
                defaults: new { Controller = "Metadata" }
            );

            config.Routes.MapHttpRoute(
                name: "BreezeModule",
                routeTemplate: "breeze/{controller}/{action}"
            );

            config.EnableQuerySupport();

            config.Filters.Add(new AuthorizeAttribute());
            if (!HttpContext.Current.IsDebuggingEnabled)
            {
                config.Filters.Add(new RequireHttpsAttribute());
            }
        }
Ejemplo n.º 8
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new {id = RouteParameter.Optional}
                );

            config.EnableQuerySupport();
            config.EnableSystemDiagnosticsTracing();

            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
             new CamelCasePropertyNamesContractResolver();

            var builder = new ContainerBuilder();

            builder.RegisterType<ToDoItemMap>().As<IMap<ToDoItem, ToDoItemDto>>();

            var webApiAssembly = Assembly.Load("WebApi");
            builder.RegisterApiControllers(webApiAssembly);

            var dataAssembly = Assembly.Load("Data");
            builder.RegisterAssemblyTypes(dataAssembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces()
                .InstancePerApiRequest();

            var container = builder.Build();
            var resolver = new AutofacWebApiDependencyResolver(container);
            config.DependencyResolver = resolver;
        }
        public static void Register(HttpConfiguration config)
        {
            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            // Add $format support
            config.MessageHandlers.Add(new FormatQueryMessageHandler());

            // Add NavigationRoutingConvention2 to support POST, PUT, PATCH and DELETE on navigation property
            var conventions = ODataRoutingConventions.CreateDefault();
            conventions.Insert(0, new CustomNavigationRoutingConvention());

            // Enables OData support by adding an OData route and enabling querying support for OData.
            // Action selector and odata media type formatters will be registered in per-controller configuration only
            config.Routes.MapODataRoute(
                routeName: "OData",
                routePrefix: null,
                model: ModelBuilder.GetEdmModel(),
                pathHandler: new DefaultODataPathHandler(),
                routingConventions: conventions);

            // Enable queryable support and allow $format query
            config.EnableQuerySupport(new QueryableAttribute
            {
                AllowedQueryOptions = AllowedQueryOptions.Supported | AllowedQueryOptions.Format
            });

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            config.Filters.Add(new ModelValidationFilterAttribute());
        }
Ejemplo n.º 10
0
        /// <summary>
        ///     Configures http message handlers.
        /// </summary>
        /// <param name="configuration"></param>
        public static void Configure(HttpConfiguration configuration)
        {
            // Attribute routes
            configuration.MapHttpAttributeRoutes();

            // Message handlers
            configuration.MessageHandlers.Add(new MethodOverrideHandler());
            configuration.MessageHandlers.Add(new UserAgentOverrideHandler());
            configuration.MessageHandlers.Add(new CancelledTaskBugWorkaroundMessageHandler());

            // Media type formatters
            configuration.Formatters.Clear();
            configuration.Formatters.Add(new JsonMediaTypeFormatter { SerializerSettings = { ContractResolver = new CamelCasePropertyNamesContractResolver() } });
            configuration.Formatters.Add(new FormUrlEncodedMediaTypeFormatter());
            configuration.Formatters.Add(new JQueryMvcFormUrlEncodedFormatter());
            configuration.Formatters.Add(new MultipartFormFormatter());
            configuration.Formatters.Add(new AnyOtherTypeFormFormatter());
            configuration.Formatters.Add(new ProjectForAdminCsvFormatter());
            configuration.Formatters.Add(new UserForAdminCsvFormatter());
            configuration.Formatters.Add(new ClientForAdminCsvFormatter());

            // CORS support
            configuration.EnableQuerySupport();
            configuration.EnableCors();
        }
Ejemplo n.º 11
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            var corsConfig = new EnableCorsAttribute("*", "*", "*");
            //corsConfig.SupportsCredentials = true;   //not allowed with * origin
            config.EnableCors(corsConfig);

            config.EnableQuerySupport();

            config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
            config.Formatters.JsonFormatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
            config.Formatters.JsonFormatter.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = false });
            config.Formatters.Remove(config.Formatters.XmlFormatter);

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
Ejemplo n.º 12
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<FontInfo>("FontInfo");
            modelBuilder.EntitySet<FontSummary>("FontSummary");
            IEdmModel model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute(routeName: "odataFontInfo", routePrefix: "o", model: model);

            //ODataConventionModelBuilder fsBuilder = new ODataConventionModelBuilder();
            //fsBuilder.EntitySet<FontSummary>("FontSummary");
            //IEdmModel fsModel = fsBuilder.GetEdmModel();
            //config.Routes.MapODataRoute(routeName: "routeTwo", routePrefix: "o2", model: fsModel);

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();
            config.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create());

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }
Ejemplo n.º 13
0
        private void RegisterRoutes(HttpConfiguration config)
        {
            config.EnableQuerySupport();

            var modelBuilder = new ODataConventionModelBuilder();
            SetEntity(modelBuilder);
            SetAction(modelBuilder);
            var model = modelBuilder.GetEdmModel();

            config.Routes.MapODataRoute(
                routeName: "OData",
                routePrefix: "odata",
                model: model);

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

            config.EnableCors(new EnableCorsAttribute("*", "*", "*", "authorization"));

            //使OData Action支持CORS
            config.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create());
        }
Ejemplo n.º 14
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 }
            );

            var cors = new EnableCorsAttribute("*", "*", "*");
            config.EnableCors(cors);

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            //config.EnableQuerySupport();

            var modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<Song>("Songs");
            modelBuilder.EntitySet<Artist>("Artists");
            modelBuilder.EntitySet<Album>("Albums");

            var json = config.Formatters.JsonFormatter;
            json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;

            var model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute("odata", "odata", model);
            config.EnableQuerySupport();
        }
Ejemplo n.º 15
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            //var json = config.Formatters.JsonFormatter;
            //json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
            //config.Formatters.Remove(config.Formatters.XmlFormatter);

            //config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            //config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; 
            //config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
        }
Ejemplo n.º 16
0
        public static void Register(HttpConfiguration config)
        {
            ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
            modelBuilder.EntitySet<Post>("Posts");

            Microsoft.Data.Edm.IEdmModel model = modelBuilder.GetEdmModel();
            config.Routes.MapODataRoute("ODataRoute", "odata", model);

            config.EnableQuerySupport();

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

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            //config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }
Ejemplo n.º 17
0
        public HttpConfiguration Configure(HttpConfiguration config)
        {
            config.MapHttpAttributeRoutes();

            //let keep only the JSON formatter
            config.Formatters.Clear();
            config.Formatters.Add(new JsonMediaTypeFormatter());

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=301869.
            config.EnableQuerySupport(new QueryableAttribute() { MaxExpansionDepth = 5 });

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            //enable cross domain requests
            config.EnableCors(new EnableCorsAttribute("*", "*", "*"));

            //OData based rest endpoint
            config.Routes.MapODataRoute(
                "ODataRoute",
                "rest",
                new RestApiModelBuilder().GetEdmModel());

            //RPC based rpc endpoint
            config.Routes.MapHttpRoute(
                name: "RPCRoute",
                routeTemplate: "rpc/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            return config;
        }
Ejemplo n.º 18
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
            config.Filters.Add(new NotImplExceptionFilterAttribute());
            config.Filters.Add(new ValidateModelAttribute());

            // Web API routes
            var constraintResolver = new DefaultInlineConstraintResolver();
            constraintResolver.ConstraintMap.Add("nonezero", typeof(NoneZeroConstraint));
            config.MapHttpAttributeRoutes(constraintResolver);

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

            config.Formatters.Add(new ProductCsvFormatter());
            config.EnableQuerySupport();

            //var provider = new SimpleModelBinderProvider(typeof(Product), new ProductModelBinder());
            //config.Services.Insert(typeof(ModelBinderProvider), 0, provider);

            DtoMapperConfig.CreateMaps();
        }
Ejemplo n.º 19
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            // Use camel case for JSON data.
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            config.Routes.MapHttpRoute(
                name: "AccountApi",
                routeTemplate: "api/account/{action}/{id}",
                defaults: new { controller = "Account", id = RouteParameter.Optional }
                );

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

            config.EnableQuerySupport();
        }
Ejemplo n.º 20
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
              name: "FeaturesByProjectApi",
              routeTemplate: "api/projects/{projectId}/features",
              defaults: new { controller = "projects", action = "GetFeatures", id = RouteParameter.Optional }
            );
            config.Routes.MapHttpRoute(
                name: "GetTaskPerStatusApi",
                routeTemplate: "api/projects/{projectId}/tasksperstatus",
                defaults: new { controller = "projects", action = "GetTaskPerStatus", id = RouteParameter.Optional }
                );
            config.Routes.MapHttpRoute(
                name: "FinishedTaskPerDayApi",
                routeTemplate: "api/projects/{projectId}/FinishedTaskPerDay",
                defaults: new { controller = "projects", action = "GetFinishedTaskPerDay", id = RouteParameter.Optional }
                );
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }
Ejemplo n.º 21
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapODataRoute("Nephos", "sdata", GetImplicitEDM());

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

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            var queryAttribute = new QueryableAttribute()
            {
                AllowedQueryOptions = AllowedQueryOptions.All, // or just some: AllowedQueryOptions.Top | AllowedQueryOptions.Skip,
                MaxTop = 100,
                PageSize = 100,
            };
            //config.EnableQuerySupport(queryAttribute);
            // no argument also allowed and then specify queryable attribute on controller
            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();

            SDataMessageHandler sdataHandler = new SDataMessageHandler();
            // optionally add mapper that's a work around for web api odata not supporting property name aiasing
            sdataHandler.AddContentMap(new DefaultMetadataMap());
            sdataHandler.SetErrorResponseBuilder(new DefaultErrorResponseBuilder());
            GlobalConfiguration.Configuration.MessageHandlers.Add(sdataHandler);
        }
Ejemplo n.º 22
0
        public static void UpdateConfiguration(HttpConfiguration configuration)
        {
            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;

            configuration.EnableODataSupport(GetEdmModel(configuration));
            configuration.EnableQuerySupport(new QueryableAttribute() { ResultLimit = 100 });
        }
Ejemplo n.º 23
0
        public static void Register(HttpConfiguration config)
        {
            #region api/Meeting Special Snowflake operations

            config.Routes.MapHttpRoute(
                name: "MeetingApi",
                routeTemplate: "api/Meeting/{meetingId}",
                defaults: new { controller = "Meeting", action = "Get", meetingId = ""}
            );

            config.Routes.MapHttpRoute(
                name: "MeetingApiAvailableBadgeNumbers",
                routeTemplate: "api/Meeting/{id}/AvailableBadgeNumbers",
                defaults: new { controller = "Meeting", action = "AvailableBadgeNumbers", id = "" }
            );

            config.Routes.MapHttpRoute(
                name: "MeetingApiAvailableBuildings",
                routeTemplate: "api/Meeting/{id}/AvailableBuildings",
                defaults: new { controller = "Meeting", action = "AvailableBuildings", id = "" }
            );

            config.Routes.MapHttpRoute(
               name: "MeetingApiAvailableEmails",
               routeTemplate: "api/Meeting/{id}/AvailableEmails",
               defaults: new { controller = "Meeting", action = "AvailableEmails", id = "" }
            );

            config.Routes.MapHttpRoute(
                name: "MeetingApiAvailableExLocations",
                routeTemplate: "api/Meeting/{id}/AvailableExLocations",
                defaults: new { controller = "Meeting", action = "AvailableExLocations", id = "" }
            );

            config.Routes.MapHttpRoute(
                name: "MeetingApiAvailableRooms",
                routeTemplate: "api/Meeting/{meetingId}/AvailableRooms/{buildingId}",
                defaults: new { controller = "Meeting", action = "AvailableRooms", meetingId = "", buildingId = "" }
            );

            #endregion

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

            // Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
            // To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
            // For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
            config.EnableQuerySupport();

            // Sets WebApi to return JSON by default. http://stackoverflow.com/questions/9847564/how-do-i-get-asp-net-web-api-to-return-json-instead-of-xml-using-chrome
            config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(
                config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml")
            );
        }
Ejemplo n.º 24
0
        public static void Register(HttpConfiguration config)
        {
            var routes = config.Routes;

            // This controller-per-type route is ideal for GetAll calls.
            // It finds the method on the controller using WebAPI conventions
            // The template has no parameters.
            //
            // ex: api/requests
            // ex: api/bins
            routes.MapHttpRoute(
                name: ControllerOnly,
                routeTemplate: "api/{controller}"
            );

            // This is the default route that a "File | New MVC 4 " project creates.
            // (I changed the name, removed the defaults, and added the constraints)
            //
            // This controller-per-type route lets us fetch a single resource by numeric id
            // It finds the appropriate method GetById method
            // on the controller using WebAPI conventions
            // The {id} is not optional, must be an integer, and
            // must match a method with a parameter named "id" (case insensitive)
            //
            //  ex: api/requests/1
            //  ex: api/bins/1
            routes.MapHttpRoute(
                name: ControllerAndId,
                routeTemplate: "api/{controller}/{id}",
                defaults: null, //defaults: new { id = RouteParameter.Optional } //,
                constraints: new { id = @"^\d+$" } // id must be all digits
            );

            /********************************************************
            * The integer id constraint is necessary to distinguish
            * the {id} route above from the {action} route below.
            * For example, the route above handles
            *     "api/sessions/1"
            * whereas the route below handles
            *     "api/lookups/all"
            ********************************************************/

            // This RPC style route is great for lookups and custom calls
            // It matches the {action} to a method on the controller
            //
            // ex: api/lookups/all
            // ex: api/lookups/rooms
            routes.MapHttpRoute(
                name: ControllerAction,
                routeTemplate: "api/{controller}/{action}"
            );

            config.EnableQuerySupport();

            // To disable tracing in your application, please comment out or remove the following line of code
            // For more information, refer to: http://www.asp.net/web-api
            config.EnableSystemDiagnosticsTracing();
        }
Ejemplo n.º 25
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.EnableQuerySupport();
        }
Ejemplo n.º 26
0
 public static void Register(HttpConfiguration config)
 {
     config.Routes.MapHttpRoute(
         name: "DefaultApi",
         routeTemplate: "api/{controller}/{id}",
         defaults: new { id = RouteParameter.Optional }
     );
     config.EnableQuerySupport();
     config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
 }
Ejemplo n.º 27
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            //Включает поддержку запросов с типом возвращаемого значения IQueryable или IQueryable<T>.
            config.EnableQuerySupport();
        }
Ejemplo n.º 28
0
        public static void Register(HttpConfiguration config)
        {
            // Use camel case for JSON data.
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
                new CamelCasePropertyNamesContractResolver();

            // Web API routes
            config.MapHttpAttributeRoutes();

            // Enable query support for actions with an IQueryable or IQueryable<T> return type.
            config.EnableQuerySupport();
        }
Ejemplo n.º 29
0
        public static void RegisterWebApiRoutes(HttpConfiguration config)
        {
            //Use web api routing
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });

            config.Routes.MapHttpRoute("BreezeDefault", "breeze/{action}", new { Controller = "Metadata" });

            config.Routes.MapHttpRoute("BreezeModule", "breeze/{controller}/{action}");

            config.EnableQuerySupport();
        }
Ejemplo n.º 30
0
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            // 取消注释下面的代码行可对具有 IQueryable 或 IQueryable<T> 返回类型的操作启用查询支持。
            // 若要避免处理意外查询或恶意查询,请使用 QueryableAttribute 上的验证设置来验证传入查询。
            // 有关详细信息,请访问 http://go.microsoft.com/fwlink/?LinkId=279712。
            config.EnableQuerySupport();
        }
        /// <summary>
        /// Enables OData support by adding an OData route and enabling OData controller and action selection, querying, and formatter support for OData.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="model">The EDM model to use for the service.</param>
        /// <param name="routePrefix">The prefix to add to the OData route's path template.</param>
        public static void EnableOData(this HttpConfiguration configuration, IEdmModel model, string routePrefix)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            if (model == null)
            {
                throw Error.ArgumentNull("model");
            }

            // Querying
            configuration.SetEdmModel(model);
            configuration.EnableQuerySupport();

            // Routing
            string routeTemplate = String.IsNullOrEmpty(routePrefix) ?
                                   ODataRouteConstants.ODataPathTemplate :
                                   routePrefix + "/" + ODataRouteConstants.ODataPathTemplate;
            IODataPathHandler    pathHandler     = configuration.GetODataPathHandler() ?? new DefaultODataPathHandler(model);
            IHttpRouteConstraint routeConstraint = new ODataPathRouteConstraint(pathHandler);

            configuration.Routes.MapHttpRoute(ODataRouteConstants.RouteName, routeTemplate, null, new HttpRouteValueDictionary()
            {
                { ODataRouteConstants.ConstraintName, routeConstraint }
            });

            IEnumerable <IODataRoutingConvention> routingConventions = configuration.GetODataRoutingConventions();
            IHttpControllerSelector controllerSelector = new ODataControllerSelector(routingConventions, configuration.Services.GetHttpControllerSelector());
            IHttpActionSelector     actionSelector     = new ODataActionSelector(routingConventions, configuration.Services.GetActionSelector());

            configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);

            // Formatter
            configuration.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create(model));
        }
Ejemplo n.º 32
0
 /// <summary>
 /// Enables query support for actions with an <see cref="IQueryable" /> or <see cref="IQueryable{T}" /> return type.
 /// </summary>
 /// <param name="configuration">The server configuration.</param>
 public static void EnableQuerySupport(this HttpConfiguration configuration)
 {
     configuration.EnableQuerySupport(new QueryableAttribute());
 }