public static IServiceCollection AddTracing(this IServiceCollection services, IWebHostEnvironment environment, IConfiguration configuration)
{
string agentHost;
int agentPort;
if (environment.IsLocal())
{
agentHost = configuration["Jaeger:AgentHost"];
agentPort = int.Parse(configuration["Jaeger:AgentPort"]);
}
else
{
agentHost = EnvironmentVariableHelper.Get("Jaeger:AgentHost", configuration);
agentPort = int.Parse(EnvironmentVariableHelper.Get("Jaeger:AgentPort", configuration));
}
var connection = ConnectionMultiplexer.Connect(EnvironmentVariableHelper.Get("Redis:Endpoint", configuration));
var serviceName = $"{environment.ApplicationName}-{environment.EnvironmentName}";
services.AddOpenTelemetryTracing(builder =>
{
builder.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName))
.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddRedisInstrumentation(connection)
.AddJaegerExporter(options =>
{
options.AgentHost = agentHost;
options.AgentPort = agentPort;
})
.SetSampler(new AlwaysOnSampler());
});
return(services);
}
public static IWebHostBuilder CreateHostBuilder(string[] args)
=> WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseStartup <Startup>()
.ConfigureAppConfiguration((hostingContext, config) =>
{
var environment = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", false, true)
.AddJsonFile($"appsettings.{environment.EnvironmentName}.json", true, true);
config.AddEnvironmentVariables();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.ClearProviders()
.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
var env = hostingContext.HostingEnvironment;
if (env.IsLocal())
{
logging.AddConsole();
}
else
{
logging
.AddStdOutLogger(options =>
{
options.IncludeScopes = false;
options.RequestIdHeader = Constants.DefaultRequestIdHeader;
options.UseUtcTimestamp = true;
})
.AddSentry(options => { options.Dsn = EnvironmentVariableHelper.Get("Logging:Sentry:Endpoint", hostingContext.Configuration); });
}
})
.UseSetting(WebHostDefaults.SuppressStatusMessagesKey, "true");
public static IServiceCollection AddTracing(this IServiceCollection services, IWebHostEnvironment environment, IConfiguration configuration)
{
string agentHost;
int agentPort;
if (environment.IsLocal())
{
agentHost = configuration["Jaeger:AgentHost"];
agentPort = int.Parse(configuration["Jaeger:AgentPort"]);
}
else
{
agentHost = EnvironmentVariableHelper.Get("Jaeger:AgentHost", configuration);
agentPort = int.Parse(EnvironmentVariableHelper.Get("Jaeger:AgentPort", configuration));
}
var serviceName = $"{environment.ApplicationName}-{environment.EnvironmentName}";
services.AddOpenTelemetrySdk(builder =>
{
builder.AddRequestInstrumentation()
.AddDependencyInstrumentation()
.UseJaegerActivityExporter(options =>
{
options.ServiceName = serviceName;
options.AgentHost = agentHost;
options.AgentPort = agentPort;
})
.SetResource(Resources.CreateServiceResource(serviceName))
.SetSampler(new AlwaysOnActivitySampler());
});
return(services);
}
protected WapClient(string endPoint, string name)
: this(string.Empty, 0, endPoint, name)
{
ControllerAddress = EnvironmentVariableHelper.Get("WAP_CONTROLLER_ADDRESS", "localhost");
ControllerPort = int.Parse(EnvironmentVariableHelper.Get("WAP_CONTROLLER_PORT", "51234"));
_controllerEp = WapEndPoint.Parse(EnvironmentVariableHelper.Get("WAP_CONTROLLER_ENDPOINT", ":control"));
}
private VaultClient.VaultClient GetVaultClient()
{
var vaultOptions = new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
};
return(new VaultClient.VaultClient(vaultOptions, new NullLoggerFactory()));
}
public void ConfigureServices(IServiceCollection services)
{
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).GetAwaiter().GetResult();
var authorityOptions = vaultClient.Get(Configuration["Authority:Options"]).GetAwaiter().GetResult();
services.AddHealthChecks()
.AddDbContextCheck <EdoContext>()
.AddRedis(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration));
services.ConfigureAuthentication(authorityOptions);
services.AddControllers()
.AddNewtonsoftJson(opts => opts.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()))
.AddJsonOptions(opts => opts.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()))
.AddFluentValidation(fv =>
{
fv.DisableDataAnnotationsValidation = true;
fv.ImplicitlyValidateRootCollectionElements = true;
fv.ImplicitlyValidateChildProperties = true;
fv.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly());
});
services.AddResponseCompression();
services.ConfigureTracing(Configuration, HostEnvironment);
services.AddProblemDetailsErrorHandling();
services.ConfigureApiVersioning();
services.ConfigureSwagger();
services.ConfigureCache(Configuration);
services.ConfigureHttpClients(Configuration, HostEnvironment, vaultClient, authorityOptions["authorityUrl"]);
services.ConfigureServiceOptions(Configuration, HostEnvironment, vaultClient);
services.ConfigureUserEventLogging(Configuration, vaultClient);
services.AddServices(HostEnvironment, Configuration, vaultClient);
services.AddSignalR().AddStackExchangeRedis(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration));
// override services
services.AddTransient <AccommodationAvailabilitiesService>();
services.AddTransient <AccommodationService>();
services.AddTransient <IAgentContextService, AgentContextService>();
services.AddTransient <BookingCancellationService>();
services.AddTransient <IBookingEvaluationService, DirectApiBookingEvaluationService>();
services.AddTransient <INotificationService, EdoDummyNotificationService>();
services.AddTransient <ValuationService>();
services.AddTransient <WideAvailabilitySearchService>();
services.AddTransient <BookingInfoService>();
services.AddTransient <BookingCreationService>();
services.AddTransient <IBookingRegistrationService, DirectApiBookingRegistrationService>();
services.AddTransient <ClientReferenceCodeValidationService>();
services.ConfigureWideAvailabilityStorage(HostEnvironment, Configuration, vaultClient);
}
public static IServiceCollection ConfigureCache(this IServiceCollection collection, IConfiguration configuration)
{
return(collection
.AddMemoryCache()
.AddMemoryFlow()
.AddStackExchangeRedisCache(options =>
{
var host = EnvironmentVariableHelper.Get("Redis:Endpoint", configuration);
options.ConfigurationOptions = new ConfigurationOptions
{
EndPoints = { new DnsEndPoint(host, 6379) },
AsyncTimeout = 15000, // set to 15 seconds before we stop storing large objects in Redis
};
})
.AddDoubleFlow()
.AddCacheFlowJsonSerialization());
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).GetAwaiter().GetResult();
services.AddHealthChecks();
services.ConfigureServiceOptions(Configuration, vaultClient)
.AddServices()
.AddMemoryCache();
services.AddStaticDataPublicationServices(vaultClient, Configuration, _environment);
services.AddHostedService <DataUpdateHostedService>();
services.AddTracing(Configuration, options =>
{
options.ServiceName = $"{_environment.ApplicationName}-{_environment.EnvironmentName}";
options.JaegerHost = _environment.IsLocal()
? Configuration.GetValue <string>("Jaeger:AgentHost")
: Configuration.GetValue <string>(Configuration.GetValue <string>("Jaeger:AgentHost"));
options.JaegerPort = _environment.IsLocal()
? Configuration.GetValue <int>("Jaeger:AgentPort")
: Configuration.GetValue <int>(Configuration.GetValue <string>("Jaeger:AgentPort"));
options.RedisEndpoint = Configuration.GetValue <string>(Configuration.GetValue <string>("Redis:Endpoint"));
});
}
public static IHostBuilder CreateHostBuilder(string[] args)
=> Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>()
.UseDefaultServiceProvider(s =>
{
s.ValidateScopes = true;
s.ValidateOnBuild = true;
});
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.ClearProviders()
.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
var env = hostingContext.HostingEnvironment;
if (env.IsLocal())
{
logging.AddConsole();
}
else
{
logging.AddStdOutLogger(setup =>
{
setup.IncludeScopes = false;
setup.RequestIdHeader = Constants.DefaultRequestIdHeader;
setup.UseUtcTimestamp = true;
});
logging.AddSentry(c =>
{
c.Dsn = EnvironmentVariableHelper.Get("Logging:Sentry:Endpoint", hostingContext.Configuration);
c.Environment = env.EnvironmentName;
});
}
});
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"],
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration))
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).Wait();
var jobsSettings = vaultClient.Get(Configuration["Identity:JobsOptions"]).GetAwaiter().GetResult();
var clientSecret = jobsSettings[Configuration["Identity:Secret"]];
var edoSettings = vaultClient.Get(Configuration["Edo:EdoOptions"]).GetAwaiter().GetResult();
var authorityUrl = edoSettings[Configuration["Identity:Authority"]];
var edoApiUrl = edoSettings[Configuration["Edo:Api"]];
services.AddAccessTokenManagement(options =>
{
options.User.RefreshBeforeExpiration = TimeSpan.FromMinutes(2);
options.Client.Clients.Add(HttpClientNames.Identity, new ClientCredentialsTokenRequest
{
Address = $"{authorityUrl}connect/token",
ClientId = Configuration["Identity:ClientId"],
ClientSecret = clientSecret
});
});
services.AddTracing(Configuration, options =>
{
options.ServiceName = $"{_environment.ApplicationName}-{_environment.EnvironmentName}";
options.JaegerHost = _environment.IsLocal()
? Configuration.GetValue <string>("Jaeger:AgentHost")
: Configuration.GetValue <string>(Configuration.GetValue <string>("Jaeger:AgentHost"));
options.JaegerPort = _environment.IsLocal()
? Configuration.GetValue <int>("Jaeger:AgentPort")
: Configuration.GetValue <int>(Configuration.GetValue <string>("Jaeger:AgentPort"));
});
services
.Configure <CompletionOptions>(Configuration.GetSection("Completion"))
.Configure <ChargeOptions>(Configuration.GetSection("Charge"))
.Configure <CancellationOptions>(Configuration.GetSection("Cancellation"))
.Configure <NotificationOptions>(Configuration.GetSection("Notification"))
.Configure <MarkupBonusMaterializationOptions>(Configuration.GetSection("MarkupBonusMaterialization"))
.Configure <RefundOptions>(Configuration.GetSection("Refund"));
services.AddHttpClient(HttpClientNames.EdoApi, client =>
{
client.BaseAddress = new Uri(edoApiUrl);
client.Timeout = TimeSpan.FromHours(1);
})
.AddPolicyHandler((sp, _) => Policy(sp))
.AddClientAccessTokenHandler(HttpClientNames.Identity);
services.AddHealthChecks();
services.AddHostedService <UpdaterService>();
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCaseExceptDictionaryKeysResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = GetVaultClient();
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).Wait();
AddDatabase(services, vaultClient);
var currencyLayerOptions = vaultClient.Get(Configuration["CurrencyLayer:Options"]).Result;
services.Configure <CurrencyLayerOptions>(options => { options.ApiKey = currencyLayerOptions["apiKey"]; });
services.Configure <FlowOptions>(options => { options.SuppressCacheExceptions = false; });
services.AddHttpClient(HttpClientNames.CurrencyLayer, client => { client.BaseAddress = new Uri("http://apilayer.net/api/"); })
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(GetDefaultRetryPolicy());
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = false;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
});
services.AddHealthChecks()
.AddDbContextCheck <CurrencyConverterContext>()
.AddCheck <ControllerResolveHealthCheck>(nameof(ControllerResolveHealthCheck));
var messagePackOptions = MessagePackSerializerOptions.Standard
.WithCompression(MessagePackCompression.Lz4BlockArray);
services.AddMemoryCache()
.AddStackExchangeRedisCache(options => { options.Configuration = Configuration["Redis:Endpoint"]; })
.AddDoubleFlow()
.AddCacheFlowMessagePackSerialization(messagePackOptions, StandardResolver.Instance, NativeDecimalResolver.Instance,
CSharpFunctionalExtensionsFormatResolver.Instance, ProblemDetailsFormatResolver.Instance)
.AddControllers()
.AddControllersAsServices();
services.AddTransient <IRateService, RateService>();
services.AddTransient <IConversionService, ConversionService>();
services.AddProblemDetailsFactory();
var bufferPairs = Configuration.GetSection("BufferPairs").Get <List <BufferPair> >();
services.AddCurrencyConversionFactory(bufferPairs);
services.AddTracing(Configuration, options =>
{
options.ServiceName = $"{_environment.ApplicationName}-{_environment.EnvironmentName}";
options.JaegerHost = _environment.IsLocal()
? Configuration.GetValue <string>("Jaeger:AgentHost")
: Configuration.GetValue <string>(Configuration.GetValue <string>("Jaeger:AgentHost"));
options.JaegerPort = _environment.IsLocal()
? Configuration.GetValue <int>("Jaeger:AgentPort")
: Configuration.GetValue <int>(Configuration.GetValue <string>("Jaeger:AgentPort"));
});
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1.0", new OpenApiInfo {
Title = "HappyTravel.com Currency Converter API", Version = "v1.0"
});
var apiXmlCommentsFilePath = Path.Combine(AppContext.BaseDirectory, $"{Assembly.GetExecutingAssembly().GetName().Name}.xml");
options.IncludeXmlComments(apiXmlCommentsFilePath);
foreach (var assembly in Assembly.GetExecutingAssembly().GetReferencedAssemblies())
{
var path = Path.Combine(AppContext.BaseDirectory, $"{assembly.Name}.xml");
if (File.Exists(path))
{
options.IncludeXmlComments(path);
}
}
});
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).GetAwaiter().GetResult();
services.AddResponseCompression()
.AddCors()
.AddLocalization()
.AddMemoryCache()
.AddMemoryFlow()
.AddStackExchangeRedisCache(options => { options.Configuration = EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration); })
.AddDoubleFlow()
.AddCacheFlowJsonSerialization()
.AddTracing(HostingEnvironment, Configuration);
services.ConfigureServiceOptions(Configuration, HostingEnvironment, vaultClient)
.ConfigureHttpClients(Configuration, HostingEnvironment, vaultClient)
.ConfigureAuthentication(Configuration, HostingEnvironment, vaultClient)
.AddServices();
services.AddHealthChecks()
.AddDbContextCheck <EdoContext>()
.AddRedis(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration))
.AddCheck <ControllerResolveHealthCheck>(nameof(ControllerResolveHealthCheck));
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = false;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
});
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1.0", new OpenApiInfo {
Title = "HappyTravel.com Edo API", Version = "v1.0"
});
var xmlCommentsFileName = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlCommentsFilePath = Path.Combine(AppContext.BaseDirectory, xmlCommentsFileName);
options.IncludeXmlComments(xmlCommentsFilePath);
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
Array.Empty <string>()
}
});
});
services.AddSwaggerGenNewtonsoftSupport();
services.AddOData();
services.AddMvcCore(options =>
{
options.Conventions.Insert(0, new LocalizationConvention());
options.Conventions.Add(new AuthorizeControllerModelConvention());
options.Filters.Add(new MiddlewareFilterAttribute(typeof(LocalizationPipelineFilter)));
options.Filters.Add(typeof(ModelValidationFilter));
AddODataMediaTypes(options);
})
.AddAuthorization()
.AddControllersAsServices()
.AddMvcOptions(m => m.EnableEndpointRouting = true)
.AddFormatterMappings()
.AddNewtonsoftJson(options => options.SerializerSettings.Converters.Add(new StringEnumConverter()))
.AddApiExplorer()
.AddCacheTagHelper()
.AddDataAnnotations();
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).GetAwaiter().GetResult();
services.AddMemoryCache()
.AddStackExchangeRedisCache(options =>
{
options.Configuration = EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration);
})
.AddDoubleFlow();
services.ConfigureServiceOptions(Configuration, vaultClient)
.AddServices();
services.AddHealthChecks()
.AddCheck <ControllerResolveHealthCheck>(nameof(ControllerResolveHealthCheck))
.AddRedis(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration));
services.AddResponseCompression()
.AddHttpContextAccessor()
.AddCors()
.AddLocalization()
.AddMemoryCache()
.AddTracing(Configuration, options =>
{
options.ServiceName = $"{_environment.ApplicationName}-{_environment.EnvironmentName}";
options.JaegerHost = _environment.IsLocal()
? Configuration.GetValue <string>("Jaeger:AgentHost")
: Configuration.GetValue <string>(Configuration.GetValue <string>("Jaeger:AgentHost"));
options.JaegerPort = _environment.IsLocal()
? Configuration.GetValue <int>("Jaeger:AgentPort")
: Configuration.GetValue <int>(Configuration.GetValue <string>("Jaeger:AgentPort"));
options.RedisEndpoint = Configuration.GetValue <string>(Configuration.GetValue <string>("Redis:Endpoint"));
});
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = false;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
});
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1.0",
new OpenApiInfo {
Title = "HappyTravel.com Property Management System API", Version = "v1.0"
});
var apiXmlCommentsFilePath = Path.Combine(AppContext.BaseDirectory,
$"{Assembly.GetExecutingAssembly().GetName().Name}.xml");
options.IncludeXmlComments(apiXmlCommentsFilePath);
foreach (var assembly in Assembly.GetExecutingAssembly().GetReferencedAssemblies())
{
var path = Path.Combine(AppContext.BaseDirectory, $"{assembly.Name}.xml");
if (File.Exists(path))
{
options.IncludeXmlComments(path);
}
}
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
Array.Empty <string>()
}
});
options.CustomSchemaIds(t => t.ToString());
});
// services.AddSwaggerGenNewtonsoftSupport();
services.AddMvcCore()
.AddFormatterMappings()
.AddNewtonsoftJson()
.AddApiExplorer()
.AddCacheTagHelper()
.AddControllersAsServices()
.AddAuthorization(options =>
{
options.FallbackPolicy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
options.AddPolicy("CanEdit", policy =>
{
policy.RequireClaim("scope", "mapper.edit");
});
});
services.AddTransient <ILocationMappingInfoService, LocationMappingInfoService>();
services.AddTransient <ILocationMappingFactory, LocationMappingFactory>();
services.AddTransient <CountryHtIdMappingService>();
services.AddStaticDataPublicationServices(vaultClient, Configuration, _environment);
services.AddProblemDetailsErrorHandling();
}
public static IServiceCollection ConfigureServiceOptions(this IServiceCollection services,
IConfiguration configuration, VaultClient.VaultClient vaultClient)
{
var databaseOptions = vaultClient.Get(configuration["Nakijin:Database:Options"]).GetAwaiter().GetResult();
services.AddDbContext <NakijinContext>(options =>
{
var host = databaseOptions["host"];
var port = databaseOptions["port"];
var password = databaseOptions["password"];
var userId = databaseOptions["userId"];
var connectionString = configuration.GetConnectionString("Nakijin");
options.UseNpgsql(string.Format(connectionString, host, port, userId, password), builder =>
{
builder.CommandTimeout(120);
builder.UseNetTopologySuite();
builder.EnableRetryOnFailure();
});
options.EnableSensitiveDataLogging(false);
options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}, ServiceLifetime.Singleton, ServiceLifetime.Singleton);
services.Configure <StaticDataLoadingOptions>(o =>
{
var preloadingBatchSize =
EnvironmentVariableHelper.Get("Workers:StaticDataLoadingOptions:PreloadingBatchSize", configuration);
var mappingBatchSize =
EnvironmentVariableHelper.Get("Workers:StaticDataLoadingOptions:MappingBatchSize", configuration);
var dataCorrectionBatchSize =
EnvironmentVariableHelper.Get("Workers:StaticDataLoadingOptions:DataCorrectionBatchSize", configuration);
var dbCommandTimeOut =
EnvironmentVariableHelper.Get("Workers:StaticDataLoadingOptions:DbCommandTimeOut", configuration);
o.PreloadingBatchSize = string.IsNullOrWhiteSpace(preloadingBatchSize)
? Models.Constants.DefaultPreloadingBatchSize
: int.Parse(preloadingBatchSize);
o.MappingBatchSize = string.IsNullOrWhiteSpace(mappingBatchSize)
? Models.Constants.DefaultMappingBatchSize
: int.Parse(mappingBatchSize);
o.DataCorrectionBatchSize = string.IsNullOrWhiteSpace(dataCorrectionBatchSize)
? Models.Constants.DefaultDataCorrectionBatchSize
: int.Parse(dataCorrectionBatchSize);
o.DbCommandTimeOut = string.IsNullOrWhiteSpace(dbCommandTimeOut)
? Models.Constants.DefaultDbCommandTimeOut
: int.Parse(dbCommandTimeOut);
});
services.Configure <UpdateOptions>(o =>
{
var workersToRun = EnvironmentVariableHelper.Get("Workers:WorkersToRun", configuration);
var supplierCodes = EnvironmentVariableHelper.Get("Workers:Suppliers", configuration);
o.WorkersToRun = string.IsNullOrWhiteSpace(workersToRun)
? Enum.GetValues(typeof(WorkerTypes))
.Cast <WorkerTypes>()
.Except(new WorkerTypes[] { WorkerTypes.None }).ToList()
: workersToRun.Split(';').Select(s => s.Trim()).Select(Enum.Parse <WorkerTypes>).ToList();
o.Suppliers = string.IsNullOrWhiteSpace(supplierCodes)
? null
: supplierCodes.Split(';').Select(s => s.Trim()).ToList();
});
services.Configure <MappingOptions>(o =>
{
var mappingMode = EnvironmentVariableHelper.Get("Workers:MappingOptions:MappingMode", configuration);
o.Mode = string.IsNullOrWhiteSpace(mappingMode)
? MappingModes.Full
: Enum.Parse <MappingModes>(mappingMode);
});
services.Configure <DataCorrectionOptions>(o =>
{
var dataCorrectionMode = EnvironmentVariableHelper.Get("Workers:DataCorrectionOptions:DataCorrectionMode", configuration);
o.Mode = string.IsNullOrWhiteSpace(dataCorrectionMode)
? DataCorrectionModes.Full
: Enum.Parse <DataCorrectionModes>(dataCorrectionMode);
});
services.Configure <LocalityCollectionOptions>(o =>
{
var collectionMode = EnvironmentVariableHelper.Get("Workers:LocalityCollectionOptions:CollectionMode", configuration);
o.CollectionMode = string.IsNullOrWhiteSpace(collectionMode)
? LocalityCollectionModes.Full
: Enum.Parse <LocalityCollectionModes>(collectionMode);
});
var clientOptions = vaultClient.Get(configuration["Nakijin:Client:Options"]).GetAwaiter().GetResult();
var authorityOptions = vaultClient.Get(configuration["Nakijin:Authority:Options"]).GetAwaiter().GetResult();
var authorityUrl = authorityOptions["authorityUrl"];
services.AddAccessTokenManagement(options =>
{
options.Client.Clients.Add(HttpClientNames.Identity, new ClientCredentialsTokenRequest
{
Address = new Uri(new Uri(authorityUrl), "/connect/token").ToString(),
ClientId = clientOptions["clientId"],
ClientSecret = clientOptions["clientSecret"],
});
});
services.AddClientAccessTokenHttpClient(HttpClientNames.Connectors, configureClient: (Action <HttpClient>)null !);
var suppliersEndpoint = configuration.GetValue <string>("Suppliers:Endpoint");
services.AddSupplierOptionsClient(o
=> o.BaseEndpoint = suppliersEndpoint,
HttpClientNames.Identity);
return(services);
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = new VaultClient.VaultClient(new VaultOptions
{
BaseUrl = new Uri(EnvironmentVariableHelper.Get("Vault:Endpoint", Configuration)),
Engine = Configuration["Vault:Engine"],
Role = Configuration["Vault:Role"]
});
vaultClient.Login(EnvironmentVariableHelper.Get("Vault:Token", Configuration)).GetAwaiter().GetResult();
services.AddResponseCompression()
.AddCors()
.AddLocalization()
.AddMemoryCache()
.AddMemoryFlow()
.AddStackExchangeRedisCache(options =>
{
var host = EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration);
options.ConfigurationOptions = new ConfigurationOptions
{
EndPoints = { new DnsEndPoint(host, 6379) },
AsyncTimeout = 15000, // set to 15 seconds before we stop storing large objects in Redis
};
})
.AddDoubleFlow()
.AddCacheFlowJsonSerialization()
.AddTracing(Configuration, options =>
{
options.ServiceName = $"{HostingEnvironment.ApplicationName}-{HostingEnvironment.EnvironmentName}";
options.JaegerHost = HostingEnvironment.IsLocal()
? Configuration.GetValue <string>("Jaeger:AgentHost")
: Configuration.GetValue <string>(Configuration.GetValue <string>("Jaeger:AgentHost"));
options.JaegerPort = HostingEnvironment.IsLocal()
? Configuration.GetValue <int>("Jaeger:AgentPort")
: Configuration.GetValue <int>(Configuration.GetValue <string>("Jaeger:AgentPort"));
options.RedisEndpoint = Configuration.GetValue <string>(Configuration.GetValue <string>("Redis:Endpoint"));
})
.AddUserEventLogging(Configuration, vaultClient);
var(apiName, authorityUrl) = GetApiNameAndAuthority(Configuration, HostingEnvironment, vaultClient);
services.ConfigureServiceOptions(Configuration, HostingEnvironment, vaultClient)
.ConfigureHttpClients(Configuration, HostingEnvironment, vaultClient, authorityUrl)
.ConfigureAuthentication(Configuration, HostingEnvironment, apiName, authorityUrl)
.AddServices(HostingEnvironment, Configuration, vaultClient);
services.AddHealthChecks()
.AddDbContextCheck <EdoContext>()
.AddRedis(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration))
.AddCheck <ControllerResolveHealthCheck>(nameof(ControllerResolveHealthCheck));
services.AddProblemDetailsErrorHandling();
services.AddApiVersioning(options =>
{
options.AssumeDefaultVersionWhenUnspecified = false;
options.DefaultApiVersion = new ApiVersion(1, 0);
options.ReportApiVersions = true;
});
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("agent", new OpenApiInfo {
Title = "Happytravel.com Edo API for an agent app", Version = "v1.0"
});
options.SwaggerDoc("admin", new OpenApiInfo {
Title = "Happytravel.com Edo API for an admin app", Version = "v1.0"
});
options.SwaggerDoc("property-owner", new OpenApiInfo {
Title = "Happytravel.com Edo API for property owners", Version = "v1.0"
});
options.SwaggerDoc("service", new OpenApiInfo {
Title = "Happytravel.com service Edo API", Version = "v1.0"
});
var xmlCommentsFileName = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlCommentsFilePath = Path.Combine(AppContext.BaseDirectory, xmlCommentsFileName);
options.IncludeXmlComments(xmlCommentsFilePath);
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
Array.Empty <string>()
}
});
// Use fully qualified object names
options.CustomSchemaIds(x => x.FullName);
});
services.AddSwaggerGenNewtonsoftSupport();
services.AddNotificationCenter(EnvironmentVariableHelper.Get("Redis:Endpoint", Configuration));
services.AddMvcCore(options =>
{
options.Conventions.Insert(0, new LocalizationConvention());
options.Conventions.Add(new AuthorizeControllerModelConvention());
options.Conventions.Add(new ApiExplorerGroupPerVersionConvention());
options.Filters.Add(new MiddlewareFilterAttribute(typeof(LocalizationPipelineFilter)));
options.Filters.Add(typeof(ModelValidationFilter));
AddODataMediaTypes(options);
})
.AddAuthorization()
.AddControllersAsServices()
.AddMvcOptions(m => m.EnableEndpointRouting = true)
.AddFormatterMappings()
.AddNewtonsoftJson(options => options.SerializerSettings.Converters.Add(new StringEnumConverter()))
.AddApiExplorer()
.AddCacheTagHelper()
.AddDataAnnotations()
.AddOData(opt => opt.Filter().Select().OrderBy().SetMaxTop(100));
}
public static IServiceCollection AddServices(this IServiceCollection services, IHostEnvironment environment, IConfiguration configuration, VaultClient.VaultClient vaultClient)
{
services.AddScoped <IdempotentFunctionExecutor>();
services.AddScoped <IdempotentBookingExecutor>();
services.AddSingleton(NtsGeometryServices.Instance.CreateGeometryFactory(GeoConstants.SpatialReferenceId));
services.AddSingleton <IConnectionMultiplexer>(ConnectionMultiplexer.Connect(EnvironmentVariableHelper.Get("Redis:Endpoint", configuration)));
services.AddSingleton <IDistributedLocker, RedisDistributedLocker>();
services.AddTransient <IConnectorClient, ConnectorClient>();
services.AddSingleton <IConnectorSecurityTokenManager, ConnectorSecurityTokenManager>();
services.AddTransient <ICountryService, CountryService>();
services.AddTransient <IGeoCoder, GoogleGeoCoder>();
services.AddSingleton <IVersionService, VersionService>();
services.AddTransient <ILocationService, LocationService>();
services.AddTransient <IAgencyVerificationService, AgencyVerificationService>();
services.AddTransient <Services.Agents.IAgentService, Services.Agents.AgentService>();
services.AddTransient <IAgentRolesService, AgentRolesService>();
services.AddTransient <IAgentRegistrationService, AgentRegistrationService>();
services.AddTransient <IAccountPaymentService, AccountPaymentService>();
services.AddTransient <IAgencyAccountService, AgencyAccountService>();
services.AddTransient <IPaymentSettingsService, PaymentSettingsService>();
services.AddTransient <IBookingOfflinePaymentService, BookingOfflinePaymentService>();
services.AddTransient <IBookingCreditCardPaymentService, BookingCreditCardPaymentService>();
services.AddTransient <IBookingAccountPaymentService, BookingAccountPaymentService>();
services.AddTransient <IBookingPaymentCallbackService, BookingPaymentCallbackService>();
services.AddScoped <IAgentContextService, HttpBasedAgentContextService>();
services.AddScoped <IAgentContextInternal, HttpBasedAgentContextService>();
services.AddHttpContextAccessor();
services.AddSingleton <IDateTimeProvider, DefaultDateTimeProvider>();
services.AddTransient <IBookingRecordManager, BookingRecordManager>();
services.AddTransient <ITagProcessor, TagProcessor>();
services.AddSingleton <IMailSender, SendGridMailSender>();
services.AddSingleton <ITokenInfoAccessor, TokenInfoAccessor>();
services.AddSingleton <IIdentityUserInfoService, IdentityUserInfoService>();
services.AddTransient <IAccountBalanceAuditService, AccountBalanceAuditService>();
services.AddTransient <ICreditCardAuditService, CreditCardAuditService>();
services.AddTransient <IOfflinePaymentAuditService, OfflinePaymentAuditService>();
services.AddTransient <IAccountManagementService, AccountManagementService>();
services.AddTransient <IAdministratorService, AdministratorService>();
services.AddTransient <IAdministratorRolesManagementService, AdministratorRolesManagementService>();
services.AddTransient <IAdministratorManagementService, AdministratorManagementService>();
services.AddTransient <IAgentRolesManagementService, AgentRolesManagementService>();
services.AddScoped <IAdministratorContext, HttpBasedAdministratorContext>();
services.AddScoped <IServiceAccountContext, HttpBasedServiceAccountContext>();
services.AddTransient <IInvitationRecordService, InvitationRecordService>();
services.AddTransient <IAgentInvitationRecordListService, AgentInvitationRecordListService>();
services.AddTransient <IAgentInvitationAcceptService, AgentInvitationAcceptService>();
services.AddTransient <IAdminInvitationAcceptService, AdminInvitationAcceptService>();
services.AddTransient <IAgentInvitationCreateService, AgentInvitationCreateService>();
services.AddTransient <IAdminInvitationCreateService, AdminInvitationCreateService>();
services.AddTransient <IExternalAdminContext, ExternalAdminContext>();
services.AddScoped <IManagementAuditService, ManagementAuditService>();
services.AddScoped <IEntityLocker, EntityLocker>();
services.AddTransient <IAccountPaymentProcessingService, AccountPaymentProcessingService>();
services.AddTransient <IPayfortService, PayfortService>();
services.AddTransient <ICreditCardsManagementService, CreditCardsManagementService>();
services.AddTransient <IPayfortSignatureService, PayfortSignatureService>();
services.AddTransient <IMarkupPolicyService, MarkupPolicyService>();
services.AddTransient <IMarkupService, MarkupService>();
services.AddTransient <IDiscountFunctionService, DiscountFunctionService>();
services.AddTransient <IDisplayedMarkupFormulaService, DisplayedMarkupFormulaService>();
services.AddTransient <IMarkupBonusMaterializationService, MarkupBonusMaterializationService>();
services.AddTransient <IMarkupBonusDisplayService, MarkupBonusDisplayService>();
services.AddSingleton <IMarkupPolicyTemplateService, MarkupPolicyTemplateService>();
services.AddScoped <IAgentMarkupPolicyManager, AgentMarkupPolicyManager>();
services.AddScoped <IAgencyMarkupPolicyManager, AgencyMarkupPolicyManager>();
services.AddTransient <IMarkupPolicyAuditService, MarkupPolicyAuditService>();
services.AddScoped <IAdminMarkupPolicyManager, AdminMarkupPolicyManager>();
services.AddTransient <IAgencyDiscountManagementService, AgencyDiscountManagementService>();
services.AddScoped <ICurrencyRateService, CurrencyRateService>();
services.AddScoped <ICurrencyConverterService, CurrencyConverterService>();
services.AddTransient <ISupplierOrderService, SupplierOrderService>();
services.AddSingleton <IJsonSerializer, NewtonsoftJsonSerializer>();
services.AddTransient <IAgentSettingsManager, AgentSettingsManager>();
services.AddTransient <IAgentStatusManagementService, AgentStatusManagementService>();
services.AddTransient <IPaymentLinkService, PaymentLinkService>();
services.AddTransient <IPaymentLinksProcessingService, PaymentLinksProcessingService>();
services.AddTransient <IPaymentLinksStorage, PaymentLinksStorage>();
services.AddTransient <IPaymentCallbackDispatcher, PaymentCallbackDispatcher>();
services.AddTransient <IAgentRolesAssignmentService, AgentRolesAssignmentService>();
services.AddTransient <IPermissionChecker, PermissionChecker>();
services.AddTransient <IBookingNotificationService, BookingNotificationService>();
services.AddTransient <IBookingDocumentsMailingService, BookingDocumentsMailingService>();
services.AddTransient <IBookingReportsService, BookingReportsService>();
services.AddTransient <IPaymentHistoryService, PaymentHistoryService>();
services.AddTransient <IBookingDocumentsService, BookingDocumentsService>();
services.AddTransient <IBookingAuditLogService, BookingAuditLogService>();
services.AddSingleton <ISupplierConnectorManager, SupplierConnectorManager>();
services.AddTransient <IWideAvailabilitySearchService, WideAvailabilitySearchService>();
services.AddTransient <IWideAvailabilityPriceProcessor, WideAvailabilityPriceProcessor>();
services.AddTransient <IWideAvailabilityAccommodationsStorage, WideAvailabilityAccommodationsStorage>();
services.AddTransient <IRoomSelectionService, RoomSelectionService>();
services.AddTransient <IRoomSelectionPriceProcessor, RoomSelectionPriceProcessor>();
services.AddTransient <IBookingEvaluationService, BookingEvaluationService>();
services.AddTransient <IBookingEvaluationPriceProcessor, BookingEvaluationPriceProcessor>();
services.AddTransient <ISupplierBookingManagementService, SupplierBookingManagementService>();
services.AddTransient <IFinancialAccountBookingFlow, FinancialAccountBookingFlow>();
services.AddTransient <IBankCreditCardBookingFlow, BankCreditCardBookingFlow>();
services.AddTransient <IOfflinePaymentBookingFlow, OfflinePaymentBookingFlow>();
services.AddTransient <IBookingInfoService, BookingInfoService>();
services.AddTransient <IBookingRequestExecutor, BookingRequestExecutor>();
services.AddTransient <IBookingRequestStorage, BookingRequestStorage>();
services.AddTransient <IBookingResponseProcessor, BookingResponseProcessor>();
services.AddTransient <IBookingRecordsUpdater, BookingRecordsUpdater>();
services.AddTransient <IBookingRegistrationService, BookingRegistrationService>();
services.AddTransient <IBookingChangeLogService, BookingChangeLogService>();
services.AddTransient <IBookingMoneyReturnService, BookingMoneyReturnService>();
services.AddTransient <IBookingsProcessingService, BookingsProcessingService>();
services.AddTransient <IDeadlineService, DeadlineService>();
services.AddTransient <IAppliedBookingMarkupRecordsManager, AppliedBookingMarkupRecordsManager>();
services.AddTransient <IAgentBookingDocumentsService, AgentBookingDocumentsService>();
services.AddSingleton <IAuthorizationPolicyProvider, CustomAuthorizationPolicyProvider>();
services.AddTransient <IAuthorizationHandler, InAgencyPermissionAuthorizationHandler>();
services.AddTransient <IAuthorizationHandler, MinAgencyVerificationStateAuthorizationHandler>();
services.AddTransient <IAuthorizationHandler, AdministratorPermissionsAuthorizationHandler>();
services.AddTransient <IAuthorizationHandler, AgentRequiredAuthorizationHandler>();
services.AddTransient <IAuthorizationHandler, ServiceAccountRequiredAuthorizationHandler>();
services.AddTransient <ICreditCardPaymentProcessingService, CreditCardPaymentProcessingService>();
services.AddTransient <ICreditCardMoneyAuthorizationService, CreditCardMoneyAuthorizationService>();
services.AddTransient <ICreditCardMoneyCaptureService, CreditCardMoneyCaptureService>();
services.AddTransient <ICreditCardMoneyRefundService, CreditCardMoneyRefundService>();
services.AddTransient <IPayfortResponseParser, PayfortResponseParser>();
services.AddTransient <ICreditCardPaymentConfirmationService, CreditCardPaymentConfirmationService>();
services.AddTransient <ICompanyService, CompanyService>();
services.AddTransient <MailSenderWithCompanyInfo>();
// Default behaviour allows not authenticated requests to be checked by authorization policies.
// Special wrapper returns Forbid result for them.
// More information: https://github.com/dotnet/aspnetcore/issues/4656
services.AddTransient <IPolicyEvaluator, ForbidUnauthenticatedPolicyEvaluator>();
// Default policy evaluator needs to be registered as dependency of ForbidUnauthenticatedPolicyEvaluator.
services.AddTransient <PolicyEvaluator>();
services.AddTransient <NetstormingResponseService>();
services.AddTransient <WebhookResponseService>();
services.AddNameNormalizationServices();
services.AddTransient <IMultiProviderAvailabilityStorage, MultiProviderAvailabilityStorage>();
services.AddTransient <IWideAvailabilitySearchStateStorage, WideAvailabilitySearchStateStorage>();
services.AddTransient <IRoomSelectionStorage, RoomSelectionStorage>();
var isUseMongoDbStorage = configuration.GetValue <bool>("WideAvailabilityStorage:UseMongoDbStorage");
if (isUseMongoDbStorage)
{
services.AddMongoDbStorage(environment, configuration, vaultClient);
services.AddTransient <IWideAvailabilityStorage, MongoDbWideAvailabilityStorage>();
}
else
{
services.AddTransient <IWideAvailabilityStorage, RedisWideAvailabilityStorage>();
}
services.AddTransient <IBookingEvaluationStorage, BookingEvaluationStorage>();
services.AddTransient <IRootAgencySystemSettingsService, RootAgencySystemSettingsService>();
services.AddTransient <IPriceProcessor, PriceProcessor>();
services.AddTransient <IInvoiceService, InvoiceService>();
services.AddTransient <IReceiptService, ReceiptService>();
services.AddTransient <IPaymentDocumentsStorage, PaymentDocumentsStorage>();
services.AddTransient <IPaymentLinkNotificationService, PaymentLinkNotificationService>();
services.AddTransient <AdministratorServices.IAgentService, AdministratorServices.AgentService>();
services.AddTransient <IAgentSystemSettingsService, AgentSystemSettingsService>();
services.AddTransient <IAgencySystemSettingsService, AgencySystemSettingsService>();
services.AddTransient <IAgentSystemSettingsManagementService, AgentSystemSettingsManagementService>();
services.AddTransient <IAgencySystemSettingsManagementService, AgencySystemSettingsManagementService>();
services.AddTransient <IBookingService, BookingService>();
services.AddTransient <IAccommodationBookingSettingsService, AccommodationBookingSettingsService>();
services.AddTransient <IContractFileManagementService, ContractFileManagementService>();
services.AddTransient <IContractFileService, ContractFileService>();
services.AddTransient <IImageFileService, ImageFileService>();
services.AddTransient <IAnalyticsService, ElasticAnalyticsService>();
services.AddTransient <IBookingAnalyticsService, BookingAnalyticsService>();
services.AddTransient <IAgentMovementService, AgentMovementService>();
services.AddTransient <IAgentBookingManagementService, AgentBookingManagementService>();
services.AddTransient <IAdministratorBookingManagementService, AdministratorBookingManagementService>();
services.AddTransient <IBookingStatusRefreshService, BookingStatusRefreshService>();
services.AddTransient <IApiClientManagementService, ApiClientManagementService>();
services.AddTransient <IAccommodationMapperClient, AccommodationMapperClient>();
services.AddTransient <IMapperManagementClient, MapperManagementClient>();
services.AddTransient <IAvailabilitySearchAreaService, AvailabilitySearchAreaService>();
services.AddTransient <IAdminAgencyManagementService, AdminAgencyManagementService>();
services.AddTransient <IAgencyManagementService, AgencyManagementService>();
services.AddTransient <IChildAgencyService, ChildAgencyService>();
services.AddTransient <IAgencyService, AgencyService>();
services.AddTransient <IAgencyRemovalService, AgencyRemovalService>();
services.AddTransient <IAgentRemovalService, AgentRemovalService>();
services.AddTransient <IApiClientService, ApiClientService>();
services.AddTransient <IReportService, ReportService>();
services.AddTransient <IAdministratorRolesAssignmentService, AdministratorRolesAssignmentService>();
services.AddTransient <IConverter <AgencyWiseRecordData, AgencyWiseReportRow>, AgencyWiseRecordDataConverter>();
services.AddTransient <IConverter <PayableToSupplierRecordData, PayableToSupplierReportRow>, PayableToSupplierRecordDataConverter>();
services.AddTransient <IConverter <FullBookingsReportData, FullBookingsReportRow>, FullBookingsReportDataConverter>();
services.AddTransient <IConverter <FinalizedBookingsReportData, FinalizedBookingsReportRow>, FinalizedBookingsReportDataConverter>();
services.AddTransient <IConverter <HotelWiseData, HotelWiseRow>, HotelWiseBookingReportDataConverter>();
services.AddTransient <IRecordManager <AgencyWiseRecordData>, AgencyWiseRecordManager>();
services.AddTransient <IRecordManager <PayableToSupplierRecordData>, PayableToSupplierRecordsManager>();
services.AddTransient <IRecordManager <FullBookingsReportData>, FullBookingsRecordManager>();
services.AddTransient <IRecordManager <FinalizedBookingsReportData>, FinalizedBookingsRecordManager>();
services.AddTransient <IConverter <AgencyWiseRecordData, AgencyWiseReportRow>, AgencyWiseRecordDataConverter>();
services.AddTransient <IConverter <PayableToSupplierRecordData, PayableToSupplierReportRow>, PayableToSupplierRecordDataConverter>();
services.AddTransient <IConverter <FullBookingsReportData, FullBookingsReportRow>, FullBookingsReportDataConverter>();
services.AddTransient <IConverter <PendingSupplierReferenceData, PendingSupplierReferenceRow>, PendingSupplierReferenceProjectionConverter>();
services.AddTransient <IConverter <ConfirmedBookingsData, ConfirmedBookingsRow>, ConfirmedBookingsConverter>();
services.AddTransient <IConverter <VccBookingData, VccBookingRow>, VccBookingDataConverter>();
services.AddTransient <IConverter <AgentWiseReportData, AgentWiseReportRow>, AgentWiseRecordDataConverter>();
services.AddTransient <IRecordManager <AgencyWiseRecordData>, AgencyWiseRecordManager>();
services.AddTransient <IRecordManager <PayableToSupplierRecordData>, PayableToSupplierRecordsManager>();
services.AddTransient <IRecordManager <FullBookingsReportData>, FullBookingsRecordManager>();
services.AddTransient <IRecordManager <PendingSupplierReferenceData>, PendingSupplierReferenceRecordManager>();
services.AddTransient <IRecordManager <ConfirmedBookingsData>, ConfirmedBookingsRecordManager>();
services.AddTransient <IRecordManager <AgencyProductivity>, AgenciesProductivityRecordManager>();
services.AddTransient <IRecordManager <HotelWiseData>, HotelWiseRecordManager>();
services.AddTransient <IRecordManager <CancellationDeadlineData>, CancellationDeadlineReportManager>();
services.AddTransient <IRecordManager <ThirdPartySupplierData>, ThirdPartySuppliersReportManager>();
services.AddTransient <IRecordManager <VccBookingData>, VccBookingRecordManager>();
services.AddTransient <IRecordManager <AgentWiseReportData>, AgentWiseRecordManager>();
services.AddTransient <IRecordManager <HotelProductivityData>, HotelProductivityRecordManager>();
services.AddTransient <IRecordManager <CancelledBookingsReportData>, CancelledBookingsReportRecordManager>();
services.AddTransient <IFixHtIdService, FixHtIdService>();
services.AddTransient <IBookingConfirmationService, BookingConfirmationService>();
services.AddTransient <IPropertyOwnerConfirmationUrlGenerator, PropertyOwnerConfirmationUrlGenerator>();
services.AddTransient <INGeniusClient, NGeniusClient>();
services.AddTransient <INGeniusPaymentService, NGeniusPaymentService>();
services.AddTransient <NGeniusWebhookProcessingService>();
services.AddTransient <INGeniusRefundService, NGeniusRefundService>();
services.AddTransient <ICreditCardPaymentManagementService, CreditCardPaymentManagementService>();
services.AddTransient <IBalanceNotificationsManagementService, BalanceNotificationsManagementService>();
services.AddTransient <IBalanceManagementNotificationsService, BalanceManagementNotificationsService>();
services.AddHostedService <MarkupPolicyStorageUpdater>();
services.AddHostedService <DiscountStorageUpdater>();
services.AddSingleton <IMarkupPolicyStorage, MarkupPolicyStorage>();
services.AddSingleton <IDiscountStorage, DiscountStorage>();
services.AddTransient <ILocalityInfoService, LocalityInfoService>();
services.AddTransient <IDirectApiClientManagementService, DirectApiClientManagementService>();
services.AddTransient <IAvailabilityRequestStorage, AvailabilityRequestStorage>();
services.AddCreditCardProvider(configuration, vaultClient);
//TODO: move to Consul when it will be ready
services.AddCurrencyConversionFactory(new List <BufferPair>
{
new()
{
BufferValue = decimal.Zero,
SourceCurrency = Currencies.AED,
TargetCurrency = Currencies.USD
},
new()
{
BufferValue = decimal.Zero,
SourceCurrency = Currencies.USD,
TargetCurrency = Currencies.AED
}
});
