public void AddSqlDbStoredProcedureMonitor2_Ok(bool isCritical)
{
// ARRANGE
var options = new MonitoringOptions();
var serviceProvider = Substitute.For <IServiceProvider>();
var logger = Substitute.For <ILogger <SqlDbStoredProcedureMonitor> >();
serviceProvider.GetService(typeof(ILogger <SqlDbStoredProcedureMonitor>)).Returns(logger);
// ACT
options.AddSqlDbStoredProcedureMonitor("Application Name=Bar;Data Source=dev-db;Initial Catalog=db_name;UID=baz_user;PWD=123456", "schema", "storedProcedureName", isCritical: isCritical);
// ASSERT
var factories = options.Factories.ToList();
Assert.Single(factories);
var factory = factories.Single();
var monitor = factory(options, serviceProvider);
Assert.IsType <SqlDbStoredProcedureMonitor>(monitor);
var sqlMonitor = (SqlDbStoredProcedureMonitor)monitor;
Assert.Equal("db_name.schema", sqlMonitor.ResourceName);
Assert.Equal(options, sqlMonitor.Configuration);
Assert.Equal(isCritical, sqlMonitor.IsCritical);
}
/// <summary>
/// Adds monitoring of ActiveMQ
/// </summary>
/// <param name="options">The options.</param>
/// <param name="configFactory">Function that produce configuration for monitoring connection <seealso cref="IActiveMqMonitoringConfig"/></param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <exception cref="ArgumentNullException"></exception>
public static void AddActiveMqMonitor(this MonitoringOptions options,
Func <IResourceMonitorConfiguration, IServiceProvider, IActiveMqMonitoringConfig> configFactory,
string resourceName = null,
bool isCritical = true)
{
options.AddResourceMonitor((configuration, provider) =>
{
var config = configFactory(configuration, provider);
if (config.Uri == null)
{
throw new ArgumentNullException(nameof(config.Uri));
}
if (config.QueueName == null)
{
throw new ArgumentNullException(nameof(config.QueueName));
}
var connectionFactory = new ConnectionFactory()
{
BrokerUri = config.Uri,
UserName = config.User,
Password = config.Password
};
return(new ActiveMqPingMonitor(resourceName, connectionFactory, config.QueueName, configuration, provider.GetRequiredService <ILogger <ActiveMqPingMonitor> >(), isCritical));
});
}
public void should_monitor_latest_season_if_some_episodes_have_aired()
{
_series.Seasons = Builder <Season> .CreateListOfSize(2)
.All()
.With(n => n.Monitored = true)
.Build()
.ToList();
_episodes = Builder <Episode> .CreateListOfSize(5)
.All()
.With(e => e.SeasonNumber = 1)
.With(e => e.EpisodeFileId = 0)
.With(e => e.AirDateUtc = DateTime.UtcNow.AddDays(-100))
.TheLast(2)
.With(e => e.SeasonNumber = 2)
.TheLast(1)
.With(e => e.AirDateUtc = DateTime.UtcNow.AddDays(100))
.Build()
.ToList();
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.LatestSeason
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifySeasonMonitored(n => n.SeasonNumber == 2);
VerifyMonitored(n => n.SeasonNumber == 2);
VerifySeasonNotMonitored(n => n.SeasonNumber == 1);
VerifyNotMonitored(n => n.SeasonNumber == 1);
}
private void Btn_AddToMonitor_Click(object sender, EventArgs e)
{
var websites = new List <ScraperBase>();
foreach (var website in Clbx_Websites.CheckedItems)
{
websites.Add((ScraperBase)website);
}
var monOptions = new MonitoringOptions()
{
WebHooks = new List <WebHook>(),
Filter = (SearchSettingsBase)PGrid_Bot.SelectedObject,
};
AppSettings.Default.WebHooks.ForEach(hook => monOptions.WebHooks.Add(hook));
if (!string.IsNullOrWhiteSpace(Tbx_CustomWebHook.Text))
{
monOptions.WebHooks.Add(new WebHook()
{
WebHookUrl = Tbx_CustomWebHook.Text
});
}
var taskGroup = new SearchMonitoringTaskGroup()
{
Name = Tbx_TaskName.Text,
Options = monOptions,
WebsiteList = websites,
};
Session.Current.TaskManager.AddSearchTaskGroup(taskGroup);
}
public void should_not_monitor_season_when_all_episodes_are_monitored_except_latest_season()
{
_series.Seasons = Builder <Season> .CreateListOfSize(2)
.All()
.With(n => n.Monitored = true)
.Build()
.ToList();
_episodes = Builder <Episode> .CreateListOfSize(5)
.All()
.With(e => e.SeasonNumber = 1)
.With(e => e.EpisodeFileId = 0)
.With(e => e.AirDateUtc = DateTime.UtcNow.AddDays(-5))
.TheLast(1)
.With(e => e.SeasonNumber = 2)
.Build()
.ToList();
Mocker.GetMock <IEpisodeService>()
.Setup(s => s.GetEpisodeBySeries(It.IsAny <int>()))
.Returns(_episodes);
var monitoringOptions = new MonitoringOptions
{
IgnoreEpisodesWithoutFiles = true
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifySeasonMonitored(n => n.SeasonNumber == 2);
VerifySeasonNotMonitored(n => n.SeasonNumber == 1);
}
/// <summary>
/// Adds the monitoring services
/// </summary>
/// <remarks>
/// The Assembly parameter is not needed when targeting netstandard1.5
/// When this package targets 1.5, we can delete this argument and call Assembly.GetEntryAssembly() instead
/// </remarks>
/// <param name="services">The services.</param>
/// <param name="entryAssembly">Reference to the Entry Assembly (to take version from)</param>
/// <param name="optionsAction">The options action.</param>
/// <returns></returns>
public static IServiceCollection AddMonitoring(
this IServiceCollection services,
Assembly entryAssembly,
Action <MonitoringOptions> optionsAction = null)
{
services.AddSingleton <IShutdownStatusProvider>(new ShutdownStatusProvider());
var options = new MonitoringOptions();
optionsAction?.Invoke(options);
return(services
.AddSingleton <IVersionService, VersionService>(
provider => new VersionService(provider.GetRequiredService <IHostingEnvironment>(), entryAssembly))
.AddSingleton <IResourceMonitorConfiguration>(options)
.AddSingleton <IResourceStateCollector>(p =>
{
var resourceMonitors = options
.Factories
.Select(f => f(options, p))
.Concat(p.GetServices <IResourceMonitor>());
var logger = p.GetRequiredService <ILogger <ResourceStateCollector> >();
return new ResourceStateCollector(resourceMonitors, options.MaxStatePerResource, logger);
}));
}
public void AddSqlDbStoredProcedureMonitor_Ok(bool isCritical)
{
// ARRANGE
var options = new MonitoringOptions();
var dbConnectionProvider = Substitute.For <IDbConnectionProvider>();
var configuration = Substitute.For <IResourceMonitorConfiguration>();
var serviceProvider = Substitute.For <IServiceProvider>();
var logger = Substitute.For <ILogger <SqlDbStoredProcedureMonitor> >();
serviceProvider.GetService(typeof(ILogger <SqlDbStoredProcedureMonitor>)).Returns(logger);
// ACT
options.AddSqlDbStoredProcedureMonitor(dbConnectionProvider, "schema", "storedProcedureName", "resource", isCritical, configuration);
// ASSERT
var factories = options.Factories.ToList();
Assert.Single(factories);
var factory = factories.Single();
var monitor = factory(configuration, serviceProvider);
Assert.IsType <SqlDbStoredProcedureMonitor>(monitor);
var sqlMonitor = (SqlDbStoredProcedureMonitor)monitor;
Assert.Equal("resource", sqlMonitor.ResourceName);
Assert.Equal(configuration, sqlMonitor.Configuration);
Assert.Equal(isCritical, sqlMonitor.IsCritical);
}
public MonitoringSender(
IOptions <MonitoringOptions> monitoringOptions,
IEnumerable <IDestination> destinations)
{
_monitoringOptions = monitoringOptions.Value;
_destinations = destinations;
}
public static IServiceCollection RegisterMonitoring <Monitoring>(this IServiceCollection services, IConfiguration configuration, IEnumerable <IDestination> newDestinations, string environmentName)
where Monitoring : class
{
var section = configuration.GetSection("MonitoringOptions");
var monitoringOptions = new MonitoringOptions();
section.Bind(monitoringOptions);
var monitoringIOptions = Options.Create(monitoringOptions);
services.Configure <MonitoringOptions>(section);
var commonSet = new CommonMonitoringSet(environmentName);
services.AddSingleton(commonSet);
services.AddSingleton <Monitoring>();
services.AddSingleton <IMonitoringSender, MonitoringSender>();
var destinations = new List <IDestination>(newDestinations);
var jsonNLogDestination = new JsonNLogDestination(commonSet, monitoringIOptions);
destinations.Add(jsonNLogDestination);
services.AddSingleton <IEnumerable <IDestination> >(destinations);
var groups = new ConcurrentDictionary <(string, string), IStatisticsMonitoringItem>();
services.AddSingleton <IDictionary <(string, string), IStatisticsMonitoringItem> >(groups);
var statItems = typeof(Monitoring).GetProperties()
.Where(p => typeof(IStatisticsMonitoringItem).IsAssignableFrom(p.PropertyType))
.Select(x =>
{
var item = (IStatisticsMonitoringItem)Activator.CreateInstance(x.PropertyType);
item.Name = x.PropertyType.Name;
item.SetProperties();
return(item);
}
)
.Select(x => new KeyValuePair <string, IStatisticsMonitoringItem>(x.Name, x));
var itemsDictionary = new ConcurrentDictionary <string, IStatisticsMonitoringItem>(statItems);
foreach (var item in itemsDictionary)
{
services.AddSingleton(item.Value.GetType(), item.Value);
}
services.AddSingleton <IDictionary <string, IStatisticsMonitoringItem> >(itemsDictionary);
var set = new StatisticsItemsFullSet(itemsDictionary, groups);
services.AddSingleton(set);
var statisticsSender = new StatisticsSender(monitoringIOptions, destinations, set);
services.AddSingleton <IStatisticsSender>(statisticsSender);
return(services);
}
public CertExpirationNotifyService(
IConfiguration config,
CertExpirationChecker expirationChecker,
EmailService emailService)
{
options = new MonitoringOptions();
config.Bind("SslMonitoring", options);
this.expirationChecker = expirationChecker;
this.emailService = emailService;
}
public void should_be_able_to_monitor_no_episodes()
{
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.None
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
Mocker.GetMock <IEpisodeService>()
.Verify(v => v.UpdateEpisodes(It.Is <List <Episode> >(l => l.All(e => !e.Monitored))));
}
public void should_be_able_to_monitor_missing_episodes_only()
{
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.Missing
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifyMonitored(e => !e.HasFile);
VerifyNotMonitored(e => e.HasFile);
}
/// <summary>
/// Adds the sql database monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="dbConnectionString">Database connection string</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddSqlDbMonitor(
this MonitoringOptions options,
string dbConnectionString,
string resourceName = null,
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddSqlDbMonitor(
new DbConnectionProvider(dbConnectionString),
resourceName,
isCritical,
configOverride);
}
public void should_be_able_to_monitor_new_episodes_only()
{
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.Future
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifyMonitored(e => e.AirDateUtc.HasValue && e.AirDateUtc.Value.After(DateTime.UtcNow));
VerifyMonitored(e => !e.AirDateUtc.HasValue);
VerifyNotMonitored(e => e.AirDateUtc.HasValue && e.AirDateUtc.Value.Before(DateTime.UtcNow));
}
public void should_be_able_to_monitor_new_albums_only()
{
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.Future
};
Subject.SetBookMonitoredStatus(_artist, monitoringOptions);
VerifyMonitored(e => e.ReleaseDate.HasValue && e.ReleaseDate.Value.After(DateTime.UtcNow));
VerifyMonitored(e => !e.ReleaseDate.HasValue);
VerifyNotMonitored(e => e.ReleaseDate.HasValue && e.ReleaseDate.Value.Before(DateTime.UtcNow));
}
public void should_be_able_to_monitor_missing_episodes_only()
{
var monitoringOptions = new MonitoringOptions
{
IgnoreEpisodesWithFiles = true,
IgnoreEpisodesWithoutFiles = false
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifyMonitored(e => !e.HasFile);
VerifyNotMonitored(e => e.HasFile);
}
public void should_not_monitor_new_specials()
{
GivenSpecials();
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.Future
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifyNotMonitored(e => e.SeasonNumber == 0);
}
public void should_not_monitor_new_specials()
{
GivenSpecials();
var monitoringOptions = new MonitoringOptions
{
IgnoreEpisodesWithFiles = true,
IgnoreEpisodesWithoutFiles = true
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
VerifyNotMonitored(e => e.SeasonNumber == 0);
}
public void should_not_monitor_latest_season_if_all_episodes_aired_more_than_90_days_ago()
{
_episodes.ForEach(e => e.AirDateUtc = DateTime.UtcNow.AddDays(-100));
var monitoringOptions = new MonitoringOptions
{
Monitor = MonitorTypes.LatestSeason
};
Subject.SetEpisodeMonitoredStatus(_series, monitoringOptions);
Mocker.GetMock <IEpisodeService>()
.Verify(v => v.UpdateEpisodes(It.Is <List <Episode> >(l => l.All(e => !e.Monitored))));
}
/// <summary>
/// Initialise le monitoring de la Web API.
/// </summary>
/// <param name="configuration">La collection des clés de configuration.</param>
private static IFrameworkTracer InitMonitoring(IConfiguration configuration)
{
MonitoringOptions options = configuration.GetSection(nameof(MonitoringOptions)).Get <MonitoringOptions>();
if (string.IsNullOrEmpty(options.TraceSourceName))
{
throw new ApplicationConfigurationException(ErrorCodes.Application.InvalidConfiguration, string.Format(CultureInfo.CurrentCulture, InternalMessages.ApplicationConfigurationMissingSetting, nameof(options.TraceSourceName)));
}
var tracer = DotNetTracerFactory.Instance.CreateTracer(TraceSourceType.Web, options.TraceSourceName);
// Interception de l'ensemble des exceptions
tracer.SetExceptionHandling(options.LogFirstChanceExceptions);
return(tracer);
}
public StatisticsSender(
IOptions <MonitoringOptions> monitoringOptions,
IEnumerable <IDestination> destinations,
StatisticsItemsFullSet statisticItems)
{
_destinations = destinations;
_monitoringOptions = monitoringOptions.Value;
_fullSet = statisticItems;
if (_monitoringOptions.RunImmediately)
{
StartMonitoring();
}
}
/// <summary>
/// Adds the SQL database stored procedure monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="dbConnectionString">Database connection string.</param>
/// <param name="schema">DB schema monitored.</param>
/// <param name="storedProcedureName">Healthcheck stored procedure name (without schema).</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddSqlDbStoredProcedureMonitor(
this MonitoringOptions options,
string dbConnectionString,
string schema,
string storedProcedureName,
string resourceName = null,
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddSqlDbStoredProcedureMonitor(
new DbConnectionProvider(dbConnectionString),
schema,
storedProcedureName,
resourceName ?? DbSchemaResourceName(dbConnectionString, schema),
isCritical,
configOverride);
}
/// <summary>
/// Adds the Shutdown monitor.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="resourceName">Name of the resource. Defaults to: Uri.AbsoluteUri.</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddShutdownMonitor(
this MonitoringOptions options,
string resourceName = null,
IResourceMonitorConfiguration configOverride = null)
{
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <ShutdownMonitor> >();
return(new ShutdownMonitor(
resourceName ?? "shutdown",
provider.GetRequiredService <IShutdownStatusProvider>(),
configOverride ?? conf,
logger
));
});
}
/// <summary>
/// Adds monitoring of ActiveMQ
/// </summary>
/// <param name="options">The options.</param>
/// <param name="url">Url used to connect to ActiveMQ</param>
/// <param name="queueName">Queue name where to put ping messages</param>
/// <param name="username">User used to connect to ActiveMQ</param>
/// <param name="password">Password used to connect to ActiveMQ</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <exception cref="ArgumentNullException"></exception>
public static void AddActiveMqMonitor(this MonitoringOptions options,
string url, string queueName, string username, string password,
string resourceName = null,
bool isCritical = false)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
options.AddResourceMonitor(
(configuration, provider) => new ActiveMqPingMonitor(resourceName, new ConnectionFactory()
{
BrokerUri = new Uri(url),
UserName = username,
Password = password
}, queueName, configuration, provider.GetRequiredService <ILogger <ActiveMqPingMonitor> >(), isCritical));
}
/// <summary>
/// Adds the sql database monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="dbProvider">Database provider</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddSqlDbMonitor(
this MonitoringOptions options,
IDbConnectionProvider dbProvider,
string resourceName = null,
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <SqlDbPingMonitor> >();
return(new SqlDbPingMonitor(
dbProvider,
logger,
configOverride ?? conf,
resourceName ?? "SQL Database",
isCritical));
});
}
/// <summary>
/// Adds the HTTP monitor.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="healthCheckEndpoint">The health check endpoint.</param>
/// <param name="resourceName">Name of the resource. Defaults to: Uri.AbsoluteUri.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddHttpMonitor(
this MonitoringOptions options,
Uri healthCheckEndpoint,
string resourceName = null,
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
resourceName = resourceName ?? healthCheckEndpoint.AbsoluteUri; // Defaults to the AbsoluteUri of the Health Check Endpoint
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <HttpResourceMonitor> >();
return(new HttpResourceMonitor(
resourceName,
healthCheckEndpoint,
new HttpClient(),
configOverride ?? conf,
logger,
isCritical));
});
}
/// <summary>
/// Adds the SQL database stored procedure monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="dbConnectionProvider">Database connection provider.</param>
/// <param name="schema">DB schema monitored.</param>
/// <param name="storedProcedureName">Healthcheck stored procedure name (without schema).</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddSqlDbStoredProcedureMonitor(
this MonitoringOptions options,
IDbConnectionProvider dbConnectionProvider,
string schema,
string storedProcedureName,
string resourceName,
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <SqlDbStoredProcedureMonitor> >();
return(new SqlDbStoredProcedureMonitor(
dbConnectionProvider,
schema,
storedProcedureName,
logger,
configOverride ?? conf,
resourceName,
isCritical));
});
}
/// <summary>
/// Adds the redis monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="multiplexer">The multiplexer.</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddRedisMonitor(
this MonitoringOptions options,
IConnectionMultiplexer multiplexer = null,
string resourceName = "Redis",
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <RedisPingMonitor> >();
multiplexer = multiplexer ?? provider.GetService <IConnectionMultiplexer>();
if (multiplexer == null)
{
throw new InvalidOperationException("A multiplexer is required either as an argument or from the Container.");
}
return(new RedisPingMonitor(
isCritical,
multiplexer,
logger,
configOverride ?? conf,
resourceName));
});
}
/// <summary>
/// Adds the MongoDB monitor to MonitoringOptions
/// </summary>
/// <param name="options">The options.</param>
/// <param name="mongo">The MongoDB.</param>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="isCritical">if set to <c>true</c> [is critical].</param>
/// <param name="configOverride">The configuration override.</param>
public static void AddMongoDbMonitor(
this MonitoringOptions options,
IMongoDatabase mongo = null,
string resourceName = "MongoDB",
bool isCritical = true,
IResourceMonitorConfiguration configOverride = null)
{
options.AddResourceMonitor((conf, provider) =>
{
var logger = provider.GetRequiredService <ILogger <MongoDbPingMonitor> >();
mongo = mongo ?? provider.GetService <IMongoDatabase>();
if (mongo == null)
{
throw new InvalidOperationException("A MongoDB instance is required either as an argument or from the Container.");
}
return(new MongoDbPingMonitor(
mongo,
logger,
configOverride ?? conf,
resourceName,
isCritical));
});
}
public void ConfigureCommonServices(IServiceCollection services)
{
services.AddLocalization(options => options.ResourcesPath = "Localization");
services.AddMvc(o =>
{
o.Filters.Add(typeof(DetectMobileFilter));
o.OutputFormatters.RemoveType <JsonOutputFormatter>();
o.OutputFormatters.Add(new JsonHalOutputFormatter(new string[] { "application/hal+json", "application/vnd.example.hal+json", "application/vnd.example.hal.v1+json" }));
}).AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix, options => options.ResourcesPath = "Localization").AddDataAnnotationsLocalization();
services.AddAuthorization(options =>
{
options.AddPolicy("AdministratorAccessLevelPolicy", policy => policy.RequireClaim("AccessLevel", "Administrator"));
});
services.AddTransient <ApplicationUserManager>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IGameInvitationService, GameInvitationService>();
services.AddScoped <IGameSessionService, GameSessionService>();
var connectionString = _configuration.GetConnectionString("DefaultConnection");
services.AddEntityFrameworkSqlServer()
.AddDbContext <GameDbContext>((serviceProvider, options) =>
options.UseSqlServer(connectionString)
.UseInternalServiceProvider(serviceProvider)
);
services.AddScoped(typeof(DbContextOptions <GameDbContext>), (serviceProvider) =>
{
return(new DbContextOptionsBuilder <GameDbContext>()
.UseSqlServer(connectionString).Options);
});
services.Configure <EmailServiceOptions>(_configuration.GetSection("Email"));
services.AddEmailService(_hostingEnvironment, _configuration);
services.AddTransient <IEmailTemplateRenderService, EmailTemplateRenderService>();
services.AddTransient <EmailViewEngine, EmailViewEngine>();
services.AddRouting();
services.AddSession(o =>
{
o.IdleTimeout = TimeSpan.FromMinutes(30);
});
services.AddIdentity <UserModel, RoleModel>(options =>
{
options.Password.RequiredLength = 1;
options.Password.RequiredUniqueChars = 0;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.SignIn.RequireConfirmedEmail = false;
}).AddEntityFrameworkStores <GameDbContext>()
.AddDefaultTokenProviders();
services.AddAuthentication(options => {
options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
}).AddCookie().AddFacebook(facebook =>
{
facebook.AppId = "123";
facebook.AppSecret = "123";
facebook.ClientId = "123";
facebook.ClientSecret = "123";
});
services.AddApplicationInsightsTelemetry(_configuration);
var section = _configuration.GetSection("Monitoring");
var monitoringOptions = new MonitoringOptions();
section.Bind(monitoringOptions);
services.AddSingleton(monitoringOptions);
if (monitoringOptions.MonitoringType == "azureapplicationinsights")
{
services.AddSingleton <IMonitoringService, AzureApplicationInsightsMonitoringService>();
}
else if (monitoringOptions.MonitoringType == "amazonwebservicescloudwatch")
{
services.AddSingleton <IMonitoringService, AmazonWebServicesMonitoringService>();
}
}
