public ShellViewModel(IMenuService menuService
, IAppConfiguration appConfiguration
, IUserSettingsService settings)
: base()
{
this.PageLoadingCommand = DelegateCommand.FromAsyncHandler(PageLoading);
this.UserSettingsService = settings;
this.AppName = appConfiguration.AppName;
this.WriteReadyStatus();
this.ToggleFullScreenCommand = new DelegateCommand<object>(o =>
{
if (o is IToggleFullScreen)
{
var tfs = o as IToggleFullScreen;
tfs.ToggleFullScreen = !tfs.ToggleFullScreen;
}
this.ToggleFullScreen = !this.ToggleFullScreen;
});
Menu = menuService.Menu.ToObservableCollection();
EventAggregator.GetEvent<MenuUpdated>().Subscribe(m =>
{
Menu.Clear();
Menu.AddRange(m.ToObservableCollection());
});
EventAggregator.GetEvent<SubMenuVisibilityChanged>().Subscribe(m => this.IsSubMenuVisible = m);
}
public MessageService(IMailSender mailSender, IAppConfiguration config, AuthenticationService authService)
: this()
{
MailSender = mailSender;
Config = config;
AuthService = authService;
}
public PackagesController(
IPackageService packageService,
IUploadFileService uploadFileService,
IMessageService messageService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratedPackageCmd,
IPackageFileService packageFileService,
IEntitiesContext entitiesContext,
IAppConfiguration config,
IIndexingService indexingService,
ICacheService cacheService,
EditPackageService editPackageService,
IPackageDeleteService packageDeleteService,
ISupportRequestService supportRequestService,
AuditingService auditingService)
{
_packageService = packageService;
_uploadFileService = uploadFileService;
_messageService = messageService;
_searchService = searchService;
_autoCuratedPackageCmd = autoCuratedPackageCmd;
_packageFileService = packageFileService;
_entitiesContext = entitiesContext;
_config = config;
_indexingService = indexingService;
_cacheService = cacheService;
_editPackageService = editPackageService;
_packageDeleteService = packageDeleteService;
_supportRequestService = supportRequestService;
_auditingService = auditingService;
}
public UserService(
IAppConfiguration config,
IEntityRepository<User> userRepository) : this()
{
Config = config;
UserRepository = userRepository;
}
private static void InitializeDynamicData(RouteCollection routes, string root, IAppConfiguration configuration)
{
try
{
DefaultModel.RegisterContext(
new EFCodeFirstDataModelProvider(
() => new EntitiesContext(configuration.SqlConnectionString, readOnly: false)), // DB Admins do not need to respect read-only mode.
configuration: new ContextConfiguration { ScaffoldAllTables = true });
}
catch (SqlException e)
{
QuietLog.LogHandledException(e);
return;
}
catch (DataException e)
{
QuietLog.LogHandledException(e);
return;
}
// This route must come first to prevent some other route from the site to take over
_route = new DynamicDataRoute(root + "/{table}/{action}")
{
Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),
Model = DefaultModel
};
routes.Insert(0, _route);
routes.MapPageRoute(
"dd_default",
root,
"~/Areas/Admin/DynamicData/Default.aspx");
}
public ExternalSearchService(IAppConfiguration config, IDiagnosticsService diagnostics)
{
ServiceUri = config.ServiceDiscoveryUri;
Trace = diagnostics.SafeGetSource("ExternalSearchService");
// Extract credentials
var userInfo = ServiceUri.UserInfo;
ICredentials credentials = null;
if (!String.IsNullOrEmpty(userInfo))
{
var split = userInfo.Split(':');
if (split.Length != 2)
{
throw new FormatException("Invalid user info in SearchServiceUri!");
}
// Split the credentials out
credentials = new NetworkCredential(split[0], split[1]);
ServiceUri = new UriBuilder(ServiceUri)
{
UserName = null,
Password = null
}.Uri;
}
if (_healthIndicatorStore == null)
{
_healthIndicatorStore = new BaseUrlHealthIndicatorStore(new AppInsightsHealthIndicatorLogger());
}
_client = new SearchClient(ServiceUri, config.SearchServiceResourceType, credentials, _healthIndicatorStore, new TracingHttpHandler(Trace));
}
public HomeController(
Func<IWeeeClient> apiClient,
IAppConfiguration configuration)
{
this.configuration = configuration;
this.apiClient = apiClient;
}
internal string FillIn(string subject, IAppConfiguration config)
{
// note, format blocks {xxx} are matched by ordinal-case-sensitive comparison
var builder = new StringBuilder(subject);
Substitute(builder, "{GalleryOwnerName}", config.GalleryOwner.DisplayName);
Substitute(builder, "{Id}", Package.PackageRegistration.Id);
Substitute(builder, "{Version}", Package.Version);
Substitute(builder, "{Reason}", Reason);
if (RequestingUser != null)
{
Substitute(builder, "{User}", String.Format(
CultureInfo.CurrentCulture,
"{2}**User:** {0} ({1}){2}{3}",
RequestingUser.Username,
RequestingUser.EmailAddress,
Environment.NewLine,
Url.User(RequestingUser, scheme: "http")));
}
else
{
Substitute(builder, "{User}", "");
}
Substitute(builder, "{Name}", FromAddress.DisplayName);
Substitute(builder, "{Address}", FromAddress.Address);
Substitute(builder, "{AlreadyContactedOwners}", AlreadyContactedOwners ? "Yes" : "No");
Substitute(builder, "{PackageUrl}", Url.Package(Package.PackageRegistration.Id, null, scheme: "http"));
Substitute(builder, "{VersionUrl}", Url.Package(Package.PackageRegistration.Id, Package.Version, scheme: "http"));
Substitute(builder, "{Reason}", Reason);
Substitute(builder, "{Signature}", Signature);
Substitute(builder, "{Message}", Message);
builder.Replace(@"\{\", "{");
return builder.ToString();
}
public PackagesController(
IPackageService packageService,
IUploadFileService uploadFileService,
IUserService userService,
IMessageService messageService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratedPackageCmd,
INuGetExeDownloaderService nugetExeDownloaderService,
IPackageFileService packageFileService,
IEntitiesContext entitiesContext,
IAppConfiguration config,
IIndexingService indexingService,
ICacheService cacheService)
{
_packageService = packageService;
_uploadFileService = uploadFileService;
_userService = userService;
_messageService = messageService;
_searchService = searchService;
_autoCuratedPackageCmd = autoCuratedPackageCmd;
_nugetExeDownloaderService = nugetExeDownloaderService;
_packageFileService = packageFileService;
_entitiesContext = entitiesContext;
_config = config;
_indexingService = indexingService;
_cacheService = cacheService;
}
public ApiController(
IEntitiesContext entitiesContext,
IPackageService packageService,
IPackageFileService packageFileService,
IUserService userService,
INuGetExeDownloaderService nugetExeDownloaderService,
IContentService contentService,
IIndexingService indexingService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratePackage,
IStatusService statusService,
IAppConfiguration config)
{
EntitiesContext = entitiesContext;
PackageService = packageService;
PackageFileService = packageFileService;
UserService = userService;
NugetExeDownloaderService = nugetExeDownloaderService;
ContentService = contentService;
StatisticsService = null;
IndexingService = indexingService;
SearchService = searchService;
AutoCuratePackage = autoCuratePackage;
StatusService = statusService;
_config = config;
}
public static void Register(RouteCollection routes, string root, IAppConfiguration configuration)
{
// Set up unobtrusive validation
InitializeValidation();
// Set up dynamic data
InitializeDynamicData(routes, root, configuration);
}
public SupportRequestService(
ISupportRequestDbContext supportRequestDbContext,
IAppConfiguration config)
{
_supportRequestDbContext = supportRequestDbContext;
_siteRoot = config.SiteRoot;
_pagerDutyClient = new PagerDutyClient(config.PagerDutyAccountName, config.PagerDutyAPIKey, config.PagerDutyServiceKey);
}
public AzureManagement(IMlogger logger, IAppConfiguration configuration, IDataExporter dataExporter)
{
Logger = logger;
Configuration = configuration;
var subscriptionId = configuration.SubscriptionId();
var base64EncodedCertificate = configuration.Base64EncodedManagementCertificate();
MyCloudCredentials = getCredentials(subscriptionId, base64EncodedCertificate);
Exporter = dataExporter;
}
public StatusService(
IEntitiesContext entities,
IFileStorageService fileStorageService,
IAppConfiguration config)
{
_entities = entities;
_fileStorageService = fileStorageService;
_config = config;
}
public ChargeController(
IAppConfiguration configuration,
BreadcrumbService breadcrumb,
Func<IWeeeClient> weeeClient)
{
this.configuration = configuration;
this.breadcrumb = breadcrumb;
this.weeeClient = weeeClient;
}
public AuthenticationService(
IEntitiesContext entities, IAppConfiguration config, IDiagnosticsService diagnostics,
AuditingService auditing, IEnumerable<Authenticator> providers, ICredentialBuilder credentialBuilder,
ICredentialValidator credentialValidator, IDateTimeProvider dateTimeProvider)
{
if (entities == null)
{
throw new ArgumentNullException(nameof(entities));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (diagnostics == null)
{
throw new ArgumentNullException(nameof(diagnostics));
}
if (auditing == null)
{
throw new ArgumentNullException(nameof(auditing));
}
if (providers == null)
{
throw new ArgumentNullException(nameof(providers));
}
if (credentialBuilder == null)
{
throw new ArgumentNullException(nameof(credentialBuilder));
}
if (credentialValidator == null)
{
throw new ArgumentNullException(nameof(credentialValidator));
}
if (dateTimeProvider == null)
{
throw new ArgumentNullException(nameof(dateTimeProvider));
}
InitCredentialFormatters();
Entities = entities;
_config = config;
Auditing = auditing;
_trace = diagnostics.SafeGetSource("AuthenticationService");
Authenticators = providers.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
_credentialBuilder = credentialBuilder;
_credentialValidator = credentialValidator;
_dateTimeProvider = dateTimeProvider;
}
public UsersController(
IUserService userService,
IMessageService messageService,
IAppConfiguration config,
AuthenticationService authService)
{
UserService = userService;
MessageService = messageService;
Config = config;
AuthService = authService;
}
public UserService(
IAppConfiguration config,
IEntityRepository<User> userRepository,
IEntityRepository<Credential> credentialRepository,
AuditingService auditing)
: this()
{
Config = config;
UserRepository = userRepository;
CredentialRepository = credentialRepository;
Auditing = auditing;
}
public UsersController(
ICuratedFeedService feedsQuery,
IUserService userService,
IPackageService packageService,
IMessageService messageService,
IAppConfiguration config,
AuthenticationService authService,
ICredentialBuilder credentialBuilder)
{
if (feedsQuery == null)
{
throw new ArgumentNullException(nameof(feedsQuery));
}
if (userService == null)
{
throw new ArgumentNullException(nameof(userService));
}
if (packageService == null)
{
throw new ArgumentNullException(nameof(packageService));
}
if (messageService == null)
{
throw new ArgumentNullException(nameof(messageService));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (authService == null)
{
throw new ArgumentNullException(nameof(authService));
}
if (credentialBuilder == null)
{
throw new ArgumentNullException(nameof(credentialBuilder));
}
_curatedFeedService = feedsQuery;
_userService = userService;
_packageService = packageService;
_messageService = messageService;
_config = config;
_authService = authService;
_credentialBuilder = credentialBuilder;
}
public UsersController(
ICuratedFeedService feedsQuery,
IUserService userService,
IPackageService packageService,
IMessageService messageService,
IAppConfiguration config) : this()
{
CuratedFeedService = feedsQuery;
UserService = userService;
PackageService = packageService;
MessageService = messageService;
Config = config;
}
public LuceneIndexingService(
IEntityRepository<Package> packageSource,
IEntityRepository<CuratedPackage> curatedPackageSource,
Lucene.Net.Store.Directory directory,
IDiagnosticsService diagnostics,
IAppConfiguration config)
{
_packageRepository = packageSource;
_curatedPackageRepository = curatedPackageSource;
_directory = directory;
_getShouldAutoUpdate = config == null ? new Func<bool>(() => true) : new Func<bool>(() => config.AutoUpdateSearchIndex);
Trace = diagnostics.SafeGetSource("LuceneIndexingService");
}
public ProjectsController(
IProjectService projectService,
IMessageService messageService,
IEntitiesContext entitiesContext,
IAppConfiguration config,
ICacheService cacheService)
{
_projectService = projectService;
_messageService = messageService;
_entitiesContext = entitiesContext;
_config = config;
_cacheService = cacheService;
}
public AuthenticationService(IEntitiesContext entities, IAppConfiguration config, IDiagnosticsService diagnostics, AuditingService auditing, IEnumerable<Authenticator> providers)
{
_credentialFormatters = new Dictionary<string, Func<string, string>>(StringComparer.OrdinalIgnoreCase) {
{ "password", _ => Strings.CredentialType_Password },
{ "apikey", _ => Strings.CredentialType_ApiKey },
{ "external", FormatExternalCredentialType }
};
Entities = entities;
Config = config;
Auditing = auditing;
Trace = diagnostics.SafeGetSource("AuthenticationService");
Authenticators = providers.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
}
public UsersController(
ICuratedFeedService feedsQuery,
IUserService userService,
IPackageService packageService,
IMessageService messageService,
IAppConfiguration config,
AuthenticationService authService)
{
CuratedFeedService = feedsQuery;
UserService = userService;
PackageService = packageService;
MessageService = messageService;
Config = config;
AuthService = authService;
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app, IAppConfiguration config)
{
ReturnUrlMapping returnUrlMapping = new ReturnUrlMapping();
returnUrlMapping.Add("/account/sign-out", null);
returnUrlMapping.Add("/admin/account/sign-out", null);
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationType = Constants.WeeeAuthType,
LoginPath = new PathString("/account/sign-in"),
SlidingExpiration = true,
ExpireTimeSpan = TimeSpan.FromMinutes(60),
CookieName = EA.Prsd.Core.Web.Constants.CookiePrefix + Constants.WeeeAuthType,
Provider = new WeeeCookieAuthenticationProvider(returnUrlMapping)
});
}
public ApiController(
IEntitiesContext entitiesContext,
IPackageService packageService,
IPackageFileService packageFileService,
IUserService userService,
INuGetExeDownloaderService nugetExeDownloaderService,
IContentService contentService,
IIndexingService indexingService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratePackage,
IStatusService statusService,
IStatisticsService statisticsService,
IAppConfiguration config)
: this(entitiesContext, packageService, packageFileService, userService, nugetExeDownloaderService, contentService, indexingService, searchService, autoCuratePackage, statusService, config)
{
StatisticsService = statisticsService;
}
internal string FillIn(string subject, IAppConfiguration config)
{
// note, format blocks {xxx} are matched by ordinal-case-sensitive comparison
var ret = new StringBuilder(subject);
Action<string, string> substitute = (target, value) => ret.Replace(target, Escape(value));
substitute("{GalleryOwnerName}", config.GalleryOwner.DisplayName);
substitute("{Id}", Package.PackageRegistration.Id);
substitute("{Version}", Package.Version);
substitute("{Reason}", Reason);
if (RequestingUser != null)
{
substitute("{Username}", RequestingUser.Username);
substitute("{UserUrl}", Url.User(RequestingUser, scheme: "http"));
if (RequestingUser.EmailAddress != null)
{
substitute("{UserAddress}", RequestingUser.EmailAddress);
}
}
substitute("{Name}", FromAddress.DisplayName);
substitute("{Address}", FromAddress.Address);
substitute("{AlreadyContactedOwners}", AlreadyContactedOwners ? "Yes" : "No");
substitute("{PackageUrl}", Url.Package(Package.PackageRegistration.Id, null, scheme: "http"));
substitute("{VersionUrl}", Url.Package(Package.PackageRegistration.Id, Package.Version, scheme: "http"));
substitute("{Reason}", Reason);
substitute("{Message}", Message);
var ownersText = new StringBuilder("");
foreach (var owner in Package.PackageRegistration.Owners)
{
ownersText.AppendFormat(
CultureInfo.InvariantCulture,
"{0} - {1} - ({2})",
owner.Username,
Url.User(owner, scheme: "http"),
owner.EmailAddress);
ownersText.AppendLine();
}
substitute("{OwnerList}", ownersText.ToString());
ret.Replace(@"\{\", "{");
return ret.ToString();
}
protected override void OnInit(EventArgs e)
{
// Cheap and easy DI. Not too clean :)
Config = NuGetGallery.Container.Kernel.Get<IAppConfiguration>();
if (!Page.User.Identity.IsAuthenticated)
{
Response.StatusCode = (int)HttpStatusCode.Unauthorized;
Response.End();
}
if (!Request.IsLocal && !Page.User.IsAdministrator())
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
Response.End();
}
base.OnInit(e);
}
private static void AppPostStart(IAppConfiguration configuration)
{
WebApiConfig.Register(GlobalConfiguration.Configuration);
NuGetODataConfig.Register(GlobalConfiguration.Configuration);
// Attach correlator
var correlationHandler = new Correlator.Handlers.ClientCorrelationHandler
{
InitializeIfEmpty = true,
TraceCorrelation = true
};
GlobalConfiguration.Configuration.MessageHandlers.Add(correlationHandler);
Routes.RegisterRoutes(RouteTable.Routes, configuration.FeedOnlyMode);
AreaRegistration.RegisterAllAreas();
GlobalFilters.Filters.Add(new SendErrorsToTelemetryAttribute {
View = "~/Views/Errors/InternalError.cshtml"
});
GlobalFilters.Filters.Add(new ReadOnlyModeErrorFilter());
GlobalFilters.Filters.Add(new AntiForgeryErrorFilter());
ValueProviderFactories.Factories.Add(new HttpHeaderValueProviderFactory());
}
private ExportViewModel(Authentication authentication, IDataBase dataBase, string[] selectedPaths)
: base(Resources.Title_Export)
{
this.authentication = authentication;
this.dataBase = dataBase;
this.dataBase.Dispatcher.VerifyAccess();
this.exportService = dataBase.GetService(typeof(IExportService)) as IExportService;
this.configService = dataBase.GetService(typeof(IAppConfiguration)) as IAppConfiguration;
this.root = new TableRootTreeViewItemViewModel(authentication, this.dataBase, this)
{
IsExpanded = true,
};
this.categories = new ObservableCollection <ExportTreeViewItemViewModel>
{
this.root
};
this.SelectItems(this.root, selectedPaths);
this.exporters = new ObservableCollection <IExporter>(this.exportService.Exporters);
this.SelectedExporter = this.exporters.FirstOrDefault(item => item.Name == (string)this.configService[this.GetType(), nameof(SelectedExporter)]);
this.configService?.Update(this);
}
public SqlAggregateStatsService(IAppConfiguration configuration)
{
this.configuration = configuration;
}
public WkHtmlToImage(IAppConfiguration appConfiguration)
{
_appConfiguration = appConfiguration;
}
public ConfigController(IAppConfiguration config)
{
_config = config;
}
public RecorderApi(IAppConfiguration appConfiguration)
{
client = new HttpClient();
this.appConfiguration = appConfiguration;
}
public HomeController(IIdentityServerInteractionService interaction, IAppConfiguration appConfiguration, IClientManagementStore clientStore)
{
_interaction = interaction;
_appConfiguration = appConfiguration;
_clientManagementStore = clientStore;
}
public UserProfileRepository(IAppConfiguration config, IUserRoleMapper userRoleMapper)
{
_config = config;
_userRoleMapper = userRoleMapper;
}
public TestBootstrapper(IAppConfiguration appConfig, ILogger logger, ClaimsPrincipal claimsPrincipal)
: base(appConfig, logger)
{
_claimsPrincipal = claimsPrincipal;
}
/// <summary>
/// </summary>
/// <param name="configuration"></param>
/// <param name="descriptors"></param>
/// <returns></returns>
public static IIocAppConfiguration UseCastleWindsorForAspNetCore(this IAppConfiguration configuration,
IEnumerable <ServiceDescriptor> descriptors)
{
return(configuration.UseCastleWindsor(false).Register(descriptors));
}
/// <summary>
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public static IIocAppConfiguration UseCastleWindsorForAspNet(this IAppConfiguration configuration)
{
return(configuration.UseCastleWindsor(true));
}
public BaseLogRepository(ILog log, IAppConfiguration config)
{
this.log = log;
this.config = config;
}
/// <summary>
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public static IIocAppConfiguration UseCastleWindsor(this IAppConfiguration configuration)
{
return(configuration.UseCastleWindsor(false));
}
public MessageService(IMailSender mailSender, IAppConfiguration config)
: base(mailSender, config)
{
}
public NewsController(IAppConfiguration configurations)
: base("NewsController.", configurations)
{
}
public virtual IServiceProvider RegisterDependencies(IServiceCollection services, IConfigurationRoot configuration, IAppConfiguration config)
{
var containerBuilder = new ContainerBuilder();
//register engine
containerBuilder.RegisterInstance(this).As <IEngine>().SingleInstance();
//register assembly finder
var assemblyHelper = new AssemblyHelper();
containerBuilder.RegisterInstance(assemblyHelper).As <IAssemblyHelper>().SingleInstance();
//find dependency registrars provided by other assemblies
var dependencyRegistrars = assemblyHelper.FindOfType <IDependencyRegistrar>();
//create and sort instances of dependency registrars
var instances = dependencyRegistrars
.Select(dependencyRegistrar => (IDependencyRegistrar)Activator.CreateInstance(dependencyRegistrar))
.OrderBy(dependencyRegistrar => dependencyRegistrar.Priority);
var dependencyConfig = new DependencyContext
{
ContainerBuilder = containerBuilder,
AssemblyHelper = assemblyHelper,
ConfigurationRoot = configuration,
AppConfig = config
};
//register all provided dependencies
foreach (var dependencyRegistrar in instances)
{
dependencyRegistrar.Register(dependencyConfig);
}
//populate Autofac container builder with the set of registered service descriptors
containerBuilder.Populate(services);
//create service provider
_serviceProvider = new AutofacServiceProvider(containerBuilder.Build());
var startupTasks = assemblyHelper.FindOfType <IStartupTask>();
var taskInstances = startupTasks
.Select(task => (IStartupTask)Activator.CreateInstance(task))
.OrderBy(task => task.Priority);
foreach (var task in taskInstances)
{
task.Execute();
}
return(_serviceProvider);
}
public DemoBootstrapper(IAppConfiguration appConfig)
{
this.appConfig = appConfig;
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_rTSSService = rTSSService;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.SecondMetricOverlay;
ThirdMetric = _appConfiguration.ThirdMetricOverlay;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
IsOverlayActiveStream.AsObservable()
.Select(isActive =>
{
if (isActive)
{
TryCloseRTSS();
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.ResetOSD();
return(sensorService.OnDictionaryUpdated
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
// OSD status logging
Task.Run(async() =>
{
var processId = await _rTSSService.ProcessIdStream.Take(1);
try
{
_logger.LogInformation("Is process {detectedProcess} detected: {isDetected}", processId, _rTSSService.IsProcessDetected(processId));
}
catch
{
_logger.LogError("Error while checking RTSS core process detection");
}
//try
//{
// _logger.LogInformation("Is OS locked: {isLocked}", _rTSSService.IsOSDLocked());
//}
//catch
//{
// _logger.LogError("Error while checking RTSS core OSD lock status");
//}
}).Wait();
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
}).Switch()
.SubscribeOn(Scheduler.Default)
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public FilterConfigTests()
{
configuration = A.Fake <IAppConfiguration>();
config = new FilterConfig(configuration);
}
public Bootstrapper(IAppConfiguration config, IServiceCollection services)
{
this.services = services;
this.config = config;
}
public SendEmailHandler(IAppConfiguration appConfiguration)
{
_appConfiguration = appConfiguration.GetAppConfiguration();
}
public LogTypeRepository(ILog log, IAppConfiguration config, IAppDBManager dbManager)
{
this.log = log;
this.config = config;
this.dbManager = dbManager;
}
public SqlServerConfigurator(IAppConfiguration appConfiguration) : base(appConfiguration)
{
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService,
IOverlayEntryCore overlayEntryCore)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_sensorService = sensorService;
_rTSSService = rTSSService;
_overlayEntryCore = overlayEntryCore;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.RunHistorySecondMetric;
ThirdMetric = _appConfiguration.RunHistoryThirdMetric;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
Task.Run(async() => await InitializeOverlayEntryDict())
.ContinueWith(t =>
{
IsOverlayActiveStream
.AsObservable()
.Select(isActive =>
{
if (isActive)
{
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.OnOSDOn();
_rTSSService.ClearOSD();
return(_onDictionaryUpdated.
SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
})
.Switch()
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
});
_sensorService.SensorSnapshotStream
.Sample(_sensorService.OsdUpdateStream.Select(timespan => Observable.Concat(Observable.Return(-1L), Observable.Interval(timespan))).Switch())
.Where((_, idx) => idx == 0 || IsOverlayActive)
.SubscribeOn(Scheduler.Default)
.Subscribe(sensorData =>
{
UpdateOverlayEntries(sensorData.Item2);
_onDictionaryUpdated.OnNext(_overlayEntryCore.OverlayEntryDict.Values.ToArray());
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public AppSettingsSectionViewModel(IAppConfiguration appConfiguration)
{
_appConfiguration = appConfiguration;
}
public IngredientsRepository(IAppConfiguration configuration)
{
_tableStorage = new TableStorage(configuration);
_ingredientsTable = configuration.GetVariable("IngredientsTable");
}
public TheCatWebAPIService(IAppConfiguration appConfiguration)
{
this.appSettings = appConfiguration.GetAppSettings();
}
public FormsAuthenticationService(IAppConfiguration configuration)
{
_configuration = configuration;
}
public static void Initialize(IAppConfiguration c)
{
_config = c;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="symmetricalEncryption">加密</param>
/// <param name="appConfig">应用配置</param>
public RabbitConnectionFactory(ISymmetricalEncryption symmetricalEncryption = null, IAppConfiguration appConfig = null)
: base(symmetricalEncryption, appConfig)
{
}
private static void BackgroundJobsPostStart(IAppConfiguration configuration)
{
var indexer = Container.Kernel.TryGet<IIndexingService>();
var jobs = new List<IJob>();
if (indexer != null)
{
indexer.RegisterBackgroundJobs(jobs, configuration);
}
if (!configuration.HasWorker)
{
jobs.Add(
new UpdateStatisticsJob(TimeSpan.FromMinutes(5),
() => new EntitiesContext(configuration.SqlConnectionString, readOnly: false),
timeout: TimeSpan.FromMinutes(5)));
}
if (configuration.CollectPerfLogs)
{
jobs.Add(CreateLogFlushJob());
}
if (jobs.AnySafe())
{
var jobCoordinator = new NuGetJobCoordinator();
_jobManager = new JobManager(jobs, jobCoordinator)
{
RestartSchedulerOnFailure = true
};
_jobManager.Fail(e => ErrorLog.GetDefault(null).Log(new Error(e)));
_jobManager.Start();
}
}
private ProcessList(string filename, IAppConfiguration appConfiguration)
{
_filename = filename;
_appConfiguration = appConfiguration;
}
