public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
appBuilder.UseWebApi(config);
var appFolder = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.FullName, "Webportal");
appBuilder.UseFileServer(new Microsoft.Owin.StaticFiles.FileServerOptions
{
RequestPath = new PathString(WebPortalUrl),
FileSystem = new PhysicalFileSystem(appFolder),
EnableDirectoryBrowsing = true
});
appBuilder.Map(PathString.Empty, a => a.Use<PortalRedirectionMiddelware>(WebPortalUrl));
appBuilder.Use<AdminMiddleware>();
}
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));
// Web API routes
config.MapHttpAttributeRoutes();
// enable CORS
config.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "PlayerApi",
routeTemplate: "api/{controller}/{action}/{name}",
defaults: new { teamName = RouteParameter.Optional }
);
}
public void RegisterRoutes(HttpConfiguration config)
{
// blobs
this.MapRoute(config, HttpMethod.Get , "api/file", "Blob", "Get");
this.MapRoute(config, HttpMethod.Post, "api/file", "Blob", "Post");
// nomenclatures
this.MapRoute(config, HttpMethod.Get, "api/nomenclatures/{alias}/{id}" , "Nom", "GetNom", new Dictionary<string, object>() { {"id", new IntRouteConstraint() } });
this.MapRoute(config, HttpMethod.Get, "api/nomenclatures/{alias}/{valueAlias}", "Nom", "GetNom");
this.MapRoute(config, HttpMethod.Get, "api/nomenclatures/{alias}" , "Nom", "GetNoms");
// signs
this.MapRoute(config, HttpMethod.Post, "api/signXml", "Sign", "PostSignXml");
this.MapRoute(config, HttpMethod.Post, "api/signOffice", "Sign", "PostSignOffice");
//user
this.MapRoute(config, HttpMethod.Get, "api/user/currentData", "User", "GetUserData");
this.MapRoute(config, HttpMethod.Get, "api/user/duplicateUnit", "User", "CheckDuplicateUnit");
this.MapRoute(config, HttpMethod.Get, "api/users", "User", "GetUsers");
this.MapRoute(config, HttpMethod.Get, "api/users/{id}", "User", "GetUser");
this.MapRoute(config, HttpMethod.Post, "api/users/{id}", "User", "UpdateUser");
this.MapRoute(config, HttpMethod.Post, "api/users", "User", "CreateUser");
this.MapRoute(config, HttpMethod.Post, "api/user/changePassword", "User", "ChangeCurrentUserPassword");
this.MapRoute(config, HttpMethod.Post, "api/user/isCorrectPassword", "User", "IsCorrectPassword");
//role
this.MapRoute(config, HttpMethod.Get, "api/roles", "User", "GetRoles");
}
public static void Register(HttpConfiguration config)
{
//// Uncomment the following to use the documentation from XML documentation file.
//config.SetDocumentationProvider(new XmlDocumentationProvider(HttpContext.Current.Server.MapPath("~/App_Data/XmlDocument.xml")));
//// Uncomment the following to use "sample string" as the sample for all actions that have string as the body parameter or return type.
//// Also, the string arrays will be used for IEnumerable<string>. The sample objects will be serialized into different media type
//// formats by the available formatters.
//config.SetSampleObjects(new Dictionary<Type, object>
//{
// {typeof(string), "sample string"},
// {typeof(IEnumerable<string>), new string[]{"sample 1", "sample 2"}}
//});
//// Uncomment the following to use "[0]=foo&[1]=bar" directly as the sample for all actions that support form URL encoded format
//// and have IEnumerable<string> as the body parameter or return type.
//config.SetSampleForType("[0]=foo&[1]=bar", new MediaTypeHeaderValue("application/x-www-form-urlencoded"), typeof(IEnumerable<string>));
//// Uncomment the following to use "1234" directly as the request sample for media type "text/plain" on the controller named "Values"
//// and action named "Put".
//config.SetSampleRequest("1234", new MediaTypeHeaderValue("text/plain"), "Values", "Put");
//// Uncomment the following to use the image on "../images/aspNetHome.png" directly as the response sample for media type "image/png"
//// on the controller named "Values" and action named "Get" with parameter "id".
//config.SetSampleResponse(new ImageSample("../images/aspNetHome.png"), new MediaTypeHeaderValue("image/png"), "Values", "Get", "id");
//// Uncomment the following to correct the sample request when the action expects an HttpRequestMessage with ObjectContent<string>.
//// The sample will be generated as if the controller named "Values" and action named "Get" were having string as the body parameter.
//config.SetActualRequestType(typeof(string), "Values", "Get");
//// Uncomment the following to correct the sample response when the action returns an HttpResponseMessage with ObjectContent<string>.
//// The sample will be generated as if the controller named "Values" and action named "Post" were returning a string.
//config.SetActualResponseType(typeof(string), "Values", "Post");
}
public static void Configure(HttpConfiguration config)
{
// Message Handlers
config.MessageHandlers.Add(new RequireHttpsMessageHandler());
config.MessageHandlers.Add(new PingYourPackageAuthHandler());
//Formatters
var jqueryFormatter = config.Formatters.FirstOrDefault(
x => x.GetType() ==
typeof(JQueryMvcFormUrlEncodedFormatter));
config.Formatters.Remove(
config.Formatters.FormUrlEncodedFormatter);
config.Formatters.Remove(jqueryFormatter);
foreach (var formatter in config.Formatters)
{
formatter.RequiredMemberSelector =
new SuppressedRequiredMemberSelector();
}
// Filters
config.Filters.Add(
new InvalidModelStateFilterAttribute());
//Default Services
config.Services.Replace(typeof(IContentNegotiator), new DefaultContentNegotiator(
excludeMatchOnTypeOnly: true));
config.Services.RemoveAll(typeof(ModelValidatorProvider), validator => !(validator
is DataAnnotationsModelValidatorProvider));
// ParameterBindingRules
config.ParameterBindingRules.Insert(0,descriptor => typeof(IRequestCommand).IsAssignableFrom(descriptor.ParameterType)? new FromUriAttribute().GetBinding(descriptor) : null);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//clear default formatters
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
//set formatters only json
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
//optional: set serializer settings here
config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
//jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
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();
}
[InlineData("GET", "http://localhost/Customers(12)/NS.SpecialCustomer/NS.GetSalary()", "GetSalaryFromSpecialCustomer_12")] // call function on derived entity type
public async Task AttriubteRouting_SelectsExpectedControllerAndAction(string method, string requestUri,
string expectedResult)
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
var controllers = new[] { typeof(CustomersController), typeof(MetadataAndServiceController), typeof(OrdersController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers));
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.Services.Replace(typeof(IAssembliesResolver), resolver);
config.MapODataServiceRoute("odata", "", model.Model);
HttpServer server = new HttpServer(config);
config.EnsureInitialized();
HttpClient client = new HttpClient(server);
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), requestUri);
// Act
var response = await client.SendAsync(request);
// Assert
if (!response.IsSuccessStatusCode)
{
Assert.False(true, await response.Content.ReadAsStringAsync());
}
var result = await response.Content.ReadAsAsync<AttributeRoutingTestODataResponse>();
Assert.Equal(expectedResult, result.Value);
}
public static void Register(HttpConfiguration config) {
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new {id = RouteParameter.Optional}
);
}
private static void setJsonSettings(HttpConfiguration config)
{
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new DateTimeConverter());
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
}
public static void Register(HttpConfiguration config)
{
//config.Formatters.JsonFormatter.("json", "application/json");
//config.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml");
// TODO: read format based on extension
config.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
config.Formatters.JsonFormatter.MediaTypeMappings.Add(
new UriPathExtensionMapping("json", "application/json"));
config.Routes.MapHttpRoute(
name: "ActivityApi",
routeTemplate: "{appName}/activity/{subjectId}/{actionName}/{objectId}",
defaults: new { Controller = "ActivityApi", objectId = RouteParameter.Optional } //, ext = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "RulesApi",
routeTemplate: "{appName}/rules/{id}",
defaults: new { Controller = "RulesApi", id = RouteParameter.Optional } //, ext = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "ReputationApi",
routeTemplate: "{appName}/{objectId}/reputation/{stat}",
defaults: new { Controller = "ReputationApi", stat = RouteParameter.Optional } //, ext = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "ReputationApiGlobal",
routeTemplate: "{objectId}/reputation/{stat}",
defaults: new { Controller = "ReputationApi", stat = RouteParameter.Optional } //, ext = RouteParameter.Optional }
);
}
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request)
{
// create context
var controllerContext = new HttpControllerContext(config, Substitute.For<IHttpRouteData>(), request);
// get route data
var routeData = config.Routes.GetRouteData(request);
RemoveOptionalRoutingParameters(routeData.Values);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
var controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
controllerContext.ControllerDescriptor = controllerDescriptor;
// get action name
var actionMapping = new ApiControllerActionSelector().SelectAction(controllerContext);
return new RouteInfo
{
Controller = controllerDescriptor.ControllerType,
Action = actionMapping.ActionName
};
}
public Generator(HttpConfiguration conf, HttpRequestMessage req)
{
config = conf;
request = req;
GenerateRouteData();
}
public static void Register(HttpConfiguration configuration)
{
container = new WindsorContainer();
container.Install(FromAssembly.This());
container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, true));
configuration.Services.Replace(typeof (IHttpControllerActivator), new WindsorCompositionRoot(container));
}
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.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "json", new MediaTypeHeaderValue("application/json")));
GlobalConfiguration.Configuration.Formatters.XmlFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "xml", new MediaTypeHeaderValue("application/xml")));
// 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();
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// 默认返回Json数据
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//var bson = new BsonMediaTypeFormatter();
//bson.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/bson"));
//config.Formatters.Add(bson);
config.Formatters.Add(new Raven.AspNet.WebApiExtensions.Formatters.MsgPackFormatter());
appBuilder.UseRequestScopeContext();
appBuilder.UseWebApi(config);
//CallContext
//appBuilder.Use(
}
public void ByPostShouldReturnCorrectResponse()
{
var controller = typeof(CategoriesController);
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var httpServer = new HttpServer(config);
var httpInvoker = new HttpMessageInvoker(httpServer);
using (httpInvoker)
{
var request = new HttpRequestMessage
{
RequestUri = new Uri("http://test.com/api/categories/1"),
Method = HttpMethod.Get
};
var result = httpInvoker.SendAsync(request, CancellationToken.None).Result;
Assert.IsNotNull(result);
}
}
public static void Register(HttpConfiguration config)
{
config.EnableCors();
// Web API configuration and services
var clientID = WebConfigurationManager.AppSettings["auth0:ClientId"];
var clientSecret = WebConfigurationManager.AppSettings["auth0:ClientSecret"];
config.MessageHandlers.Add(new JsonWebTokenValidationHandler()
{
Audience = clientID,
SymmetricKey = clientSecret
});
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "WithActionApi",
routeTemplate: "api/{controller}/{action}/{fillupId}"
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
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();
// 若要在应用程序中禁用跟踪，请注释掉或删除以下代码行
// 有关详细信息，请参阅: http://www.asp.net/web-api
config.EnableSystemDiagnosticsTracing();
// 参考：http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api/odata-v3/creating-an-odata-endpoint
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Product>("Products");
// 参考：http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api/odata-v3/working-with-entity-relations
builder.EntitySet<Supplier>("Suppliers");
//config.Routes.MapODataRoute("OData", "odata", builder.GetEdmModel());
config.Routes.MapODataServiceRoute("ODataRoute", "odata", builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
}
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));
//Unity
var container = new UnityContainer();
container.RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager());
container.RegisterType<IGenericRepository<Farmacia>, GenericRepository<Farmacia>>(new HierarchicalLifetimeManager());
config.DependencyResolver = new UnityResolver(container);
//Formatters
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
//config.Formatters.Insert(0, new System.Net.Http.Formatting.JsonMediaTypeFormatter());
// Web API routes
config.MapHttpAttributeRoutes();
//config.EnableCors();
var cors = new EnableCorsAttribute("http://localhost:28285", "*", "*");
config.EnableCors(cors);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional});
appBuilder.UseWebApi(config).UseNancy();
}
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 }
);
// Load basic support for sending WebHooks
config.InitializeCustomWebHooks();
// Load Azure Storage or SQL for persisting subscriptions
config.InitializeCustomWebHooksAzureStorage();
// config.InitializeCustomWebHooksSqlStorage();
// Load Azure Queued Sender for enqueueing outgoing WebHooks to an Azure Storage Queue
// config.InitializeCustomWebHooksAzureQueueSender();
// Load Web API controllers for managing subscriptions
config.InitializeCustomWebHooksApis();
}
public static new void Install(HttpConfiguration config, IAppBuilder app)
{
config.SuppressHostPrincipal();
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
var jSettings = new JsonSerializerSettings();
jSettings.Formatting = Formatting.Indented;
jSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.SerializerSettings = jSettings;
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public AuthorizationLevelAttributeTests()
{
HttpConfig = new System.Web.Http.HttpConfiguration();
_actionContext = CreateActionContext(typeof(TestController).GetMethod("Get"), HttpConfig);
Mock <IDependencyResolver> mockDependencyResolver = new Mock <IDependencyResolver>(MockBehavior.Strict);
HttpConfig.DependencyResolver = mockDependencyResolver.Object;
MockSecretManager = new Mock <ISecretManager>(MockBehavior.Strict);
_hostSecrets = new HostSecretsInfo
{
MasterKey = TestMasterKeyValue,
FunctionKeys = new Dictionary <string, string>
{
{ TestHostFunctionKeyName1, TestHostFunctionKeyValue1 },
{ TestHostFunctionKeyName2, TestHostFunctionKeyValue2 }
},
SystemKeys = new Dictionary <string, string>
{
{ TestSystemKeyName1, TestSystemKeyValue1 },
{ TestSystemKeyName2, TestSystemKeyValue2 }
}
};
MockSecretManager.Setup(p => p.GetHostSecretsAsync()).ReturnsAsync(_hostSecrets);
_functionSecrets = new Dictionary <string, string>
{
{ TestFunctionKeyName1, TestFunctionKeyValue1 },
{ TestFunctionKeyName2, TestFunctionKeyValue2 }
};
MockSecretManager.Setup(p => p.GetFunctionSecretsAsync(It.IsAny <string>(), false)).ReturnsAsync(_functionSecrets);
mockDependencyResolver.Setup(p => p.GetService(typeof(ISecretManager))).Returns(MockSecretManager.Object);
_webHostSettings = new WebHostSettings();
mockDependencyResolver.Setup(p => p.GetService(typeof(WebHostSettings))).Returns(_webHostSettings);
}
public void Configuration(IAppBuilder app)
{
var startupType = typeof(IStartup);
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var startupTypes = assemblies.SelectMany(s => GetAssemblyTypes(s, startupType));
var startupInstances = new List <IStartup>();
foreach (var sType in startupTypes)
{
var startupInstance = Activator.CreateInstance(sType) as IStartup;
startupInstances.Add(startupInstance);
}
// Register HttpConfiguration
var config = new System.Web.Http.HttpConfiguration();
config.MapHttpAttributeRoutes();
foreach (var sType in startupInstances)
{
sType.Register(config, app);
}
// Set up all configuration.
foreach (var sType in startupInstances)
{
sType.Configuration(app);
}
app.UseWebApi(config);
}
public static void Register(HttpConfiguration httpConfiguration)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataV4TestService.Models";
builder.EntitySet<Product>("Products");
builder.EntitySet<SuppliedProduct>("SuppliedProducts");
builder.EntitySet<Supplier>("Suppliers");
builder.EntitySet<Product>("OtherProducts");
builder.ComplexType<Description>();
builder.EntityType<Product>()
.Action("Rate")
.Parameter<int>("Rating");
builder.EntityType<Product>().Collection
.Function("Best")
.ReturnsCollectionFromEntitySet<Product>("Products");
var funcConfig = builder
.EntityType<Product>()
.Function("RelatedProducts")
.SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product)))
//.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)).
.ReturnsCollectionFromEntitySet<Product>("Products");
funcConfig
.Parameter<DateTimeOffset>("start");
funcConfig
.Parameter<DateTimeOffset>("end");
//builder.Function("GetSalesTaxRate")
// .Returns<double>()
// .Parameter<int>("PostalCode");
builder.EntitySet<Account>("Accounts");
builder.EntityType<PaymentInstrument>()
.Collection
.Function("GetCount")
.Returns<int>()
.Parameter<string>("NameContains");
var model = builder.GetEdmModel();
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration));
var server = new BatchServer(httpConfiguration);
httpConfiguration.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: model,
pathHandler: new DefaultODataPathHandler(),
routingConventions: conventions,
batchHandler: new DefaultODataBatchHandler(server));
httpConfiguration.MessageHandlers.Add(new TracingMessageHandler());
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "ThreadsApi",
routeTemplate: "api/threads/{threadId}/posts",
defaults: new
{
controller = "threads",
action = "posts"
}
);
config.Routes.MapHttpRoute(
name: "UsersApi",
routeTemplate: "api/users/{action}",
defaults: new { controller = "users" }
);
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();
}
public void Configuration(IAppBuilder app)
{
var cookieOptions = new CookieAuthenticationOptions()
{
LoginPath = new PathString("/LoginHandler"),
AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
Provider = new AppCookieAuthProvider()
};
app.UseCookieAuthentication(cookieOptions);
// web api
var apiConfig = new System.Web.Http.HttpConfiguration();
//apiConfig.MapHttpAttributeRoutes();
//apiConfig.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
apiConfig.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(apiConfig);
//app.Run(context =>
//{
// context.Response.ContentType = "plain/html";
// return context.Response.WriteAsync("Hello World!");
//});
}
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 }
);
// OData
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Player>("Players");
builder.EntitySet<BattingDetail>("BattingDetails");
builder.EntitySet<BowlingDetail>("BowlingDetails");
builder.EntitySet<Country>("Countrys");
builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber);
config.AddODataQueryFilter();
config.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
//2014/06/16 若以此設定在get/put的方法會造成404，因為參數api/products/1的products對到了area,1對到了controller,id=optional
// config.Routes.MapHttpRoute(
//name: "AreaAPI",
//routeTemplate: "api/{area}/{controller}/{id}",
//defaults: new { id = RouteParameter.Optional }
// //, constraints: new { area = @"\w{3}|\w{4}|\w{5}|\w{6}|\w{7}" }//限定Area才吃此設定，防put 404 error, 2014/06/16無效
//);
//test:http://localhost:3752/rd
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return;
//2014/08/11重點為default的id約束及DefaultApiWithAction，可以使用明確的action來呼叫
//2014/08/11看起來WebApi最好的設定方式
//http://lonetechie.com/2013/03/04/fixing-multiple-actions-were-found-that-match-the-request-aspnet-webapi/
config.Routes.MapHttpRoute("DefaultApiWithId", "api/{controller}/{id}", new { id = RouteParameter.Optional }, new { id = @"\d+" });
config.Routes.MapHttpRoute("DefaultApiWithAction", "api/{controller}/{action}");
config.Routes.MapHttpRoute("DefaultApiGet", "api/{controller}", new { action = "Get" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) });
config.Routes.MapHttpRoute("DefaultApiPost", "api/{controller}", new { action = "Post" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Post) });
config.Routes.MapHttpRoute("DefaultApiPut", "api/{controller}", new { action = "Put" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Put) });
config.Routes.MapHttpRoute("DefaultApiDelete", "api/{controller}", new { action = "Delete" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Delete) });
}
public void Configuration(IAppBuilder app)
{
var httpConfiguration = new HttpConfiguration();
// Configure Web API Routes:
// - Enable Attribute Mapping
// - Enable Default routes at /api.
httpConfiguration.MapHttpAttributeRoutes();
httpConfiguration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(httpConfiguration);
// Make ./public the default root of the static files in our Web Application.
app.UseFileServer(new FileServerOptions
{
RequestPath = new PathString(string.Empty),
FileSystem = new PhysicalFileSystem("./public"),
EnableDirectoryBrowsing = true,
});
app.UseStageMarker(PipelineStage.MapHandler);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseWebApi(config);
}
private static HttpConfiguration GetNewHttpConfig()
{
HttpConfiguration config = new System.Web.Http.HttpConfiguration();
config.EnableDependencyInjection(); //1
config.EnsureInitialized(); //2
return(config);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
var container = new ServiceContainer();
Container = container;
container.RegisterApiControllers(typeof(IocConfig).Assembly);
container.EnableWebApi(config);
RegisterServices(container);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
new Logging.LogManager();
System.Web.Http.HttpConfiguration conf = new System.Web.Http.HttpConfiguration();
conf.EnableSystemDiagnosticsTracing();
}
public void Configuration(IAppBuilder app)
{
System.Web.Http.HttpConfiguration config = new System.Web.Http.HttpConfiguration();
config.Routes.MapHttpRoute("r1", "{controller}/{action}/{id}/", defaults: new { id = RouteParameter.Optional });
config.Filters.Add(new AzFilter());
app.UseWebApi(config);
// 有关如何配置应用程序的详细信息，请访问 http://go.microsoft.com/fwlink/?LinkID=316888
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
UnityConfig.RegisterComponents();
System.Web.Http.HttpConfiguration config = System.Web.Http.GlobalConfiguration.Configuration;
config.EnsureInitialized();
}
public ExceptionProcessingHandler(System.Web.Http.HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_config = config;
_traceWriterLoader = new Lazy <TraceWriter>(() => _config.DependencyResolver.GetService <TraceWriter>());
_handlers = InitializeExceptionHandlers();
}
public async Task <ActionResult> Index(Models.SendNotificationsModel model)
{
//get notification hub information
// Get the settings for the server project.
System.Web.Http.HttpConfiguration config =
System.Web.Http.GlobalConfiguration.Configuration;
MobileAppSettingsDictionary settings =
config.GetMobileAppSettingsProvider().GetMobileAppSettings();
// Get the Notification Hubs credentials for the Mobile App.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
.Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;
// Create a new Notification Hub client.
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);
// Sending the message so that all template registrations that contain "messageParam"
// will receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
Dictionary <string, string> templateParams = new Dictionary <string, string>();
templateParams["title"] = model.Title;
templateParams["message"] = model.Message;
try
{
NotificationOutcome result = null;
// Send the push notification and log the results.
if (model.Tags != null && model.Tags.Count > 0)
{
result = await hub.SendTemplateNotificationAsync(templateParams, String.Join(" || ", model.Tags));
}
else
{
result = await hub.SendTemplateNotificationAsync(templateParams);
}
// Write the success result to the logs.
config.Services.GetTraceWriter().Info(result.State.ToString());
}
catch (System.Exception ex)
{
// Write the failure result to the logs.
config.Services.GetTraceWriter()
.Error(ex.Message, null, "Push.SendAsync Error");
throw;
}
//redirct to confirm
return(View("Confirm"));
}
public WebViewer(ILogger logger, Action <Action <ISystemController, IRaceController> > queueCommand, IPlugin plugin, IKernel kernel)
{
//params to add:
//wifi hostspot?
//dhcp?
//dns?
//katana port
//static content path
_logger = logger;
this.Plugin = plugin;
//possibly do these as another plugin/dependency eg how bt or i2c works?
//optionally configure wifi as hotspot
//optionally configure dhcp
//optionally configure dns
//initialize owin/katana
_webApp = WebApp.Start("http://*:9000", app =>
{
var webApiConfig = new System.Web.Http.HttpConfiguration();
webApiConfig.MapHttpAttributeRoutes();
webApiConfig.Formatters.Clear();
webApiConfig.Formatters.Add(new JsonMediaTypeFormatter());
webApiConfig.Formatters.JsonFormatter.SerializerSettings =
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
_resolver = new WebResolver(webApiConfig.DependencyResolver, logger, queueCommand, kernel);
webApiConfig.DependencyResolver = _resolver;
app.UseWebApi(webApiConfig);
var fs = new PhysicalFileSystem("/home/brook/Desktop/MrGibbs/src/MrGibbs.OnboardWebUI/Web");
app.UseFileServer(new FileServerOptions()
{
FileSystem = fs,
RequestPath = new PathString(""),
EnableDefaultFiles = true
});
});
//initialize static content
//initialize default page
//initialize webapi
//initialize websockets/signalr?
//create a ninject kernel specifically for the webapp
//add the logger and queue command, maybe state?
}
public ExceptionProcessingHandlerTests()
{
_settingsManager = ScriptSettingsManager.Instance;
_traceWriter = new TestTraceWriter(System.Diagnostics.TraceLevel.Verbose);
Mock <IDependencyResolver> mockResolver = new Mock <IDependencyResolver>();
mockResolver.Setup(p => p.GetService(typeof(TraceWriter))).Returns(_traceWriter);
_config = new System.Web.Http.HttpConfiguration();
_config.DependencyResolver = mockResolver.Object;
}
public static void RegisterApi(System.Web.Http.HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// Adds support for the webapi 1 style methods, e.g. /api/Users/
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.EnsureInitialized();
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
var authConfig = new AuthenticationConfiguration
{
InheritHostClientIdentity = true,
EnableSessionToken = false,
RequireSsl = false// only for testing
};
// authConfig.AddBasicAuthentication()
config.MessageHandlers.Add(new AuthenticationHandler(authConfig));
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
config.EnableCors();
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi1", "api/{controller}");
config.Routes.MapHttpRoute("DefaultApi2", "api/{controller}/{value}");
config.Routes.MapHttpRoute("DefaultApi3", "api/{controller}/{action}/{value}");
config.Routes.MapHttpRoute("DefaultApi4", "api/{controller}/{value1}/{value2}/{value3}", new { value1 = RouteParameter.Optional, value2 = RouteParameter.Optional, value3 = RouteParameter.Optional });
//Dim appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(Function(t) t.MediaType = "application/xml")
//config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType)
}
/// <summary>
/// OWIN start up method
/// </summary>
/// <param name="app">The app.</param>
public void Configuration(IAppBuilder app)
{
var config = new System.Web.Http.HttpConfiguration();
app.Use((context, next) =>
{
return(next.Invoke());
});
app.UseStageMarker(PipelineStage.Authenticate);
Swashbuckle.Bootstrapper.Init(config);
WebApiConfig.Register(config);
app.UseWebApi(config);
app.UseStageMarker(PipelineStage.MapHandler);
}
public SystemTraceHandlerTests()
{
_traceWriter = new TestTraceWriter(TraceLevel.Verbose);
var config = new System.Web.Http.HttpConfiguration();
Mock <IDependencyResolver> mockResolver = new Mock <IDependencyResolver>(MockBehavior.Strict);
mockResolver.Setup(p => p.GetService(typeof(TraceWriter))).Returns(_traceWriter);
config.DependencyResolver = mockResolver.Object;
var handler = new SystemTraceHandler(config)
{
InnerHandler = new TestHandler()
};
_invoker = new HttpMessageInvoker(handler);
}
/// <summary>
/// The register.
/// </summary>
/// <param name="config">
/// The config.
/// </param>
/// <exception cref="ArgumentNullException">If any issues with configuration.
/// </exception>
public override void Register(System.Web.Http.HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
base.Register(config);
// Web API routes
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "V1/api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
protected static HttpActionContext CreateActionContext(MethodInfo action, System.Web.Http.HttpConfiguration config = null)
{
config = config ?? new System.Web.Http.HttpConfiguration();
var actionContext = new HttpActionContext();
var controllerDescriptor = new HttpControllerDescriptor(config, action.ReflectedType.Name, action.ReflectedType);
var controllerContext = new HttpControllerContext();
controllerContext.ControllerDescriptor = controllerDescriptor;
actionContext.ControllerContext = controllerContext;
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, action);
actionContext.ActionDescriptor = actionDescriptor;
controllerContext.Configuration = config;
return(actionContext);
}
public void Configuration(IAppBuilder app)
{
System.Web.Http.HttpConfiguration config = new System.Web.Http.HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
#if DEBUG
Database.SetInitializer(new MigrateDatabaseToLatestVersion <AuthContext, Migrations.Configuration>());
#endif
}
/// <summary>
/// Setup OData http://blogs.msdn.com/b/alexj/archive/2012/08/15/odata-support-in-asp-net-web-api.aspx
/// </summary>
/// <param name="config"></param>
private static void SetupODataRoutes(System.Web.Http.HttpConfiguration config)
{
var modelBuilder = new System.Web.Http.OData.Builder.ODataConventionModelBuilder();
modelBuilder.EntitySet <Member>("Members");
var model = modelBuilder.GetEdmModel();
// Create the OData formatter and give it the model
var odataFormatter = new System.Web.Http.OData.Formatter.ODataMediaTypeFormatter(model);
// Register the OData formatter
config.Formatters.Insert(0, odataFormatter);
//Next you need to setup some routes to handle common OData requests, below are the routes required for a Read/Write OData model built using the OData Routing conventions that also supports client side code-generation (vital if you want a WCF DS client application to talk to your service).
// Metadata routes to support $metadata and code generation in the WCF Data Service client.
config.Routes.MapHttpRoute(
System.Web.Http.OData.Builder.Conventions.ODataRouteNames.Metadata,
"api/$metadata",
new { Controller = "ODataMetadata", Action = "GetMetadata" }
);
config.Routes.MapHttpRoute(
System.Web.Http.OData.Builder.Conventions.ODataRouteNames.ServiceDocument,
"api",
new { Controller = "ODataMetadata", Action = "GetServiceDocument" }
);
// Relationship routes (notice the parameters is {type}Id not id, this avoids colliding with GetById(id)).
// This code handles requests like ~/ProductFamilies(1)/Products
config.Routes.MapHttpRoute(System.Web.Http.OData.Builder.Conventions.ODataRouteNames.PropertyNavigation,
"api/{controller}({parentId})/{navigationProperty}");
// Route for manipulating links, the code allows people to create and delete relationships between entities
config.Routes.MapHttpRoute(System.Web.Http.OData.Builder.Conventions.ODataRouteNames.Link,
"api/{controller}({id})/$links/{navigationProperty}");
// Routes for urls both producing and handling urls like ~/Product(1), ~/Products() and ~/Products
config.Routes.MapHttpRoute(System.Web.Http.OData.Builder.Conventions.ODataRouteNames.GetById,
"api/{controller}({id})");
config.Routes.MapHttpRoute(
System.Web.Http.OData.Builder.Conventions.ODataRouteNames.DefaultWithParentheses, "api/{controller}()");
config.Routes.MapHttpRoute(System.Web.Http.OData.Builder.Conventions.ODataRouteNames.Default,
"api/{controller}");
}
public async Task PostRequestTestTest_RoutingTest()
{
var config = new System.Web.Http.HttpConfiguration();
WebApiConfig.Register(config);
string url = "http://localhost/api/requesttests/";
var request = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, new Uri(url));
using (var server = new HttpServer(config))
{
var client = new System.Net.Http.HttpClient(server);
using (var response = await client.SendAsync(request))
{
Assert.IsTrue(System.Net.HttpStatusCode.NotFound != response.StatusCode);
}
}
}
public static void RegisterComponents(System.Web.Http.HttpConfiguration config)
{
var container = new UnityContainer();
var cnString = ConfigurationManager.ConnectionStrings["Login"].ConnectionString;
var pepper = ConfigurationManager.AppSettings["Pepper"];
container.RegisterInstance <IAccountRepository>(new AccountRepository(cnString, pepper));
// Dependency Injection trouble-shooting.
//http://stackoverflow.com/questions/24254189/make-sure-that-the-controller-has-a-parameterless-public-constructor-error
// register repositories
var defaultConnectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString;
container.RegisterInstance <ICommonRepository>(new CommonRepository(defaultConnectionString));
container.RegisterInstance <ITeamRepository>(new TeamRepository(defaultConnectionString));
container.RegisterInstance <IChurchRepository>(new ChurchRepository(defaultConnectionString));
container.RegisterInstance <ILogger>(new LoggerRepository(defaultConnectionString));
container.RegisterInstance <IMemberRepository>(new MemberRepository(defaultConnectionString));
container.RegisterInstance <IMessageRepository>(new MessageRepository(defaultConnectionString));
container.RegisterInstance <IReportsRepository>(new ReportsRepository(defaultConnectionString));
container.RegisterInstance <IImportRepository>(new ImportRepository(defaultConnectionString));
container.RegisterInstance <IImportService>(new ImportService(defaultConnectionString,
container.Resolve <IChurchRepository>(),
container.Resolve <ITeamRepository>(),
container.Resolve <IMemberRepository>(),
container.Resolve <IMessageRepository>(),
container.Resolve <ICommonRepository>(),
container.Resolve <ILogger>(),
container.Resolve <IImportRepository>()));
// register controllers
container.RegisterType <AccountController>();
container.RegisterType <ChurchController>();
container.RegisterType <MembersController>();
//container.RegisterType<MessageApiController>();
//GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
config.DependencyResolver = new UnityDependencyResolver(container);
}
public async Task PostRequestTestTest_InvalidJson_IntegrationTest()
{
var config = new System.Web.Http.HttpConfiguration();
WebApiConfig.Register(config);
string url = "http://localhost/api/requesttests/";
var request = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, new Uri(url));
request.Content = new System.Net.Http.StringContent(@"{'Id':1, 'Name':''}");
request.Content.Headers.ContentType.MediaType = "application/json";
using (var server = new HttpServer(config))
{
var client = new System.Net.Http.HttpClient(server);
using (var response = await client.SendAsync(request))
{
Assert.AreEqual(System.Net.HttpStatusCode.BadRequest, response.StatusCode);
}
}
}
private HttpConfiguration ConfigureWebApi()
{
var config = new System.Web.Http.HttpConfiguration();
var enableCorsAttribute = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(enableCorsAttribute);
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeWithQualityHeaderValue("text/html")
);
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json");
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return(config);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
var unity = new UnityContainer();
unity.RegisterType <SettingsController>();
unity.RegisterType <PostsController>();
unity.RegisterType <PagesController>();
unity.RegisterType <BlogsController>();
unity.RegisterType <StatsController>();
unity.RegisterType <PackagesController>();
unity.RegisterType <LookupsController>();
unity.RegisterType <CommentsController>();
unity.RegisterType <TrashController>();
unity.RegisterType <TagsController>();
unity.RegisterType <CategoriesController>();
unity.RegisterType <CustomFieldsController>();
unity.RegisterType <UsersController>();
unity.RegisterType <RolesController>();
unity.RegisterType <FileManagerController>();
unity.RegisterType <CommentFilterController>();
unity.RegisterType <ISettingsRepository, SettingsRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IPostRepository, PostRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IPageRepository, PageRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IBlogRepository, BlogRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IStatsRepository, StatsRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IPackageRepository, PackageRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ILookupsRepository, LookupsRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ICommentsRepository, CommentsRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ITrashRepository, TrashRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ITagRepository, TagRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ICategoryRepository, CategoryRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ICustomFieldRepository, CustomFieldRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IUsersRepository, UsersRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IRolesRepository, RolesRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <IFileManagerRepository, FileManagerRepository>(new HierarchicalLifetimeManager());
unity.RegisterType <ICommentFilterRepository, CommentFilterRepository>(new HierarchicalLifetimeManager());
config.DependencyResolver = new IoCContainer(unity);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
// Web-API-Konfiguration und -Dienste
// Web-API-Routen
config.MapHttpAttributeRoutes();
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Contracts.IResident>("Residents");
//config.AddODataQueryFilter(new System.Web.Http.Filters.ActionFilterAttribute() );
//config.Routes.MapODataRoute("ODataRoute", "odata", GetEdmModel());
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Models.ResidentViewModel>("Residents");
//config.MapODataServiceRoute(
// routeName: "ODataRoute",
// routePrefix: "odata",
// model: builder.GetEdmModel());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Models.ResidentViewModel>("ResidentViewModels");
config.AddODataQueryFilter();
//config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.MapODataServiceRoute( "odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
// Enable the application to use bearer tokens to authenticate users
PublicClientId = "self";
OAuthAuthorizationServerOptions aAuthOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/Token"),
Provider = new ApplicationOAuthProvider(PublicClientId),
//AuthorizeEndpointPath = new PathString("/api/Account/ExternalLogin"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
AllowInsecureHttp = true
};
app.UseOAuthBearerTokens(aAuthOptions);
var apiConfig = new System.Web.Http.HttpConfiguration();
apiConfig.SuppressDefaultHostAuthentication();
apiConfig.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
apiConfig.MapHttpAttributeRoutes();
apiConfig.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(apiConfig);
//app.Run(context =>
//{
// //context.Response.ContentType = "plain/html";
// return context.Response.WriteAsync("Hello World!");
//});
}
/// <summary>
/// Used to call static functions when the plugin is initially loaded into
/// the framework
/// </summary>
/// <param name="config"></param>
public override void Configure(System.Web.Http.HttpConfiguration config)
{
base.Configure(config);
ConfigSettings.AutoMapperConfiguration.Configure();
}
