// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();
    
            var section = Configuration.GetSection("MongoDB");
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseIISPlatformHandler();
            app.UseCors("AllowAll");
            app.UseStaticFiles();

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                  name:"api",
                  template: "api/{controller}/{id?}"  
                );
             });
        }

 public void Configure(IApplicationBuilder app)
 {
     app.Run(context =>
     {
         return context.Response.WriteAsync("Hello PriyaLaksmi");
     });
 }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app)
        {
            app.UseIISPlatformHandler();

            app.UseDefaultFiles();
            app.UseStaticFiles();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            app.UseIISPlatformHandler();

            app.UseApplicationInsightsRequestTelemetry();

            app.UseApplicationInsightsExceptionTelemetry();

            app.UseStaticFiles();

            app.Use(async (context, next) =>
            {
                context.Response.Headers.Add("Access-Control-Allow-Origin", "*");
                context.Response.Headers.Add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
                context.Response.Headers.Add("Access-Control-Allow-Headers", new[] { "Content-Type, x-xsrf-token" });

                if (context.Request.Method == "OPTIONS")
                {
                    context.Response.StatusCode = 200;
                }
                else
                {
                    await next();
                }
            });

            app.UseMvc();

            SampleData.Initialize(app.ApplicationServices);
        }

 public void Configure(IApplicationBuilder app)
 {
     app.UseMiddleware(typeof(MyMiddleware));
     
     app.Run(async context =>
         await context.Response.WriteAsync("---------- Done\r\n"));
 }

        public void Configure(IApplicationBuilder app)
        {
            app.UseRequestLocalization();

            // Add MVC to the request pipeline
            app.UseMvcWithDefaultRoute();
        }

 public void Configure(IApplicationBuilder app)
 {
     app.UseIISPlatformHandler();
     
     app.Run(async context =>
     {
         var singleton1 = context.RequestServices.GetService<ISingleton>();
         var singleton2 = context.RequestServices.GetService<ISingleton>();
         var scoped1 = context.RequestServices.GetService<IScoped>();
         var scoped2 = context.RequestServices.GetService<IScoped>();
         var transient1 = context.RequestServices.GetService<ITransient>();
         var transient2 = context.RequestServices.GetService<ITransient>();
         var instance1 = context.RequestServices.GetService<IInstance>();
         var instance2 = context.RequestServices.GetService<IInstance>();
         
         await context.Response.WriteAsync(
             "<table>" +
             $"<tr><td>Singleton 1 and Singleton 2 are the same instance:</td><td> {object.ReferenceEquals(singleton1, singleton2)}</td></tr>" +
             $"<tr><td>Instance 1 and Instance 2 are the same instance:</td><td> {object.ReferenceEquals(instance1, instance2)}</td></tr>" +
             $"<tr><td>Scoped 1 and Scoped 2 are the same instance:</td><td> {object.ReferenceEquals(scoped1, scoped2)}</td></tr>" +
             $"<tr><td>Transient 1 and Transient 2 are the same instance:</td><td> {object.ReferenceEquals(transient1, transient2)}</td></tr>" +
             "</table><br><br><table>" +
             $"<tr><td>Singleton Id:</td><td> {singleton1.Id}</td></tr>" +
             $"<tr><td>Instance Id:</td><td> {instance1.Id}</td></tr>" +
             $"<tr><td>_instanceId:</td><td> {InstanceId}</td></tr>" +
             $"<tr><td>Scoped Id:</td><td> {scoped1.Id}</td></tr>" +
             $"<tr><td>Transient 1 Id:</td><td> {transient1.Id}</td></tr>" +
             $"<tr><td>Transient 2 Id:</td><td> {transient2.Id}</td></tr>" +
             "</table>");
     });
 }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app,
            ILoggerFactory loggerFactory)
        {
            // The hosting environment can be found in a project's properties -> DEBUG or in launchSettings.json.
            if (_hostingEnvironment.IsDevelopment())
            {
                // The exception page is only shown if the app is in development mode.
                app.UseDeveloperExceptionPage();
            }

            // This middleware makes sure our app is correctly invoked by IIS.
            app.UseIISPlatformHandler();

            // Add the MVC middleware service above first. Then use said middleware in this method.
            //app.UseMvc(routes =>
            //{
            //    routes.MapRoute(
            //        name: "default",
            //        template: "{controller}/{action}/{id}",
            //        defaults: new { controller = "Home", action = "Index" }
            //    );
            //});

            app.UseMvcWithDefaultRoute();

            // Always remember to add the static files middleware or the images from JavaScript or CSS 
            // won't be served.
            app.UseStaticFiles();

            // Whenever HTTP status codes like 404 arise, the below middleware will display them on the page.
            app.UseStatusCodePages();
        }

 public void Configure(IApplicationBuilder app)
 {
     app.Run(context =>
             {
             return context.Response.WriteAsync("Hello from ASP.NET Core!");
             });
 }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, BeaconsContextSeedData seeder)
        {

            app.UseStaticFiles();
            app.UseDeveloperExceptionPage();


            Mapper.Initialize(config =>
            {
                config.CreateMap<Beacon, BeaconViewModel>().ReverseMap();
                config.CreateMap<Log, LogViewModel>().ReverseMap();
            });

            app.UseIISPlatformHandler();

            app.UseMvc(config =>
            {
                config.MapRoute(
                    name: "Default",
                    template: "{controller}/{action}/{id?}",
                    defaults: new { controller = "App", action ="Index"}
                    );
            });

            seeder.EnsureSeedData();
        }

        public void Configure(IApplicationBuilder app)
        {
            _validatorProvider.ServiceProvider = app.ApplicationServices;

            // Add MVC to the request pipeline.
            app.UseMvcWithDefaultRoute();
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseCultureReplacer();

            app.UseErrorReporter();

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "isbn10",
                    template: "book/{action}/{isbnNumber:IsbnDigitScheme10(true)}",
                    defaults: new { controller = "InlineConstraints_Isbn10" });

                routes.MapRoute("StoreId",
                        "store/{action}/{id:guid?}",
                        defaults: new { controller = "InlineConstraints_Store" });

                routes.MapRoute("StoreLocation",
                        "store/{action}/{location:minlength(3):maxlength(10)}",
                        defaults: new { controller = "InlineConstraints_Store" },
                        constraints: new { location = new AlphaRouteConstraint() });

                // Used by tests for the 'exists' constraint.
                routes.MapRoute("areaExists-area", "area-exists/{area:exists}/{controller=Home}/{action=Index}");
                routes.MapRoute("areaExists", "area-exists/{controller=Home}/{action=Index}");
                routes.MapRoute("areaWithoutExists-area", "area-withoutexists/{area}/{controller=Home}/{action=Index}");
                routes.MapRoute("areaWithoutExists", "area-withoutexists/{controller=Home}/{action=Index}");
            });
        }

 // Configure is called after ConfigureServices is called.
 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {
     // Add MVC to the request pipeline.
     app.UseMvc();
     // Add the following route for porting Web API 2 controllers.
     // routes.MapWebApiRoute("DefaultApi", "api/{controller}/{id?}");
 }

        // Configure is called after ConfigureServices is called.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.MinimumLevel = LogLevel.Information;

            // Add the following to the request pipeline only in development environment.
            if (env.IsDevelopment())
            {
                app.UseBrowserLink();
                //app.UseErrorPage(ErrorPageOptions.ShowAll);
            }
            else
            {
                // Add Error handling middleware which catches all application specific errors and
                // sends the request to the following path or controller action.
                //app.UseErrorHandler("/Home/Error");
            }

            // Add static files to the request pipeline.
            app.UseStaticFiles();

            // Add MVC to the request pipeline.
            app.UseMvc(routes =>
            {
            });

            app.UseMvc();
        }

 public static void Configure(IApplicationBuilder app)
 {
     app.UseMvc(routes => {
         routes.MapRoute("Dashboard", "app/{*catchall}", new { controller = "dashboard", action = "index" });
         routes.MapRoute("Default", "{controller=home}/{action=index}/{id?}");
     });
 }

        public void Configure(IApplicationBuilder app)
        {
            app.UseIISPlatformHandler();

			app.UseMvc(routes =>
				routes.MapRoute("default", "{controller}/{action}", new { controller = "home", action = "index" }));
        }

 public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
 {
     loggerFactory.AddConsole();
     app.UseIISPlatformHandler();
     app.UseStaticFiles();
     app.UseWelcomePage();
 }

        public void Configure(IApplicationBuilder app)
        {
            // Request pipeline

            app.UseWebSockets();

            app.Use(HandleWebSocketsAsync);

            app.UseMvc();

            // Initialization

            Task.Run(async () =>
            {
                await InitializeDatabaseAsync();
                await InitializeServiceBrokerAsync(app.ApplicationServices);
            })
            .Wait();

            // Background tasks

            Task.Run(async () =>
            {
                await ProcessMessagesAsync(app.ApplicationServices);
            });
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IConfigurationRoot configuration)
        {
            loggerFactory.AddConsole(configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            // For more details on creating database during deployment see http://go.microsoft.com/fwlink/?LinkID=615859
            try
            {
                using (var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>()
                    .CreateScope())
                {
                    using (var db = serviceScope.ServiceProvider.GetService<ApplicationDbContext>())
                    {
                        db.Database.EnsureCreated();
                        db.Database.Migrate();
                    }
                }
            }
            catch (Exception exception)
            {
            }

            app.UseCors("AllowAllOrigins");         // TODO: allow collection of allowed origins per client
            app.UseIISPlatformHandler();
            app.UseStaticFiles();
            app.UseMvc();
        }

        public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory, IApplicationEnvironment env)
        {
            var ksi = app.ServerFeatures.Get<IKestrelServerInformation>();
            ksi.NoDelay = true;

            loggerFactory.AddConsole(LogLevel.Error);

            app.UseKestrelConnectionLogging();

            app.Run(async context =>
            {
                Console.WriteLine("{0} {1}{2}{3}",
                    context.Request.Method,
                    context.Request.PathBase,
                    context.Request.Path,
                    context.Request.QueryString);
                Console.WriteLine($"Method: {context.Request.Method}");
                Console.WriteLine($"PathBase: {context.Request.PathBase}");
                Console.WriteLine($"Path: {context.Request.Path}");
                Console.WriteLine($"QueryString: {context.Request.QueryString}");

                var connectionFeature = context.Connection;
                Console.WriteLine($"Peer: {connectionFeature.RemoteIpAddress?.ToString()} {connectionFeature.RemotePort}");
                Console.WriteLine($"Sock: {connectionFeature.LocalIpAddress?.ToString()} {connectionFeature.LocalPort}");

                var content = $"Hello world!{Environment.NewLine}Received '{Args}' from command line.";
                context.Response.ContentLength = content.Length;
                context.Response.ContentType = "text/plain";
                await context.Response.WriteAsync(content);
            });
        }