Example #1
0
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR<LogWriter>("/log/write");
            app.MapSignalR<LogReader>("/log/read");

            app.MapSignalR();

            MungState.App.Pipeline.AddProcessor(new RelationalEventProcessor(PathManager.DataPath));

            var metrics = new MetricFactory(PathManager.MetricPath, MungState.App.Pipeline);

            metrics.Reload();

            Task.Run(() => {
                // If the app shut down without properly disposing of the file
                // objects, we may have a whole lot of files still marked as "active"
                // which are actually dead.
                SqlBatchChecker.CleanUpOldFiles(PathManager.DataPath, Db.Warehouse);
            });

            Task.Run(() => {
                while (true) {
                    Thread.Sleep(1000 * 60 );
                    SqlBatchChecker.Check(PathManager.DataPath, Db.Warehouse);
                }
            });
        }
        public static void ConfigureSignalR(IAppBuilder app)
        {
            // SignalR + Service Bus
            var connectionString = CloudConfigurationManager.GetSetting(ServiceBusConnectionStrings.SignalRServiceBusConnection);

            GlobalHost.DependencyResolver.UseServiceBus(connectionString, ServiceBusPathNames.SignalRServiceBus);

            // Custom UserId provider
            //GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new UserIdProvider());

#if !DEBUG
            // Minify hub javascript
            GlobalHost.DependencyResolver.Register(typeof(IJavaScriptMinifier), () => new HubMinify());
#endif

            // SignalR
#if DEBUG
            app.MapSignalR(new HubConfiguration
            {
                EnableDetailedErrors = true
            });
#else
            app.MapSignalR(new HubConfiguration());
#endif

            // Force Auth in SignalR
            GlobalHost.HubPipeline.RequireAuthentication();
        }
Example #3
0
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR<SendingConnection>("/sending-connection");
            app.MapSignalR<TestConnection>("/test-connection");
            app.MapSignalR<RawConnection>("/raw-connection");
            app.MapSignalR<StreamingConnection>("/streaming-connection");

            app.Use(typeof(ClaimsMiddleware));

            ConfigureSignalR(GlobalHost.DependencyResolver, GlobalHost.HubPipeline);

            var config = new HubConfiguration()
            {
                EnableDetailedErrors = true
            };

            app.MapSignalR(config);

            app.Map("/cors", map =>
            {
                map.UseCors(CorsOptions.AllowAll);
                map.MapSignalR<RawConnection>("/raw-connection");
                map.MapSignalR();
            });

            app.Map("/basicauth", map =>
            {
                map.UseBasicAuthentication(new BasicAuthenticationProvider());
                map.MapSignalR<AuthenticatedEchoConnection>("/echo");
                map.MapSignalR();
            });

            BackgroundThread.Start();
        }
        public void Configuration(IAppBuilder app)
        {
            app.UseCors(CorsOptions.AllowAll);
            ConfigureAuth(app);

            app.MapSignalR<AuthorizeEchoConnection>("/echo");
            app.MapSignalR();
        }
Example #5
0
        public void Configuration(IAppBuilder app)
        {
            GlobalHost.Configuration.DisconnectTimeout = TimeSpan.FromSeconds(60);

            app.MapSignalR<TestConnection>("/TestConnection");
            app.MapSignalR();

            Dashboard.Init();
        }
Example #6
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            var hubConfig = new HubConfiguration() {EnableDetailedErrors = true};
            app.MapSignalR(hubConfig); // the hub part registration (at /signalr)

            app.MapSignalR<UsersConnection>("/echo"); // the persistent connection registration
        }
Example #7
0
 public void Configuration(IAppBuilder app)
 {
     GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new UCUserIDProvider());
     app.UseCors(CorsOptions.AllowAll);
     var cfg = new HubConfiguration() {
         EnableJSONP = true,
         EnableDetailedErrors = true
     };
     app.MapSignalR("/Msg", cfg);
     app.MapSignalR(cfg);
 }
Example #8
0
        public void Configuration(IAppBuilder app)
        {
            GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new QueryStringUserIdProvider());

            app.MapSignalR<JavaScriptSendObjects.Connection>("/JavaScriptSendObjects/connection");
            app.MapSignalR<JavaScriptErrorHandling.Connection>("/JavaScriptErrorHandling/connection");
            app.MapSignalR<JavaScriptCustomJsonParsing.Connection>("/JavaScriptCustomJsonParsing/connection");
            app.MapSignalR<SendPreEncodedJson.Connection>("/SendPreEncodedJson/connection");
            
            app.MapSignalR();
            //app.MapSignalRWithCors();
        }
Example #9
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            
            app.MapSignalR<MyEndPoint>("/echo");
            app.MapSignalR<MyEndPoint2>("/echo2");
            app.MapSignalR<MyEndPointGroups>("/groups");

            app.MapSignalR();


        }
Example #10
0
 public void Configuration(IAppBuilder app)
 {
     if (Debugger.IsAttached)
     {
         var hubConfiguration = new HubConfiguration();
         hubConfiguration.EnableDetailedErrors = true;
         hubConfiguration.EnableJavaScriptProxies = true;
         app.MapSignalR("/visualcronmonitor/signalr", hubConfiguration);
     }
     else
     {
         app.MapSignalR();
     }
 }
        // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Configure the db context, user manager and signin manager to use a single instance per request
            app.CreatePerOwinContext(ApplicationDbContext.Create);
            app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);

            // Enable the application to use a cookie to store information for the signed in user
            // and to use a cookie to temporarily store information about a user logging in with a third party login provider
            // Configure the sign in cookie
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login"),
                Provider = new CookieAuthenticationProvider
                {
                    // Enables the application to validate the security stamp when the user logs in.
                    // This is a security feature which is used when you change a password or add an external login to your account.
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});

            //SignalR
            GlobalHost.DependencyResolver.Register(typeof(IHubActivator), () => new UnityHubActivator(UnityConfig.GetConfiguredContainer()));

            //var config = new HubConfiguration {EnableJSONP = true};
            //app.MapSignalR(config);

            app.MapSignalR();
        }
        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 void Configuration(IAppBuilder app)
 {
     //FiddlerFriendly(GlobalHost.DependencyResolver);
     HubConfiguration hubConfiguration = new HubConfiguration();
     hubConfiguration.EnableDetailedErrors = true;
     app.MapSignalR(hubConfiguration);
 }
Example #14
0
        public void Configuration(IAppBuilder app)
        {
            SecurityConfig.Config();
            var oauthServerConfig = new Microsoft.Owin.Security.OAuth.OAuthAuthorizationServerOptions
            {
                AllowInsecureHttp = false,
                AccessTokenExpireTimeSpan = TimeSpan.FromHours(2),
                Provider = new AuthorizationServerProvider(),
                TokenEndpointPath = new PathString("/token")
            };
            app.UseOAuthAuthorizationServer(oauthServerConfig);

            var oauthConfig = new Microsoft.Owin.Security.OAuth.OAuthBearerAuthenticationOptions
            {
                AuthenticationMode = Microsoft.Owin.Security.AuthenticationMode.Active
                //AuthenticationType = "Bearer"
            };
            app.UseOAuthBearerAuthentication(oauthConfig);
            var config = new HttpConfiguration();
            WebApiConfig.Register(config);
            app.UseWebApi(config);
            GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
            GlobalHost.Configuration.LongPollDelay = TimeSpan.FromMilliseconds(5000);
            app.MapSignalR();
        }
        public void Configuration(IAppBuilder app)
        {

            #region Global Configuration
            GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(110);
            GlobalHost.Configuration.DisconnectTimeout = TimeSpan.FromSeconds(30);
            GlobalHost.Configuration.KeepAlive = TimeSpan.FromSeconds(10);
            GlobalHost.Configuration.DefaultMessageBufferSize = 500;
            #endregion

            #region Hub Configuration
            var hubConfiguration = new HubConfiguration();
            hubConfiguration.EnableDetailedErrors = true;
            hubConfiguration.EnableJavaScriptProxies = true;
            hubConfiguration.EnableJSONP = true;
            #endregion

            //var options = new CookieAuthenticationOptions()
            //{
            //    CookieName = "Token"
            //};

            //app.UseCookieAuthentication(options);

            //app.Use<LoginMiddleware>();

            app.MapSignalR("/signalr", hubConfiguration);
        }
Example #16
0
 public void Configuration(IAppBuilder app)
 {
     Common.Setup.AutoMapper.Initialize();
     app.MapSignalR();
     app.UseNancy();
     app.UseStageMarker(PipelineStage.MapHandler);
 }    
Example #17
0
        // Дополнительные сведения о настройке проверки подлинности см. по адресу: http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            app.MapSignalR();
            // Настройка контекста базы данных, диспетчера пользователей и диспетчера входа для использования одного экземпляра на запрос
            app.CreatePerOwinContext(DAL.ApplicationDbContext.Create);
            app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);

            // Включение использования файла cookie, в котором приложение может хранить информацию для пользователя, выполнившего вход,
            // и использование файла cookie для временного хранения информации о входах пользователя с помощью стороннего поставщика входа
            // Настройка файла cookie для входа
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login"),
                Provider = new CookieAuthenticationProvider
                {
                    // Позволяет приложению проверять метку безопасности при входе пользователя.
                    // Эта функция безопасности используется, когда вы меняете пароль или добавляете внешнее имя входа в свою учетную запись.
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Позволяет приложению временно хранить информацию о пользователе, пока проверяется второй фактор двухфакторной проверки подлинности.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Позволяет приложению запомнить второй фактор проверки имени входа. Например, это может быть телефон или почта.
            // Если выбрать этот параметр, то на устройстве, с помощью которого вы входите, будет сохранен второй шаг проверки при входе.
            // Точно так же действует параметр RememberMe при входе.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
        }
        public static new void Install(HttpConfiguration config, IAppBuilder app)
        {
            config.SuppressHostPrincipal();

            SecurityApi.Services.Contracts.IIdentityService identityService = UnityConfiguration.GetContainer().Resolve<SecurityApi.Services.Contracts.IIdentityService>();

            app.UseOAuthAuthorizationServer(new OAuthOptions(identityService));

            app.UseJwtBearerAuthentication(new SecurityApi.Auth.JwtOptions());

            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            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 void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            app.Map("/signalr-diagnostic", builder=>{

                builder.Run(ctx =>
                    ctx.Response.WriteAsync(
            @"<!DOCTYPE html>

            <html lang=""en"">
            <head>
            <meta charset=""utf-8"" />
            <title>TypeScript HTML App</title>
            <link rel=""stylesheet"" href=""app.css"" type=""text/css"" />
            <script data-main=""main"" src=""Scripts/require.js""></script>
            </head>
            <body>
            <h1>TypeScript HTML App</h1>
            <button data-bind=""click:toggleState"">Toggle</button>
            <div data-bind=""foreach : perfcounters"">
            <span data-bind=""text:Name""></span> : <span data-bind=""text:Value""></span><br />
            </div>
            </body>
            </html>"));

            });
            // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
        }
Example #20
0
        // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Enable the application to use a cookie to store information for the signed in user
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login")
            });
            // Use a cookie to temporarily store information about a user logging in with a third party login provider
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication();
            app.MapSignalR();
        }
Example #21
0
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration
                .Configuration
                .Formatters
                .JsonFormatter
                .SerializerSettings
                .ContractResolver = new CamelCasePropertyNamesContractResolver();

            var serializer = JsonSerializer.Create(new JsonSerializerSettings
            {
                ContractResolver = new SignalRContractResolver()
            });
            GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => serializer);

            GlobalConfiguration.Configuration.Routes.MapHttpRoute(
                "DefaultApi",
                "api/{controller}/{id}",
                new {id = RouteParameter.Optional}
            );
            RouteTable.Routes.MapRoute(
                "Default",
                "{controller}/{action}/{id}",
                new { controller = "Activity", action = "Index", id = UrlParameter.Optional }
            );

            app.MapSignalR();
        }
Example #22
0
        public void Configuration(IAppBuilder app)
        {
            app.UseAbp();

            DataProtectionProvider = app.GetDataProtectionProvider();

            app.UseOAuthBearerAuthentication(AccountController.OAuthBearerOptions);

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login")
            });

            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            if (IsTrue("ExternalAuth.Facebook.IsEnabled"))
            {
                app.UseFacebookAuthentication(CreateFacebookAuthOptions());
            }

            if (IsTrue("ExternalAuth.Twitter.IsEnabled"))
            {
                app.UseTwitterAuthentication(CreateTwitterAuthOptions());
            }

            if (IsTrue("ExternalAuth.Google.IsEnabled"))
            {
                app.UseGoogleAuthentication(CreateGoogleAuthOptions());
            }

            app.MapSignalR();
        }
        public void Configuration(IAppBuilder app)
        {
            // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
            var hubConfiguration = new HubConfiguration { EnableDetailedErrors = true };

            app.MapSignalR(hubConfiguration);
        }
 public void Configuration(IAppBuilder app)
 {
     // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
     // Any connection or hub wire up and configuration should go here
     
     app.MapSignalR();
 }
Example #25
0
 private void ConfigureSignalR(IAppBuilder app)
 {
     GlobalHost.DependencyResolver.Register(
         typeof(ChatHub),
         () => new ChatHub(new MessagesServices(new QmsData())));
     app.MapSignalR();
 }
Example #26
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            EnsureValidCulture();
            app.MapSignalR();
        }
Example #27
0
 public void Configuration(IAppBuilder app)
 {
     app.MapSignalR();
     GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(110);
     GlobalHost.Configuration.DisconnectTimeout = TimeSpan.FromSeconds(10);
     GlobalHost.Configuration.KeepAlive = TimeSpan.FromSeconds(2);
 }
        public void Configuration(IAppBuilder app)
        {
            //// Turn cross domain on
            var config = new ConnectionConfiguration {EnableJSONP = true};

            //// This will map out to http://localhost:8080/signalr by default
            ////app.MapConnection<MyServerConnection>("/messaging", config);

            //app.Map("/messaging", map =>
            //{
            //    //.UseCors(CorsOptions.AllowAll);
            //    var hubConfiguration = new HubConfiguration
            //    {
            //        // You can enable JSONP by uncommenting line below.
            //        // JSONP requests are insecure but some older browsers (and some
            //        // versions of IE) require JSONP to work cross domain
            //        // EnableJSONP = true
            //    };
            //    // Run the SignalR pipeline. We're not using MapSignalR
            //    // since this branch already runs under the "/signalr"
            //    // path.
            //    map.RunSignalR(hubConfiguration);
            //});
            app.MapSignalR<MyServerConnection>("/messaging", config);
        }
Example #29
0
		public void Configuration(IAppBuilder app)
		{

			app.UseCors(CorsOptions.AllowAll);

			InitializeAutoMapper ();

			// Rest API Setup
			var config = new HttpConfiguration(); 

			config.MapHttpAttributeRoutes ();

			// Use only JSON by default.
			var xmlFormatterSupportedMediaTypes = config.Formatters.XmlFormatter.SupportedMediaTypes;
			var appXmlType = xmlFormatterSupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
			xmlFormatterSupportedMediaTypes.Remove(appXmlType);

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

			config.Filters.Add(new ExceptionHandlerFilter(config.Formatters.JsonFormatter));

			app.UseWebApi(config);

			app.MapSignalR <Echo>("/test");

		}
Example #30
0
        // Para obtener más información para configurar la autenticación, visite http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Permitir que la aplicación use una cookie para almacenar información para el usuario que inicia sesión
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login")
            });
            // Use a cookie to temporarily store information about a user logging in with a third party login provider
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            //=============SignalR
            app.MapSignalR();

            // Quitar los comentarios de las siguientes líneas para habilitar el inicio de sesión con proveedores de inicio de sesión de terceros
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication();
        }
 //чтобы задействовать фукциональность SignalR
 public void Configuration(IAppBuilder app)
 {
     GlobalHost.DependencyResolver.UseSqlServer(ConfigurationManager.ConnectionStrings["PersonalContext"].ToString());
     app.MapSignalR();
 }
Example #32
0
 public void Configuration(IAppBuilder app)
 {
     app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
     app.MapSignalR();
 }
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     app.MapSignalR();
     //app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
 }
Example #34
0
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR <SendingConnection>("/sending-connection");
            app.MapSignalR <TestConnection>("/test-connection");
            app.MapSignalR <RawConnection>("/raw-connection");
            app.MapSignalR <StreamingConnection>("/streaming-connection");

            app.Use(typeof(ClaimsMiddleware));

            ConfigureSignalR(GlobalHost.DependencyResolver, GlobalHost.HubPipeline);

            app.Map("/cors", map =>
            {
                map.UseCors(CorsOptions.AllowAll);
                map.MapSignalR <RawConnection>("/raw-connection");
                map.MapSignalR();
            });

            app.Map("/cookieauth", map =>
            {
                var options = new CookieAuthenticationOptions()
                {
                    AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
                    LoginPath          = CookieAuthenticationDefaults.LoginPath,
                    LogoutPath         = CookieAuthenticationDefaults.LogoutPath,
                };

                map.UseCookieAuthentication(options);

                map.Use(async(context, next) =>
                {
                    if (context.Request.Path.Value.Contains(options.LoginPath.Value))
                    {
                        if (context.Request.Method == "POST")
                        {
                            var form     = await context.Request.ReadFormAsync();
                            var userName = form["UserName"];
                            var password = form["Password"];

                            var identity = new ClaimsIdentity(options.AuthenticationType);
                            identity.AddClaim(new Claim(ClaimTypes.Name, userName));
                            context.Authentication.SignIn(identity);
                        }
                    }
                    else
                    {
                        await next();
                    }
                });

                map.MapSignalR <AuthenticatedEchoConnection>("/echo");
                map.MapSignalR();
            });

            var config = new HubConfiguration()
            {
                EnableDetailedErrors = true
            };

            app.MapSignalR(config);

            BackgroundThread.Start();
        }
 public void Configuration(IAppBuilder app)
 {
     // Para obtener más información acerca de cómo configurar su aplicación, visite http://go.microsoft.com/fwlink/?LinkID=316888
     app.MapSignalR();
     //app.MapSignalR("/~/signalr", new HubConfiguration());
 }
Example #36
0
 public void Configuration(IAppBuilder app)
 {
     Microsoft.AspNet.SignalR.GlobalHost.Configuration.DefaultMessageBufferSize = 50;
     app.MapSignalR();
 }
Example #37
0
 public static void ConfigureSignalR(IAppBuilder app, HubConfiguration config)
 {
     app.MapSignalR(config);
 }
Example #38
0
 public void Configuration(IAppBuilder app)
 {
     app.MapSignalR();
 }
Example #39
0
 public void Configuration(IAppBuilder app)
 {
     GlobalHost.DependencyResolver.Register(
         typeof(IUserIdProvider), () => new HubUserProvider());
     app.MapSignalR();
 }
Example #40
0
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     app.MapSignalR();
 }
Example #41
0
 public void Configuration(IAppBuilder app)
 {
     // 有关如何配置应用程序的详细信息,请访问 https://go.microsoft.com/fwlink/?LinkID=316888
     app.MapSignalR();
 }
Example #42
0
        public void Configuration(IAppBuilder appBuilder)
        {
            appBuilder.UseCors(CorsOptions.AllowAll);

            appBuilder.MapSignalR("/signalchat", new HubConfiguration());
        }
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     app.MapSignalR(); < --{ Add this line }
Example #44
0
 public void Configuration(IAppBuilder app)
 {
     app.UseCors(CorsOptions.AllowAll);
     app.MapSignalR();
 }
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            // Configure Web API for self-host.
            var config      = new HttpConfiguration();
            var corsOptions = new CorsOptions
            {
                PolicyProvider = new CorsPolicyProvider
                {
                    PolicyResolver = c => Task.FromResult(new CorsPolicy
                    {
                        AllowAnyHeader      = true,
                        AllowAnyMethod      = true,
                        AllowAnyOrigin      = true,
                        SupportsCredentials = true
                    })
                }
            };

            app.Map("/signalr", map =>
            {
                map.UseCors(CorsOptions.AllowAll);
                var hubConfiguration = new HubConfiguration {
                };
                map.RunSignalR(hubConfiguration);
            });

            config.Formatters.Clear();
            config.Formatters.Add(new JsonMediaTypeFormatter());

            config.MapHttpAttributeRoutes();

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

            config.Routes.MapHttpRoute(
                name: "journals",
                routeTemplate: "api/trades/journals/{orderId}",
                defaults: new { }
                );

            config.Routes.MapHttpRoute(
                name: "allocations",
                routeTemplate: "api/trades/allocations/{orderId}",
                defaults: new { }
                );

            config.Routes.MapHttpRoute(
                name: "SecurityData-Queries",
                routeTemplate: "api/{controller}/data/{symbol}",
                defaults: new
            {
            }
                );

            app.UseCors(corsOptions);
            app.UseWebApi(config);
            AppStartCacheHelper.CacheReferenceData();
        }
Example #46
0
 public void Configuration(IAppBuilder app)
 {
     // Any connection or hub wire up and configuration should go here
     app.MapSignalR();
 }
Example #47
0
        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();
        }
Example #48
0
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     CreateRolesandUsers();
     app.MapSignalR();
 }
Example #49
0
        public static void BuildWithContainer(IAppBuilder app, Container container)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }

            Config = new HttpConfiguration();

            if (Settings.Current.ShouldAutoUpgradeDatabase)
            {
                var    url          = new MongoUrl(Settings.Current.MongoConnectionString);
                string databaseName = url.DatabaseName;
                if (Settings.Current.AppendMachineNameToDatabase)
                {
                    databaseName += String.Concat("-", Environment.MachineName.ToLower());
                }

                MongoMigrationChecker.EnsureLatest(Settings.Current.MongoConnectionString, databaseName);
            }

            Config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
            Config.Formatters.Remove(Config.Formatters.XmlFormatter);
            Config.Formatters.JsonFormatter.SerializerSettings.Formatting       = Formatting.Indented;
            Config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new LowerCaseUnderscorePropertyNamesContractResolver();

            var constraintResolver = new DefaultInlineConstraintResolver();

            constraintResolver.ConstraintMap.Add("objectid", typeof(ObjectIdRouteConstraint));
            constraintResolver.ConstraintMap.Add("objectids", typeof(ObjectIdsRouteConstraint));
            constraintResolver.ConstraintMap.Add("token", typeof(TokenRouteConstraint));
            constraintResolver.ConstraintMap.Add("tokens", typeof(TokensRouteConstraint));
            Config.MapHttpAttributeRoutes(constraintResolver);
            //Config.EnableSystemDiagnosticsTracing();

            container.RegisterSingle <JsonSerializer>(JsonSerializer.Create(new JsonSerializerSettings {
                ContractResolver = new SignalRContractResolver()
            }));
            container.RegisterWebApiFilterProvider(Config);

            VerifyContainer(container);

            container.Bootstrap(Config);
            container.Bootstrap(app);
            Log.Info().Message("Starting api...").Write();

            Config.Services.Add(typeof(IExceptionLogger), new NLogExceptionLogger());
            Config.Services.Replace(typeof(IExceptionHandler), container.GetInstance <ExceptionlessReferenceIdExceptionHandler>());

            Config.MessageHandlers.Add(container.GetInstance <XHttpMethodOverrideDelegatingHandler>());
            Config.MessageHandlers.Add(container.GetInstance <EncodingDelegatingHandler>());
            Config.MessageHandlers.Add(container.GetInstance <AuthMessageHandler>());

            // Throttle api calls to X every 15 minutes by IP address.
            Config.MessageHandlers.Add(container.GetInstance <ThrottlingHandler>());

            // Reject event posts in orgs over their max event limits.
            Config.MessageHandlers.Add(container.GetInstance <OverageHandler>());

            app.UseCors(new CorsOptions {
                PolicyProvider = new CorsPolicyProvider
                {
                    PolicyResolver = ctx => Task.FromResult(new CorsPolicy
                    {
                        AllowAnyHeader      = true,
                        AllowAnyMethod      = true,
                        AllowAnyOrigin      = true,
                        SupportsCredentials = true,
                        PreflightMaxAge     = 60 * 5
                    })
                }
            });

            app.CreatePerContext <Lazy <User> >("User", ctx => new Lazy <User>(() => {
                if (ctx.Request.User == null || ctx.Request.User.Identity == null || !ctx.Request.User.Identity.IsAuthenticated)
                {
                    return(null);
                }

                string userId = ctx.Request.User.GetUserId();
                if (String.IsNullOrEmpty(userId))
                {
                    return(null);
                }

                var userRepository = container.GetInstance <IUserRepository>();
                return(userRepository.GetById(userId, true));
            }));

            app.CreatePerContext <Lazy <Project> >("DefaultProject", ctx => new Lazy <Project>(() => {
                if (ctx.Request.User == null || ctx.Request.User.Identity == null || !ctx.Request.User.Identity.IsAuthenticated)
                {
                    return(null);
                }

                // TODO: Use project id from url. E.G., /projects/{projectId:objectid}/events
                string projectId      = ctx.Request.User.GetDefaultProjectId();
                var projectRepository = container.GetInstance <IProjectRepository>();

                if (String.IsNullOrEmpty(projectId))
                {
                    var firstOrgId = ctx.Request.User.GetOrganizationIds().FirstOrDefault();
                    if (!String.IsNullOrEmpty(firstOrgId))
                    {
                        var project = projectRepository.GetByOrganizationId(firstOrgId, useCache: true).FirstOrDefault();
                        if (project != null)
                        {
                            return(project);
                        }
                    }

                    if (Settings.Current.WebsiteMode == WebsiteMode.Dev)
                    {
                        var dataHelper = container.GetInstance <DataHelper>();
                        // create a default org and project
                        projectId = dataHelper.CreateDefaultOrganizationAndProject(ctx.Request.GetUser());
                    }
                }

                if (String.IsNullOrEmpty(projectId))
                {
                    return(null);
                }

                return(projectRepository.GetById(projectId, true));
            }));

            app.UseWebApi(Config);
            var resolver = new SimpleInjectorSignalRDependencyResolver(container);

            if (Settings.Current.EnableRedis)
            {
                resolver.UseRedis(new RedisScaleoutConfiguration(Settings.Current.RedisConnectionString, "exceptionless.signalr"));
            }
            app.MapSignalR("/api/v2/push", new HubConfiguration {
                Resolver = resolver
            });

            Config.EnableSwagger("schema/{apiVersion}", c => {
                c.SingleApiVersion("v2", "Exceptionless");
                c.ApiKey("access_token").In("header").Name("access_token").Description("API Key Authentication");
                c.BasicAuth("basic").Description("Basic HTTP Authentication");
                c.IncludeXmlComments(String.Format(@"{0}\bin\Exceptionless.Api.xml", AppDomain.CurrentDomain.BaseDirectory));
                c.IgnoreObsoleteActions();
                c.DocumentFilter <FilterRoutesDocumentFilter>();
            }).EnableSwaggerUi("docs/{*assetPath}", c => {
                c.InjectStylesheet(typeof(AppBuilder).Assembly, "Exceptionless.Api.Content.docs.css");
                c.InjectJavaScript(typeof(AppBuilder).Assembly, "Exceptionless.Api.Content.docs.js");
            });

            Mapper.Configuration.ConstructServicesUsing(container.GetInstance);

            var context = new OwinContext(app.Properties);
            var token   = context.Get <CancellationToken>("host.OnAppDisposing");

            CreateSampleData(container);

            if (Settings.Current.RunJobsInProcess)
            {
                Task.Factory.StartNew(() => container.GetInstance <EventPostsJob>().RunContinuousAsync(token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                Task.Factory.StartNew(() => container.GetInstance <EventUserDescriptionsJob>().RunContinuousAsync(token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                Task.Factory.StartNew(() => container.GetInstance <MailMessageJob>().RunContinuousAsync(token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                Task.Factory.StartNew(() => container.GetInstance <EventNotificationsJob>().RunContinuousAsync(token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                Task.Factory.StartNew(() => container.GetInstance <WebHooksJob>().RunContinuousAsync(token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                //Task.Factory.StartNew(() => container.GetInstance<DailySummaryJob>().RunContinuousAsync(delay: TimeSpan.FromMinutes(15), token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                //Task.Factory.StartNew(() => container.GetInstance<RetentionLimitsJob>().RunContinuousAsync(delay: TimeSpan.FromHours(8), token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
                //Task.Factory.StartNew(() => container.GetInstance<StaleAccountsJob>().RunContinuousAsync(delay: TimeSpan.FromHours(8), token: token), token, TaskCreationOptions.LongRunning, TaskScheduler.Default).IgnoreExceptions();
            }
        }
Example #50
0
 public static void Configuration(IAppBuilder app)
 {
     app.MapSignalR <PersistentCommandController>("/api/commandstream");
     app.MapSignalR("/api/filesystemhub", new HubConfiguration());
 }
 public void Configuration(IAppBuilder app)
 {
     app.MapSignalR();
     GlobalHost.Configuration.DisconnectTimeout = new TimeSpan(0, 0, 20);
 }
        public static void Configuration(IAppBuilder app)
        {
            // For more information on how to configure your application using OWIN startup, visit http://go.microsoft.com/fwlink/?LinkID=316888

            app.MapSignalR();
        }
Example #53
0
 public void Configuration(IAppBuilder app)
 {
     // アプリケーションの構成方法の詳細については、https://go.microsoft.com/fwlink/?LinkID=316888 を参照してください-
     app.MapSignalR();
 }
Example #54
0
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
        }
Example #55
0
 public void Configuration(IAppBuilder app)
 {
     app.MapSignalR();
     GlobalHost.Configuration.MaxIncomingWebSocketMessageSize = 1024 * 1000;
 }
Example #56
0
        public void Configuration(IAppBuilder app, string virtualRoot, string routPrefix)
        {
            VirtualRoot = virtualRoot;

            _assembliesPath = HostingEnvironment.MapPath(VirtualRoot + "/App_Data/Modules");
            var modulesVirtualPath  = VirtualRoot + "/Modules";
            var modulesPhysicalPath = HostingEnvironment.MapPath(modulesVirtualPath).EnsureEndSeparator();

            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;

            //Modules initialization
            var bootstrapper = new VirtoCommercePlatformWebBootstrapper(modulesVirtualPath, modulesPhysicalPath, _assembliesPath);

            bootstrapper.Run();

            var container = bootstrapper.Container;

            container.RegisterInstance(app);

            var moduleInitializerOptions = (ModuleInitializerOptions)container.Resolve <IModuleInitializerOptions>();

            moduleInitializerOptions.VirtualRoot = virtualRoot;
            moduleInitializerOptions.RoutPrefix  = routPrefix;

            //Initialize Platform dependencies
            const string connectionStringName = "VirtoCommerce";

            InitializePlatform(app, container, connectionStringName);

            var moduleManager = container.Resolve <IModuleManager>();
            var moduleCatalog = container.Resolve <IModuleCatalog>();

            var applicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase.EnsureEndSeparator();

            // Register URL rewriter for platform scripts
            var scriptsPhysicalPath        = HostingEnvironment.MapPath(VirtualRoot + "/Scripts").EnsureEndSeparator();
            var scriptsRelativePath        = MakeRelativePath(applicationBase, scriptsPhysicalPath);
            var platformUrlRewriterOptions = new UrlRewriterOptions();

            platformUrlRewriterOptions.Items.Add(PathString.FromUriComponent("/$(Platform)/Scripts"), "");
            app.Use <UrlRewriterOwinMiddleware>(platformUrlRewriterOptions);
            app.UseStaticFiles(new StaticFileOptions
            {
                FileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(scriptsRelativePath)
            });

            // Register URL rewriter before modules initialization
            if (Directory.Exists(modulesPhysicalPath))
            {
                var modulesRelativePath = MakeRelativePath(applicationBase, modulesPhysicalPath);

                var urlRewriterOptions = new UrlRewriterOptions();

                foreach (var module in moduleCatalog.Modules.OfType <ManifestModuleInfo>())
                {
                    var urlRewriteKey   = string.Format(CultureInfo.InvariantCulture, "/Modules/$({0})", module.ModuleName);
                    var urlRewriteValue = MakeRelativePath(modulesPhysicalPath, module.FullPhysicalPath);
                    urlRewriterOptions.Items.Add(PathString.FromUriComponent(urlRewriteKey), "/" + urlRewriteValue);

                    moduleInitializerOptions.ModuleDirectories.Add(module.ModuleName, module.FullPhysicalPath);
                }

                app.Use <UrlRewriterOwinMiddleware>(urlRewriterOptions);
                app.UseStaticFiles(new StaticFileOptions
                {
                    FileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(modulesRelativePath)
                });
            }

            // Ensure all modules are loaded
            foreach (var module in moduleCatalog.Modules.Where(x => x.State == ModuleState.NotStarted))
            {
                moduleManager.LoadModule(module.ModuleName);
            }

            // Post-initialize

            // Platform MVC configuration
            if (IsApplication)
            {
                AreaRegistration.RegisterAllAreas();
            }

            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();

            // Security OWIN configuration
            var authenticationOptions = new AuthenticationOptions
            {
                CookiesEnabled             = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:Cookies.Enabled", true),
                CookiesValidateInterval    = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:Cookies.ValidateInterval", TimeSpan.FromDays(1)),
                BearerTokensEnabled        = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:BearerTokens.Enabled", true),
                BearerTokensExpireTimeSpan = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:BearerTokens.AccessTokenExpireTimeSpan", TimeSpan.FromHours(1)),
                HmacEnabled = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:Hmac.Enabled", true),
                HmacSignatureValidityPeriod = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:Hmac.SignatureValidityPeriod", TimeSpan.FromMinutes(20)),
                ApiKeysEnabled                  = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:ApiKeys.Enabled", true),
                ApiKeysHttpHeaderName           = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:ApiKeys.HttpHeaderName", "api_key"),
                ApiKeysQueryStringParameterName = ConfigurationManager.AppSettings.GetValue("VirtoCommerce:Authentication:ApiKeys.QueryStringParameterName", "api_key"),
            };

            OwinConfig.Configure(app, container, connectionStringName, authenticationOptions);

            RecurringJob.AddOrUpdate <SendNotificationsJobs>("SendNotificationsJob", x => x.Process(), "*/1 * * * *");

            var notificationManager = container.Resolve <INotificationManager>();

            notificationManager.RegisterNotificationType(() => new RegistrationEmailNotification(container.Resolve <IEmailNotificationSendingGateway>())
            {
                DisplayName          = "Registration notification",
                Description          = "This notification sends by email to client when he finish registration",
                NotificationTemplate = new NotificationTemplate
                {
                    Body     = PlatformNotificationResource.RegistrationNotificationBody,
                    Subject  = PlatformNotificationResource.RegistrationNotificationSubject,
                    Language = "en-US"
                }
            });

            var postInitializeModules = moduleCatalog.CompleteListWithDependencies(moduleCatalog.Modules)
                                        .Where(m => m.ModuleInstance != null)
                                        .ToArray();

            foreach (var module in postInitializeModules)
            {
                moduleManager.PostInitializeModule(module);
            }

            // SignalR
            var tempCounterManager = new TempPerformanceCounterManager();

            GlobalHost.DependencyResolver.Register(typeof(IPerformanceCounterManager), () => tempCounterManager);
            var hubConfiguration = new HubConfiguration();

            hubConfiguration.EnableJavaScriptProxies = false;
            app.MapSignalR("/" + moduleInitializerOptions.RoutPrefix + "signalr", hubConfiguration);
        }
Example #57
0
 public void Configuration(IAppBuilder app)
 {
     app.MapSignalR();
     // GlobalHost.HubPipeline.AddModule(new RejoingGroupPipelineModule());
 }
Example #58
0
 public void Configuration(IAppBuilder app)
 {
     // Any connection or hub wire up and configuration should go here
     app.MapSignalR("/signalr", new Microsoft.AspNet.SignalR.HubConfiguration());
 }
Example #59
0
 public void Configuration(IAppBuilder app)
 {
     //RabbitMQConsummer v = RabbitMQConsummer.Instance;//.ConfigureRabbitMQ();
     app.MapSignalR();
     ConfigureAuth(app);
 }
Example #60
0
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     app.MapSignalR <OrderConnection>("/OrderInfo");
     app.MapSignalR();
 }