public void InitTest()
{
base.InitDbContext();
_backgroundService = Substitute.For<IBackgroundService>();
_appraiserOrderRepository = new AppraiserOrderRepository(this.DbFactory);
_orderRepository = new OrderRepository(this.DbFactory);
_commitProvider = new CommitProvider(this.DbFactory);
_userRepository = new UserRepository(this.DbFactory);
_taskManager = new TaskManager(_backgroundService, _userRepository);
_referenceManagement = new ReferenceManagement(new ReferenceRepository(this.DbFactory), new WebCacheService());
_dateTimeManager = new DateTimeManager(_referenceManagement);
_appraiserManagement = Substitute.For<IAppraiserManagement>();
_configHelper = Substitute.For<IConfigurationHelper>();
_orderManager = new OrderManager(
_orderRepository,
Substitute.For<IClientUserRepository>(),
_referenceManagement,
_appraiserManagement,
_configHelper,
Substitute.For<IAppraiserOrderRepository>(),
Substitute.For<IChangeTrackingRepository>(),
Substitute.For<IOrderHistoryManager>(),
Substitute.For<IOrderDocumentsRepository>());
_appraiserOrderDeliveryService = new AppraiserOrderDeliveryService(_taskManager, _appraiserOrderRepository, _commitProvider, _orderManager,
new DateTimeManager(_referenceManagement), Substitute.For<IOrderHistoryManager>(), Substitute.For<IAppraiserOrderSetPointsRepository>(),
Substitute.For<IAppraiserOrderListItemRepository>(),
Substitute.For<IOrderPeriodicalNotificationManager>());
}
public HomeViewModel()
{
Interval = "15";
Title = "Homepage";
_weatherService = Locator.Current.GetService <IWeatherService>();
_dataRepository = Locator.Current.GetService <IDataRepository>();
_backgroundService = Locator.Current.GetService <IBackgroundService>();
GetWeather = ReactiveCommand.CreateFromTask <string, WeatherRoot>(
city => {
if (string.IsNullOrEmpty(city))
{
return(GetWeatherUsingGps());
}
return(_weatherService.GetWeather(city));
});
GetWeather.Subscribe(data => { Output = data; });
_weatherService.NewWeatherUpdate.Subscribe(data => { Output = data; });
_isLoading = GetWeather
.IsExecuting
.ToProperty(this, x => x.IsLoading);
this.WhenValueChanged(x => x.Interval)
.Skip(1) // Skip initial value assignment
.Throttle(TimeSpan.FromSeconds(2))
.Where(x => !string.IsNullOrEmpty(x))
.Subscribe(interval =>
{
_backgroundService.StopJob();
_backgroundService.RunJob(int.Parse(interval));
});
GetWeather.IsExecuting
.Skip(1) // IsExecuting has an initial value of false. We can skip that first value
.Where(isExecuting => !isExecuting) // filter until the executing state becomes false
.Subscribe(_ => {
if (!_backgroundService.IsJobRunning)
{
_backgroundService.RunJob(int.Parse(string.IsNullOrEmpty(Interval) ? "0" : Interval));
}
});
this.WhenValueChanged(x => x.Output)
.Skip(1) // Skip initial value assignment
.DistinctUntilChanged()
.Throttle(TimeSpan.FromSeconds(2))
.Subscribe(data =>
{
var h = data.ToHistory();
h.Id = 1;
_dataRepository.SaveItemAsync(h);
});
}
public BackgroundServiceMonitor(
[NotNull] IFeatureToggleWithDefault featureToggle, [NotNull] IBackgroundService backgroundService,
[NotNull] IApplicationLifetimeManager applicationLifetimeManager, [NotNull] ILogger logger, [NotNull] ITypeHelper typeHelper)
{
_FeatureToggle = featureToggle ?? throw new ArgumentNullException(nameof(featureToggle));
_BackgroundService = backgroundService ?? throw new ArgumentNullException(nameof(backgroundService));
_ApplicationLifetimeManager = applicationLifetimeManager ?? throw new ArgumentNullException(nameof(applicationLifetimeManager));
_Logger = logger ?? throw new ArgumentNullException(nameof(logger));
_TypeHelper = typeHelper ?? throw new ArgumentNullException(nameof(typeHelper));
}
public AutomaticSyncingService(
IBackgroundService backgroundService,
ITimeService timeService)
{
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.backgroundService = backgroundService;
this.timeService = timeService;
}
public BackgroundMenu(
INWScript script,
IDialogService dialog,
IColorTokenService color,
IBackgroundService background)
: base(script, dialog)
{
_background = background;
_color = color;
}
protected override void RunAppStart(object hint = null)
{
base.RunAppStart(hint);
analyticsService = Mvx.Resolve <IAnalyticsService>();
backgroundService = Mvx.Resolve <IBackgroundService>();
navigationService = Mvx.Resolve <IMvxNavigationService>();
setupNavigationBar();
setupTabBar();
}
public void RefreshSettings()
{
IBackgroundService backgroundService = backgroundServiceService.GetBackgroundService(this.ID);
if (backgroundService != null)
{
Enabled = backgroundService.Enabled;
}
settings = null;
}
public void TestInitialize()
{
_appraiserOrderRepository = Substitute.For<IAppraiserOrderRepository>();
_backgroundService = Substitute.For<IBackgroundService>();
_userRepository = Substitute.For<IUserRepository>();
_taskManager = new TaskManager(_backgroundService, _userRepository);
_commitProvider = Substitute.For<ICommitProvider>();
Target = new AppraiserOrderDeliveryService(_taskManager, _appraiserOrderRepository, _commitProvider, Substitute.For<IOrderManager>(),
new DateTimeManager(Substitute.For<IReferenceManagement>()), Substitute.For<IOrderHistoryManager>(), Substitute.For<IAppraiserOrderSetPointsRepository>(),
Substitute.For<IAppraiserOrderListItemRepository>(), Substitute.For<IOrderPeriodicalNotificationManager>());
}
public AutomaticSyncingService(
IBackgroundService backgroundService,
ITimeService timeService,
ILastTimeUsageStorage lastTimeUsageStorage)
{
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(lastTimeUsageStorage, nameof(lastTimeUsageStorage));
this.backgroundService = backgroundService;
this.timeService = timeService;
this.lastTimeUsageStorage = lastTimeUsageStorage;
}
public SettingsViewModel(IBackgroundService _backgroundService)
{
backgroundService = _backgroundService;
// Create a new trigger
applicationtrigger = new ApplicationTrigger();
localFolder = ApplicationData.Current.LocalFolder;
_fences = new ObservableCollection <Fence>();
_locations = new ObservableCollection <Location>();
formatterLongTime = new DateTimeFormatter("{hour.integer}:{minute.integer(2)}:{second.integer(2)}", new[] { "en-US" }, "US", Windows.Globalization.CalendarIdentifiers.Gregorian, Windows.Globalization.ClockIdentifiers.TwentyFourHour);
calendar = new Calendar();
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateCommandHandler"/> class.
/// </summary>
/// <param name="module">The command handler module.</param>
/// <param name="idGenerator">The generator for unique identifiers.</param>
/// <param name="serializer">The JSON serializer.</param>
/// <param name="mediator">The mediator.</param>
/// <param name="backgroundService">The background service.</param>
public CreateCommandHandler(
ICommandHandlerModule module,
IIdGenerator idGenerator,
IDefaultJsonSerializer serializer,
IMediator mediator,
IBackgroundService backgroundService)
: base(module)
{
this.idGenerator = idGenerator ?? throw new ArgumentNullException(nameof(idGenerator));
this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
this.mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
this.backgroundService = backgroundService ?? throw new ArgumentNullException(nameof(backgroundService));
}
public GameServerManagerRefac(IGameFileManagerProvider fileProvider,
IBackgroundService backgroundService,
ILoggerFactory logFactory,
IServerProcessManagerProvider procManager,
IRepository repository)
{
_fileProvider = fileProvider;
_logFactory = logFactory;
_logger = logFactory.CreateLogger <GameServerManagerRefac>();
_backgroundService = backgroundService;
_repository = repository;
_procManager = procManager.GetProcessManagerProvider();
}
protected override void RunAppStart(object hint = null)
{
base.RunAppStart(hint);
var container = IosDependencyContainer.Instance;
timeService = container.TimeService;
analyticsService = container.AnalyticsService;
backgroundService = container.BackgroundService;
navigationService = container.NavigationService;
setupNavigationBar();
setupTabBar();
}
public TogglDataSource(
ITogglApi api,
ITogglDatabase database,
ITimeService timeService,
IErrorHandlingService errorHandlingService,
IBackgroundService backgroundService,
Func <ITogglDataSource, ISyncManager> createSyncManager,
TimeSpan minimumTimeInBackgroundForFullSync,
INotificationService notificationService,
IApplicationShortcutCreator shortcutCreator,
IAnalyticsService analyticsService)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(notificationService, nameof(notificationService));
Ensure.Argument.IsNotNull(errorHandlingService, nameof(errorHandlingService));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(createSyncManager, nameof(createSyncManager));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
this.database = database;
this.timeService = timeService;
this.shortcutCreator = shortcutCreator;
this.backgroundService = backgroundService;
this.notificationService = notificationService;
this.errorHandlingService = errorHandlingService;
this.minimumTimeInBackgroundForFullSync = minimumTimeInBackgroundForFullSync;
User = new UserDataSource(database.User);
Tags = new TagsDataSource(database.Tags);
Tasks = new TasksDataSource(database.Tasks);
Clients = new ClientsDataSource(database.Clients);
Projects = new ProjectsDataSource(database.Projects);
Workspaces = new WorkspacesDataSource(database.Workspaces);
Preferences = new PreferencesDataSource(database.Preferences);
WorkspaceFeatures = new WorkspaceFeaturesDataSource(database.WorkspaceFeatures);
TimeEntries = new TimeEntriesDataSource(database.TimeEntries, timeService, analyticsService);
this.createSyncManager = createSyncManager;
CreateNewSyncManager();
ReportsProvider = new ReportsProvider(api, database);
FeedbackApi = api.Feedback;
isLoggedIn = true;
}
private void registerApplicationLifecycleObserver(IBackgroundService backgroundService)
{
var togglApplication = getTogglApplication();
var currentAppLifecycleObserver = togglApplication.ApplicationLifecycleObserver;
if (currentAppLifecycleObserver != null)
{
Application.UnregisterActivityLifecycleCallbacks(currentAppLifecycleObserver);
Application.UnregisterComponentCallbacks(currentAppLifecycleObserver);
}
togglApplication.ApplicationLifecycleObserver = new ApplicationLifecycleObserver(backgroundService);
Application.RegisterActivityLifecycleCallbacks(togglApplication.ApplicationLifecycleObserver);
Application.RegisterComponentCallbacks(togglApplication.ApplicationLifecycleObserver);
}
/// <summary>
/// Syncs the currently registered <see cref="IBackgroundTask"/>s on the given <see cref="IBackgroundService"/> to match a collection of <see cref="IBackgroundTask"/>s.
/// </summary>
/// <param name="service">The <see cref="IBackgroundService"/> used for registering/unregistering background tasks.</param>
/// <param name="tasks">The desired collection of <see cref="IBackgroundTask"/>s to register.</param>
public static async Task RegisterCollectionAsync(this IBackgroundService service, IEnumerable <IBackgroundTask> tasks)
{
var toRemove = service.CurrentlyRegistered.Where(r => !tasks.Any(t => t.Id == r)).ToArray();
var toAdd = tasks.Where(t => !service.CurrentlyRegistered.Any(r => r == t.Id)).ToArray();
foreach (var name in toRemove)
{
service.UnRegister(name);
}
foreach (var task in toAdd)
{
await service.RegisterAsync(task);
}
}
public void Stop()
{
lock (timer)
{
if (Status != BackgroundServiceExecutorStatus.Stopped)
{
timer.Change(Timeout.Infinite, Timeout.Infinite);
timer.Dispose();
current = null;
Status = BackgroundServiceExecutorStatus.Stopped;
}
}
}
public void InvokeShouldWork()
{
IServiceProvider serviceProvider = base.InitDependencyInjection(services => { }, builder => { });
IBackgroundService backgroundService = serviceProvider.GetService <IBackgroundService>();
int x = 0, y = 50;
backgroundService.Invoke(() =>
{
x = y;
});
System.Threading.Thread.Sleep(1000);
Assert.AreEqual(x, y);
}
public BackgroundServiceDecorator(
IBackgroundService decorated,
ITelemetryClientFactory telemetryClientFactory,
ShellSettings shellSettings,
IEnumerable <IBackgroundTask> backgroundTasks,
IClock clock,
ISiteService siteService)
{
_decorated = decorated;
_telemetryClientFactory = telemetryClientFactory;
_shellSettings = shellSettings;
_backgroundTasks = backgroundTasks;
_clock = clock;
_siteService = siteService;
}
public OnModuleEnter(INWScript script,
IPlayerService player,
ISkillService skill,
IQuestService quest,
IActivityLoggingService activityLogging,
IMapPinService mapPin,
IBackgroundService background)
{
_ = script;
_player = player;
_skill = skill;
_quest = quest;
_activityLogging = activityLogging;
_mapPin = mapPin;
_background = background;
}
public void Start()
{
IBackgroundService backgroundService = (IBackgroundService)container.Resolve(type);
IPlugin plugin = getPlugin();
TimeSpan interval = getInterval(plugin);
if (interval.TotalSeconds > 10)
{
#if DEBUG
if (plugin.Enabled)
{
backgroundService.Run(plugin.Settings);
}
#endif
timer.Change(interval, new TimeSpan(0, 0, 0, 0, -1));
}
}
public void InvokeManyTimeShouldWork()
{
IServiceProvider serviceProvider = base.InitDependencyInjection(services => { }, builder => { });
IBackgroundService backgroundService = serviceProvider.GetService <IBackgroundService>();
int x = 0;
for (var i = 0; i < 100; i++)
{
backgroundService.Invoke(() =>
{
x++;
});
}
System.Threading.Thread.Sleep(1000);
Assert.AreEqual(x, 100);
}
public void Start()
{
IBackgroundService backgroundService = (IBackgroundService)container.Resolve(type);
backgroundService.RefreshSettings();
//INFO: (erikpo) This check is just to make sure a value was provided for interval and that they can't put in an interval that will take down their server
if (backgroundService.Interval.TotalSeconds > 10)
{
#if DEBUG
if (backgroundService.Enabled)
{
backgroundService.Run();
}
#endif
timer.Change(backgroundService.Interval, new TimeSpan(0, 0, 0, 0, -1));
}
}
public BackgroundServiceTests()
{
unitOfWorkMock = new Mock <IUnitOfWork>();
backgroundsOwnedRepositoryMock = new Mock <IAsyncRepository <BackgroundsOwned> >();
profileVisualsRepositoryMock = new Mock <IAsyncRepository <ProfileVisuals> >();
unitOfWorkMock.Setup(x => x.GetRepository(
It.IsAny <IRepositoryFactory <BackgroundsOwned> >()))
.Returns(backgroundsOwnedRepositoryMock.Object);
unitOfWorkMock.Setup(x => x.GetRepository(
It.IsAny <IRepositoryFactory <ProfileVisuals> >()))
.Returns(profileVisualsRepositoryMock.Object);
transactionServiceMock = new Mock <ITransactionService>();
backgroundStoreMock = new Mock <IBackgroundStore>();
backgroundService = new BackgroundService(
unitOfWorkMock.Object, transactionServiceMock.Object, backgroundStoreMock.Object);
}
public TogglDataSource(
ITogglApi api,
ITogglDatabase database,
ITimeService timeService,
IApiErrorHandlingService apiErrorHandlingService,
IBackgroundService backgroundService,
Func <ITogglDataSource, ISyncManager> createSyncManager,
TimeSpan minimumTimeInBackgroundForFullSync,
IApplicationShortcutCreator shortcutCreator)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(apiErrorHandlingService, nameof(apiErrorHandlingService));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(createSyncManager, nameof(createSyncManager));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
this.database = database;
this.apiErrorHandlingService = apiErrorHandlingService;
this.backgroundService = backgroundService;
this.shortcutCreator = shortcutCreator;
this.minimumTimeInBackgroundForFullSync = minimumTimeInBackgroundForFullSync;
User = new UserDataSource(database.User, timeService);
Tags = new TagsDataSource(database.IdProvider, database.Tags, timeService);
Tasks = new TasksDataSource(database.Tasks);
Clients = new ClientsDataSource(database.IdProvider, database.Clients, timeService);
Preferences = new PreferencesDataSource(database.Preferences);
Projects = new ProjectsDataSource(database.IdProvider, database.Projects, timeService);
TimeEntries = new TimeEntriesDataSource(database.TimeEntries, timeService);
Workspaces = new WorkspacesDataSource(database.Workspaces);
WorkspaceFeatures = new WorkspaceFeaturesDataSource(database.WorkspaceFeatures);
SyncManager = createSyncManager(this);
ReportsProvider = new ReportsProvider(api, database);
errorHandlingDisposable = SyncManager.ProgressObservable.Subscribe(onSyncError);
isLoggedIn = true;
}
private void timerCallback(object state)
{
if (!isExecuting)
{
IBackgroundService backgroundService = (IBackgroundService)container.Resolve(type);
backgroundService.RefreshSettings();
if (backgroundService.Enabled)
{
isExecuting = true;
backgroundService.Run();
isExecuting = false;
}
}
//TODO: (erikpo) Once background services have a cancel state and timeout interval, check their state and cancel if appropriate
}
public PerkRefund(
INWScript script,
IDialogService dialog,
IDataService data,
IColorTokenService color,
INWNXCreature nwnxCreature,
ICustomEffectService customEffect,
IPlayerStatService stat,
ITimeService time,
IBackgroundService background)
: base(script, dialog)
{
_data = data;
_color = color;
_nwnxCreature = nwnxCreature;
_customEffect = customEffect;
_stat = stat;
_time = time;
_background = background;
}
private async Task StopService(
IBackgroundService service,
CancellationTokenSource cancellationTokenSource)
{
_logger.ServiceStopping(service);
var stopwatch = Stopwatch.StartNew();
try
{
await service.StopAsync(cancellationTokenSource.Token);
_logger.ServiceStopped(service, stopwatch.Elapsed);
}
catch (Exception error)
{
_logger.ServiceStopFailed(service, stopwatch.Elapsed, error);
cancellationTokenSource.Cancel(false);
throw;
}
}
public void Start()
{
lock (timer)
{
if (Status == BackgroundServiceExecutorStatus.Paused || Status == BackgroundServiceExecutorStatus.Stopped)
{
if (Status == BackgroundServiceExecutorStatus.Stopped)
{
Status = BackgroundServiceExecutorStatus.Starting;
current = (IBackgroundService)container.Resolve(backgroundServiceType);
current.Initialize(moduleConfiguration);
}
Status = BackgroundServiceExecutorStatus.Running;
current.Run(moduleConfiguration);
timer.Change(interval, new TimeSpan(0, 0, 0, 0, -1));
}
}
}
public EconomyModule(IEconomyService economyService,
IBragService bragService,
IGiveawayService giveawayService,
IBotRespectService botRespectService,
IBackgroundService backgroundService,
IRoleService roleService,
IRewindService rewindService,
IDoubleExpService doubleExpService,
IChannelService channelService,
IMessageService messageService)
{
this.economyService = economyService;
this.bragService = bragService;
this.giveawayService = giveawayService;
this.botRespectService = botRespectService;
this.backgroundService = backgroundService;
this.roleService = roleService;
this.rewindService = rewindService;
this.doubleExpService = doubleExpService;
this.channelService = channelService;
this.messageService = messageService;
}
public SuggestionsViewModel(
IInteractorFactory interactorFactory,
IOnboardingStorage onboardingStorage,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory,
IAnalyticsService analyticsService,
ITimeService timeService,
IPermissionsChecker permissionsChecker,
INavigationService navigationService,
IBackgroundService backgroundService,
IUserPreferences userPreferences,
ISyncManager syncManager,
IWidgetsService widgetsService)
: base(navigationService)
{
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(permissionsChecker, nameof(permissionsChecker));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(widgetsService, nameof(widgetsService));
this.interactorFactory = interactorFactory;
this.onboardingStorage = onboardingStorage;
this.schedulerProvider = schedulerProvider;
this.rxActionFactory = rxActionFactory;
this.analyticsService = analyticsService;
this.timeService = timeService;
this.permissionsChecker = permissionsChecker;
this.backgroundService = backgroundService;
this.userPreferences = userPreferences;
this.syncManager = syncManager;
this.widgetsService = widgetsService;
}
public ShellViewModel(IBackgroundService backgroundService, IDialogService dialogService, IEventAggregator eventAggregator, IRegionManager regionManager)
{
this.backgroundService = backgroundService;
this.dialogService = dialogService;
this.eventAggregator = eventAggregator;
this.regionManager = regionManager;
// this.eventAggregator.GetEvent<TaskItemInsertEvent>().Subscribe(e => { this.Message = e.Description; }, ThreadOption.UIThread);
this.eventAggregator.GetEvent <MemoryStatusEvent>().Subscribe(e => { this.MemoryStatus = e; }, ThreadOption.UIThread);
this.eventAggregator.GetEvent <MemoryStatusEvent>().Publish(1);
this.eventAggregator.GetEvent <CurrentDateEvent>().Subscribe(e => { this.CurrentDate = e; }, ThreadOption.UIThread);
this.eventAggregator.GetEvent <CurrentDateEvent>().Publish(DateTime.Now);
//użycie menu - wołanie okna po wybraniu przycisku
this.eventAggregator.GetEvent <NavigateToEvent>().Subscribe(n =>
{
this.regionManager.RequestNavigate("ContentRegion", new Uri(n, UriKind.Relative));
}, ThreadOption.UIThread);
}
public TaskManager(IBackgroundService backgroundService, IUserRepository userRepository)
{
_backgroundService = backgroundService;
_userRepository = userRepository;
}
public HomeController(ISession session, IDevAccessChecker devAccessChecker, IBackgroundService backgroundService)
{
_session = session;
_devAccessChecker = devAccessChecker;
_backgroundService = backgroundService;
}
