public async Task GenerateLinkSuccess()
{
//Arrange
var playerName = "Test Name";
var playerRegion = "Test Region";
var generatLinkDto = new GenerateLinkDto
{
Api = "Test Api",
Nickname = playerName,
Server = playerRegion
};
var mockRiotService = new Mock <IRiotApiService>();
mockRiotService.Setup(rs => rs.FetchPlayerId(playerName, playerRegion)).ReturnsAsync("ID");
var mockSendgridService = new Mock <ISendgridService>();
var controller = new WebPageController(mockRiotService.Object, mockSendgridService.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
};
//Act
var result = await controller.GenerateLink(generatLinkDto);
//Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Link", redirectToActionResult.ActionName);
}
public async Task GenerateLinkRegionNotFound()
{
//Arrange
var playerName = "Test Name";
var playerRegion = "Test Region";
var generatLinkDto = new GenerateLinkDto
{
Nickname = playerName,
Server = playerRegion
};
var mockRiotService = new Mock <IRiotApiService>();
mockRiotService.Setup(rs => rs.FetchPlayerId(playerName, playerRegion)).ThrowsAsync(new RegionNotFoundException());
var mockSendgridService = new Mock <ISendgridService>();
var controller = new WebPageController(mockRiotService.Object, mockSendgridService.Object);
//Act
var result = await controller.GenerateLink(generatLinkDto);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
viewResult.ViewData.ModelState.TryGetValue("RegionNotFound", out var error);
Assert.Equal("Selected region not found.", error.Errors[0].ErrorMessage);
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
settings.Converters.Add(new IsoDateTimeConverter());
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load shared hub into application domain, initializing default status and exception handlers
try
{
using (new SharedHub(
(message, updateType) => Program.LogStatus(message, true),
ex => Program.LogException(ex)
)) { }
}
catch (Exception ex)
{
Program.LogException(new SecurityException($"Failed to load Shared Hub: {ex.Message}", ex));
}
// Configuration Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
AppModel appModel = new AppModel();
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, appModel.Global.DefaultWebPage, appModel, typeof(AppModel));
// Make sure any hosted exceptions get propagated to service error handling
httpConfig.Services.Replace(typeof(IExceptionHandler), new HostedExceptionHandler());
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
private void HandleRequestForTimersWebPage(HttpListenerRequest request, HttpListenerResponse response)
{
if (_optionsService.Options.IsWebClockEnabled)
{
_apiThrottler.CheckRateLimit(ApiRequestType.ClockPage, request);
var controller = new WebPageController(WebPageTypes.Timers);
controller.HandleRequestForWebPage(response);
}
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
try
{
using (new SecurityHub()) { }
}
catch (Exception ex)
{
throw new SecurityException($"Failed to load Security Hub, validate database connection string in configuration file: {ex.Message}", ex);
}
// Configure Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemes = AuthenticationSchemes.Ntlm;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
#if DEBUG
GlobalHost.Configuration.DisconnectTimeout = TimeSpan.FromMinutes(30);
#endif
// Enable cross-domain scripting
app.UseCors(CorsOptions.AllowAll);
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
private void HandleRequestForClockWebPageTimerData(
HttpListenerRequest request,
HttpListenerResponse response)
{
if (_optionsService.Options.IsWebClockEnabled)
{
_apiThrottler.CheckRateLimit(ApiRequestType.ClockData, request);
var timerInfo = new TimerInfoEventArgs();
OnRequestForTimerDataEvent(timerInfo);
WebPageController.HandleRequestForTimerData(response, timerInfo, _dateTimeService.Now());
}
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
settings.Converters.Add(new IsoDateTimeConverter());
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
using (new SecurityHub()) { }
// Configuration Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemes = AuthenticationSchemes.Ntlm;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
AppModel appModel = new AppModel();
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, appModel.Global.DefaultWebPage, appModel, typeof(AppModel));
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
app.Use <AuthenticationMiddleware>(new AuthenticationOptions()
{
AnonymousResourceExpression = "(?!)",
AuthFailureRedirectResourceExpression = "(?!)"
});
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public async Task GenerateLinkModelStateInvalid()
{
//Arrange
var generatLinkDto = new GenerateLinkDto();
var mockRiotService = new Mock <IRiotApiService>();
var mockSendgridService = new Mock <ISendgridService>();
var controller = new WebPageController(mockRiotService.Object, mockSendgridService.Object);
controller.ModelState.AddModelError("Testing Error", "Error");
//Act
var result = await controller.GenerateLink(generatLinkDto);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
viewResult.ViewData.ModelState.TryGetValue("Testing Error", out var error);
Assert.Equal("Error", error.Errors[0].ErrorMessage);
}
public async Task ContactSucces()
{
//Arrange
var contactDto = new ContactDto
{
Email = "*****@*****.**",
Message = "Test Message",
Name = "Test Name"
};
var mockRiotService = new Mock <IRiotApiService>();
var mockSendgridService = new Mock <ISendgridService>();
mockSendgridService.Setup(s => s.SendMail(contactDto)).Verifiable();
var controller = new WebPageController(mockRiotService.Object, mockSendgridService.Object);
//Act
var result = await controller.Contact(contactDto);
//Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
mockSendgridService.Verify();
Assert.Equal("EmailSend", redirectToActionResult.ActionName);
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
AppModel model = Program.Host.Model;
// Load security hub into application domain before establishing SignalR hub configuration, initializing default status and exception handlers
try
{
using (new SecurityHub(
(message, updateType) => Program.Host.LogWebHostStatusMessage(message, updateType),
ex => Program.Host.LogException(ex)
)) { }
}
catch (Exception ex)
{
Program.Host.LogException(new SecurityException($"Failed to load Security Hub, validate database connection string in configuration file: {ex.Message}", ex));
}
// Load shared hub into application domain, initializing default status and exception handlers
try
{
using (new SharedHub(
(message, updateType) => Program.Host.LogWebHostStatusMessage(message, updateType),
ex => Program.Host.LogException(ex)
)) { }
}
catch (Exception ex)
{
Program.Host.LogException(new SecurityException($"Failed to load Shared Hub: {ex.Message}", ex));
}
// Load Modbus assembly
try
{
// Make embedded resources of Modbus poller available to web server
using (ModbusPoller poller = new ModbusPoller())
WebExtensions.AddEmbeddedResourceAssembly(poller.GetType().Assembly);
ModbusPoller.RestoreConfigurations(FilePath.GetAbsolutePath("ModbusConfigs"));
}
catch (Exception ex)
{
Program.Host.LogException(new InvalidOperationException($"Failed to load Modbus assembly: {ex.Message}", ex));
}
// Configure Windows Authentication for self-hosted web service
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, model, typeof(AppModel));
// Make sure any hosted exceptions get propagated to service error handling
httpConfig.Services.Replace(typeof(IExceptionHandler), new HostedExceptionHandler());
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
// Enable GSF session management
httpConfig.EnableSessions(AuthenticationOptions);
// Enable GSF role-based security authentication
app.UseAuthentication(AuthenticationOptions);
// Enable cross-domain scripting default policy - controllers can manually
// apply "EnableCors" attribute to class or an action to override default
// policy configured here
try
{
if (!string.IsNullOrWhiteSpace(model.Global.DefaultCorsOrigins))
{
httpConfig.EnableCors(new EnableCorsAttribute(model.Global.DefaultCorsOrigins, model.Global.DefaultCorsHeaders, model.Global.DefaultCorsMethods)
{
SupportsCredentials = model.Global.DefaultCorsSupportsCredentials
});
}
}
catch (Exception ex)
{
Program.Host.LogException(new InvalidOperationException($"Failed to establish default CORS policy: {ex.Message}", ex));
}
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Map custom API controllers
try
{
using (new GrafanaController()) { }
httpConfig.Routes.MapHttpRoute(
name: "CustomAPIs",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { action = "Index", id = RouteParameter.Optional }
);
}
catch (Exception ex)
{
Program.Host.LogException(new InvalidOperationException($"Failed to initialize custom API controllers: {ex.Message}", ex));
}
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public void SetUp()
{
_webPageHelper = new Mock <IWebPageHelper>();
_webPageController = new WebPageController(_webPageHelper.Object);
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub into application domain before establishing SignalR hub configuration
try
{
using (new SecurityHub()) { }
}
catch (Exception ex)
{
Program.Host.LogException(new SecurityException($"Failed to load Security Hub, validate database connection string in configuration file: {ex.Message}", ex));
}
// Configure Windows Authentication for self-hosted web service
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
// Make sure any hosted exceptions get propagated to service error handling
httpConfig.Services.Replace(typeof(IExceptionHandler), new HostedExceptionHandler());
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
// Enable GSF session management
httpConfig.EnableSessions(AuthenticationOptions);
// Enable GSF role-based security authentication
app.UseAuthentication(AuthenticationOptions);
// Enable cross-domain scripting
app.UseCors(CorsOptions.AllowAll);
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Map custom API controllers
try
{
httpConfig.Routes.MapHttpRoute(
name: "Controllers",
routeTemplate: "api/{controller}/{action}/{modelName}/{id}",
defaults: new {
action = "Index",
id = RouteParameter.Optional,
modelName = RouteParameter.Optional
}
);
httpConfig.Routes.MapHttpRoute(
name: "Summary",
routeTemplate: "Summary/{*stuff}",
defaults: new
{
action = "GetPage",
controller = "Main"
}
);
}
catch (Exception ex)
{
Program.Host.LogException(new InvalidOperationException($"Failed to initialize custom API controllers: {ex.Message}", ex));
}
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
try
{
using (new SecurityHub()) { }
}
catch (Exception ex)
{
throw new SecurityException($"Failed to load Security Hub, validate database connection string in configuration file: {ex.Message}", ex);
}
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
// Make sure any hosted exceptions get propagated to service error handling
httpConfig.Services.Replace(typeof(IExceptionHandler), new HostedExceptionHandler());
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
// Enable GSF session management
httpConfig.EnableSessions(AuthenticationOptions);
// Enable GSF role-based security authentication
app.UseAuthentication(AuthenticationOptions);
// Enable cross-domain scripting default policy - controllers can manually
// apply "EnableCors" attribute to class or an action to override default
// policy configured here
try
{
if (!string.IsNullOrWhiteSpace(Program.Host.Model.Global.DefaultCorsOrigins))
{
httpConfig.EnableCors(new EnableCorsAttribute(Program.Host.Model.Global.DefaultCorsOrigins, Program.Host.Model.Global.DefaultCorsHeaders, Program.Host.Model.Global.DefaultCorsMethods)
{
SupportsCredentials = Program.Host.Model.Global.DefaultCorsSupportsCredentials
});
}
}
catch (Exception ex)
{
Program.Host.LogException(new InvalidOperationException($"Failed to establish default CORS policy: {ex.Message}", ex));
}
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
app.Use((context, next) =>
{
context.Response.Headers.Remove("Server");
return(next.Invoke());
});
app.UseStageMarker(PipelineStage.PostAcquireState);
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
using (new SecurityHub()) { }
// Configuration Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemeSelectorDelegate = AuthenticationSchemeForClient;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
#if DEBUG
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
#endif
app.Use <AuthenticationMiddleware>(new AuthenticationOptions()
{
SessionToken = "session",
AuthFailureRedirectResourceExpression = "(?!)",
AnonymousResourceExpression = "^/api/(?:JSONApi|Grafana)"
});
string allowedDomainList = ConfigurationFile.Current.Settings["systemSettings"]["AllowedDomainList"]?.Value;
if (allowedDomainList == "*")
{
app.UseCors(CorsOptions.AllowAll);
}
else if ((object)allowedDomainList != null)
{
httpConfig.EnableCors(new System.Web.Http.Cors.EnableCorsAttribute(allowedDomainList, "*", "*"));
}
CsvDownloadHandler.LogExceptionHandler = Program.Host.HandleException;
HowlCSVDownloadHandler.LogExceptionHandler = Program.Host.HandleException;
HowlCSVUploadHandler.LogExceptionHandler = Program.Host.HandleException;
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Set configuration to use reflection to setup routes
ControllerConfig.Register(httpConfig);
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
httpConfig.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
using (new SecurityHub()) { }
using (new openXDA.Adapters.JSONApiController()) { }
//using (new GrafanaController()) { }
// Configuration Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemeSelectorDelegate = AuthenticationSchemeForClient;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
#if DEBUG
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
#endif
string allowedDomainList = ConfigurationFile.Current.Settings["systemSettings"]["AllowedDomainList"]?.Value;
if (allowedDomainList == "*")
{
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
}
else if ((object)allowedDomainList != null)
{
httpConfig.EnableCors(new System.Web.Http.Cors.EnableCorsAttribute(allowedDomainList, "*", "*"));
}
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Map custom API controllers
httpConfig.Routes.MapHttpRoute(
name: "CustomAPIs",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
// Modify the JSON serializer to serialize dates as UTC - otherwise, timezone will not be appended
// to date strings and browsers will select whatever timezone suits them
JsonSerializerSettings settings = JsonUtility.CreateDefaultSerializerSettings();
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
JsonSerializer serializer = JsonSerializer.Create(settings);
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);
// Load security hub in application domain before establishing SignalR hub configuration
try
{
using (new SecurityHub()) { }
}
catch (Exception ex)
{
throw new SecurityException($"Failed to load Security Hub, validate database connection string in configuration file: {ex.Message}", ex);
}
// Configuration Windows Authentication for self-hosted web service
HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
listener.AuthenticationSchemeSelectorDelegate = AuthenticationSchemeForClient;
HubConfiguration hubConfig = new HubConfiguration();
HttpConfiguration httpConfig = new HttpConfiguration();
// Setup resolver for web page controller instances
httpConfig.DependencyResolver = WebPageController.GetDependencyResolver(WebServer.Default, Program.Host.DefaultWebPage, new AppModel(), typeof(AppModel));
// Make sure any hosted exceptions get propagated to service error handling
httpConfig.Services.Replace(typeof(IExceptionHandler), new HostedExceptionHandler());
// Enabled detailed client errors
hubConfig.EnableDetailedErrors = true;
// Load ServiceHub SignalR class
app.MapSignalR(hubConfig);
// Map specific historian instance API controllers
httpConfig.Routes.MapHttpRoute(
name: "InstanceAPIs",
routeTemplate: "instance/{instanceName}/{controller}/{action}/{id}",
defaults: new { action = "Index", id = RouteParameter.Optional }
);
// Map custom API controllers
httpConfig.Routes.MapHttpRoute(
name: "CustomAPIs",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { action = "Index", id = RouteParameter.Optional }
);
// Set configuration to use reflection to setup routes
httpConfig.MapHttpAttributeRoutes();
// Load the WebPageController class and assign its routes
app.UseWebApi(httpConfig);
// Check for configuration issues before first request
httpConfig.EnsureInitialized();
}