public class Program

private static bool development = true;

private readonly OcelotConfigBuilder _ocelotConfigBuilder;

public IConfiguration Configuration { get; }

private ModuleManager<IServiceCollection> _moduleManager;

public Program(IConfiguration configuration)

Configuration = configuration;

_ocelotConfigBuilder = new OcelotConfigBuilder(Configuration);

public static void Main(string[] args)

ServicePointManager.ServerCertificateValidationCallback +=

(sender, certificate, chain, errors) =>

if (development)

return true;

return errors == SslPolicyErrors.None;

};

Log.Logger = new LoggerConfiguration()

.MinimumLevel.Debug()

.Enrich.With<MethodInvocationEnricher>()

.Enrich.FromLogContext()

.WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss} [{Level}]

[{CorrelationID}] [{InvocationContextClassName}] [{InvocationContextMethodName}]
{Message} {NewLine} {Exception}") // Updated output template

.WriteTo.File("C:\\logcontext\\loglog.txt",
 outputTemplate: "{Timestamp:HH:mm:ss} [{Level}]
[{CorrelationID}] [{InvocationContextClassName}] [{InvocationContextMethodName}]
{Message} {NewLine} {Exception}",

rollingInterval: RollingInterval.Day)

.CreateLogger();

CreateHostBuilder(args).Build().Run();

public static IHostBuilder CreateHostBuilder(string[] args) =>

Host.CreateDefaultBuilder(args)

.ConfigureWebHostDefaults(webBuilder =>

webBuilder.UseKestrel()

.UseIIS()

.UseStartup<Program>();

webBuilder.ConfigureAppConfiguration(ConfigureConfig);

}).ConfigureServices(

services =>

services.AddSingleton<IHttpContextAccessor,
HttpContextAccessor>();

services.AddSingleton<ICustomIsomSerializer,
CustomIsomSerializer>();

services.AddSingleton<IDeviceSearchRequestMapper,
DeviceSearchRequestMapper>();

})

.UseServiceProviderFactory(new AutofacServiceProviderFactory());

private static void ConfigureLogger(HostBuilderContext arg1,

LoggerConfiguration arg2)

arg2.ReadFrom.Configuration(arg1.Configuration);

//arg2.ReadFrom.Configuration(arg1.Configuration);

}
private static void ConfigureConfig(WebHostBuilderContext hostingContext,
IConfigurationBuilder configBuilder)

configBuilder.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath).AddJso
nFile("appsettings.json", true, true)

.AddJsonFile($"appsettings.
{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)

.AddEnvironmentVariables();

var config = configBuilder.Build();

var deploymentType = config.GetValue<string>("DeploymentType");

configBuilder.AddOcelot($"./GatewayConfig/{deploymentType}",
hostingContext.HostingEnvironment).AddOcelotWithSwaggerSupport((o) => { o.Folder =
$"GatewayConfig/{deploymentType}"; });

// This method gets called by the runtime. Use this method to add services to
the container.

public void ConfigureServices(IServiceCollection services)

services.AddHealthChecks();

services.AddHttpContextAccessor();

ConfigureSwagger(services);

SetUpAuthentication(services);

var mvcBuilder = services.AddControllers().AddJsonOptions(opts =>

opts.JsonSerializerOptions.Converters.Add(new
JsonStringEnumConverter());

});

var path = AppDomain.CurrentDomain.BaseDirectory;

//services.AddControllers().AddNewtonsoftJson(opts =>

//{

// opts.SerializerSettings.Converters.Add(new StringEnumConverter());

//});
 var moduleManager = ModuleManager<IServiceCollection>.Create(services,
path);

moduleManager.InitializeModule();

_moduleManager = moduleManager;

foreach (var assembly in moduleManager.LoadedAssemblies)

mvcBuilder.AddApplicationPart(assembly);

services.AddCors(options =>

options.AddPolicy("AllowOrigin",

builder =>
builder.WithOrigins(Configuration.GetSection("AllowedOrigins").Value).AllowCredenti
als().AllowAnyHeader().AllowAnyMethod());

});

services.AddSwaggerForOcelot(Configuration);

services.AddOcelot().AddCacheManager(x =>

x.WithDictionaryHandle();

})

.AddPolly()

.AddDelegatingHandler<SpaceIsomSearchHandler>()

.AddDelegatingHandler<SpaceIsomHandler>()

.AddDelegatingHandler<DeviceIsomHandler>()

.AddDelegatingHandler<DoorOperationsHandler>()

.AddDelegatingHandler<TokenHandler>()

.AddDelegatingHandler<RevokeTokenHandler>()

.AddDelegatingHandler<UnAcknowledgeAlarmsRollUpHandler>()

.AddDelegatingHandler<AcknowledgeAlarmsRollUpHandler>()

.AddDelegatingHandler<MaxproAuthenticationHandler>()

.AddDelegatingHandler<StreamConfigHandler>()
 .AddDelegatingHandler<CameraStreamConfigHandler>()

.AddDelegatingHandler<MaxproStreamConfigHandler>()

.AddDelegatingHandler<CameraHandler>()

.AddDelegatingHandler<ValidateSupervisorPinIsomHandler>()

.AddDelegatingHandler<RecorderSummaryHandler>()

.AddDelegatingHandler<RecordingUnavailabilityHandler>()

.AddDelegatingHandler<HostInjectorDelegatingHandler>()

.AddDelegatingHandler<CameraConfigHandler>();

services.AddOptions();

services.AddScoped<IGatewayNegotiate, GatewayNegotiateService>();

services.AddScoped<IApiClientHelper, ApiClientHelper>();

services.AddScoped<IDeviceDetailHelper, DeviceDetailHelper>();

services.AddScoped<IUvisomRequestHandler, UvisomRequestHandler>();

services.AddTransient<IEntityMapper, EntityMapper>();

services.AddOptions();

private void SetUpAuthentication(IServiceCollection services)

if
(Configuration.GetValue<string>("DeploymentType").Equals("IntegratedSecurity",
StringComparison.InvariantCultureIgnoreCase) ||

Configuration.GetValue<string>("DeploymentType").Equals("PROWATCH",
StringComparison.InvariantCultureIgnoreCase))

//Create Seri Logger Instance and add it to Log Factory to fetch a ILogger
Instance

////For Logging Authentication Validation

var seriLogger = new LoggerConfiguration()

.ReadFrom.Configuration(Configuration)

.CreateLogger();
 var logFactory = LoggerFactory.Create(builder =>

builder.AddSerilog(seriLogger);

});

Microsoft.Extensions.Logging.ILogger logger =
logFactory.CreateLogger(LogLevel.Information.ToString());

services.AddICAuthentication(Configuration, logger);

else

AuthSetup.ConfigureAuthentication(services, Configuration);

if (!Configuration.GetValue<bool>("AllowAnonymous"))

services.AddMvc(options =>

options.EnableEndpointRouting = false;

}).AddControllersAsServices();

else

services.AddMvc(options =>

options.EnableEndpointRouting = false;

options.Filters.Add(new AllowAnonymousFilter());

}).AddControllersAsServices();

public void ConfigureContainer(ContainerBuilder containerBuilder)

 {

containerBuilder.RegisterGeneric(typeof(AppLogger<>)).As(typeof(IAppLogger<>));

// This method gets called by the runtime. Use this method to configure
the HTTP request pipeline.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

if (app != null && env != null)

if (env.IsDevelopment())

app.UseDeveloperExceptionPage();

new MvcOptions().EnableEndpointRouting = false;

HoneyEngine.ServiceProvider = app.ApplicationServices;

_moduleManager.StartModule(app.ApplicationServices);

app.UseCookiePolicy();

app.UseAuthentication();

app.UseAuthorization();

app.UseHttpsRedirection();

app.UseRouting();

app.UseSerilogRequestLogging();

app.UseCors(builder =>
builder.WithOrigins(Configuration.GetSection("AllowedOrigins").Value).AllowCredenti
als().AllowAnyHeader().AllowAnyMethod());

app.UseMiddleware<ApiLoggerMiddleware>();

app.UseMiddleware<NegotiateMiddleware>();

app.UseMiddleware<NegotiateMiddlewareV2>();

app.UseSwaggerForOcelotUI(options =>
_ocelotConfigBuilder.GetSwaggerConfiguration(options));
app.UseOcelot(_ocelotConfigBuilder.GetOcelotPipelineConfiguration()).Wait();

app.UseMvc();

UserLocalization(app);

private static void ConfigureSwagger(IServiceCollection services)

services.AddSwaggerGen(c =>

c.SwaggerDoc("v1", new OpenApiInfo { Title = "Honeywell

Security API Management", Version = "v1" });

var xmlFiles =
Directory.GetFiles(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),

"*.xml");

foreach (var xmlFile in xmlFiles)

c.IncludeXmlComments(xmlFile);

c.EnableAnnotations();

var securityScheme = new OpenApiSecurityScheme

Description = "Please enter into field the word 'Bearer'

followed by a space and the JWT value",

Name = "Bearer",

Type = SecuritySchemeType.Http,

BearerFormat = "JWT",

Scheme = "bearer"

};

c.IgnoreObsoleteActions();

c.AddSecurityDefinition("Bearer", securityScheme);

// Add security requirements globally. If needs to be unique

per operation then use IOperationFilter.
 var securityRequirement = new OpenApiSecurityRequirement

new OpenApiSecurityScheme

Reference = new OpenApiReference {Type =

ReferenceType.SecurityScheme, Id = "Bearer"}

},

new[] {"Bearer"}

};

c.AddSecurityRequirement(securityRequirement);

});

services.AddSwaggerGenNewtonsoftSupport();

private void UserLocalization(IApplicationBuilder app)

// use localization

var supportedCulturesStrings =
Configuration.GetSection("SupportedCultures").Get<string[]>();

var supportedCultures = supportedCulturesStrings.Select(item => new

CultureInfo(item)).ToList();

var options = new RequestLocalizationOptions

DefaultRequestCulture = new
RequestCulture(Configuration.GetSection("DefaultRequestCulture").Value),

SupportedCultures = supportedCultures,

SupportedUICultures = supportedCultures

};

app.UseRequestLocalization(options);

}
 }