cms_thermo_active/Step/App_Start/Startup.cs

using Microsoft.AspNet.SignalR;
using Microsoft.Owin;
using Microsoft.Owin.Cors;
using Microsoft.Owin.FileSystems;
using Microsoft.Owin.Security.OAuth;
using Microsoft.Owin.StaticFiles;
using Newtonsoft.Json;
using Owin;
using Step.Core;
using Step.Provider;
using Step.Utils;
using System;
using System.Configuration;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
using System.Web.Http;
using static Step.Config.ServerConfig;
using static Step.Model.Constants;

[assembly: OwinStartup(typeof(Step.App_Start.Startup))]

namespace Step.App_Start
{
    public class Startup
    {
        public static OAuthAuthorizationServerOptions OAuthOptions;

        public void Configuration(IAppBuilder app)
        {
            if (NcConfig.NcVendor.ToUpper() == NC_VENDOR.SIEMENS)
                ThreadSiemensHmi.InitWindow();

            // Configure HTTP
            HttpConfiguration config = new HttpConfiguration();

            // Register Web API config
            WebApiConfig.Register(config);

            // Register Swagger config
            SwaggerConfig.Register(config);

            // Configure api authentication
            ConfigureWebApiOAuth(app);

            app.UseWebApi(config);
            
            // SignalR config & startup
            SignalRConfig(app);

            var directoryBrowsing = ConfigurationManager.AppSettings["enableDirectoryBrowsing"] == "true";
            // Create directories if they don't exist
            CreateDirectories();

            // Check if web site directory exists
            if (!Directory.Exists(WEBSITE_DIRECTORY)) 
                ExceptionManager.Manage(ERROR_LEVEL.FATAL, "Main window directory not found!");

            var options = new FileServerOptions()
            { 
                EnableDefaultFiles = !directoryBrowsing,
                EnableDirectoryBrowsing = directoryBrowsing,
                RequestPath = PathString.Empty,
                FileSystem = new PhysicalFileSystem(WEBSITE_DIRECTORY)
            };
            
            app.UseFileServer(options);
            if (!ServerPortIsAvailable(ServerStartupConfig.ServerPort))
            {
                ExceptionManager.Manage(ERROR_LEVEL.FATAL, "Server port is already in use by another process");
            }
        }

        private void ConfigureWebApiOAuth(IAppBuilder app)
        {
            // Create new authorization options
            OAuthOptions = new OAuthAuthorizationServerOptions
            {
                // Login and Token generation end point
                TokenEndpointPath = new PathString("/Token"),
                Provider = new ApplicationOAuthProvider(),
                // Bearer token expiration time
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
                //TODO: In modalità di produzione impostare AllowInsecureHttp = false
                AllowInsecureHttp = true
            };
            // Set authorization options
            app.UseOAuthAuthorizationServer(OAuthOptions);
            // Set bearer oAuth as authentication method
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
        }

        public void SignalRConfig(IAppBuilder app)
        {
            // Set CamelCase json configuration
            var settings = new JsonSerializerSettings
            {
                ContractResolver = new SignalRContractResolver()
            };

            var serializer = JsonSerializer.Create(settings);
            GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);

            // Set up signalR config
            app.Map("/signalr", map =>
            {
                map.UseCors(CorsOptions.AllowAll);
                
                map.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions()
                {
                    Provider = new SignalROAuthBearerProvider()
                });
                var hubConfiguration = new HubConfiguration
                {
                    Resolver = GlobalHost.DependencyResolver,
                    EnableDetailedErrors = true
                };
                map.RunSignalR(hubConfiguration);
            });
            //app.MapSignalR();
        }

        private bool ServerPortIsAvailable(int port)
        {
            bool isAvailable = true;

            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();

            foreach (IPEndPoint endPoint in ipEndPoints)
            {
                if (endPoint.Port == port)
                {
                    isAvailable = false;
                    break;
                }
            }

            return isAvailable;
        }

        private void CreateDirectories()
        {
            if (!Directory.Exists(MAINTENANCE_ATTACHMENT_PATH))
                Directory.CreateDirectory(MAINTENANCE_ATTACHMENT_PATH);
            if (!Directory.Exists(ALARM_ATTACHMENT_PATH))
                Directory.CreateDirectory(ALARM_ATTACHMENT_PATH);

            if (!Directory.Exists(TEMP_PP_FOLDER))
                Directory.CreateDirectory(TEMP_PP_FOLDER);

            if (!Directory.Exists(PART_PRG_IMAGES))
                Directory.CreateDirectory(PART_PRG_IMAGES);

            if (!Directory.Exists(JOB_TMP_DIRECTORY))
                Directory.CreateDirectory(JOB_TMP_DIRECTORY);

            if (!Directory.Exists(QUEUE_TMP_FOLDER))
                Directory.CreateDirectory(QUEUE_TMP_FOLDER);
        }
    }
}
//app.Map("/signalr", map =>
//{
//    map.UseCors(CorsOptions.AllowAll);
//    // Debug
//    HubConfiguration hubConfiguration = new HubConfiguration
//    {
//        EnableDetailedErrors = true
//    };
//    // Create an istance of custom authorize attribute
//    SignalRAuthorizeAttribute authorizer = new SignalRAuthorizeAttribute();
//    AuthorizeModule module = new AuthorizeModule(authorizer, authorizer);
//    GlobalHost.HubPipeline.AddModule(module);
//    map.RunSignalR();
//});