public CourseController(ICourseService courseService, ILessonService lessonService, IUserService userService, IReminderService reminderService)
{
_courseService = courseService;
_lessonService = lessonService;
_userService = userService;
_reminderService = reminderService;
}
private async Task InjectDependencies()
{
catalog.SiloStatusOracle = this.siloStatusOracle;
this.siloStatusOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
this.siloStatusOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
this.siloStatusOracle.SubscribeToSiloStatusEvents(typeManager);
this.siloStatusOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <DeploymentLoadPublisher>());
var reminderTable = Services.GetService <IReminderTable>();
if (reminderTable != null)
{
logger.Info($"Creating reminder grain service for type={reminderTable.GetType()}");
// Start the reminder service system target
var timerFactory = this.Services.GetRequiredService <IAsyncTimerFactory>();
reminderService = new LocalReminderService(this, reminderTable, this.initTimeout, this.loggerFactory, timerFactory);
RegisterSystemTarget((SystemTarget)reminderService);
}
RegisterSystemTarget(catalog);
await scheduler.QueueActionAsync(catalog.Start, catalog)
.WithTimeout(initTimeout, $"Starting Catalog failed due to timeout {initTimeout}");
// SystemTarget for provider init calls
this.fallbackScheduler = Services.GetRequiredService <FallbackSystemTarget>();
RegisterSystemTarget(fallbackScheduler);
}
public RemoveController(
IUserService userService,
IFeatureService featureService,
ILocationService locationService,
ICustomerService customerService,
IDivisionService divisionService,
IPropertyService propertyService,
IItemService itemService,
IDealService dealService,
IPaymentService paymentService,
IEmployeeService employeeService,
IReminderService reminderService,
IPictureService pictureService
)
{
_userService = userService;
_customerService = customerService;
_locationService = locationService;
_featureService = featureService;
_propertyService = propertyService;
_divisionService = divisionService;
_itemService = itemService;
_dealService = dealService;
_employeeService = employeeService;
_paymentService = paymentService;
_reminderService = reminderService;
_pictureService = pictureService;
}
private void InjectDependencies()
{
healthCheckParticipants.Add(membershipOracle);
catalog.SiloStatusOracle = LocalSiloStatusOracle;
localGrainDirectory.CatalogSiloStatusListener = catalog;
LocalSiloStatusOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
messageCenter.SiloDeadOracle = LocalSiloStatusOracle.IsDeadSilo;
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
LocalSiloStatusOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
LocalSiloStatusOracle.SubscribeToSiloStatusEvents(DeploymentLoadPublisher.Instance);
// start the reminder service system target
reminderService = reminderFactory.CreateReminderService(this).WithTimeout(initTimeout).Result;
RegisterSystemTarget((SystemTarget)reminderService);
RegisterSystemTarget(catalog);
scheduler.QueueAction(catalog.Start, catalog.SchedulingContext)
.WaitWithThrow(initTimeout);
// SystemTarget for provider init calls
providerManagerSystemTarget = new ProviderManagerSystemTarget(this);
RegisterSystemTarget(providerManagerSystemTarget);
}
private void InjectDependencies()
{
catalog.SiloStatusOracle = this.siloStatusOracle;
this.siloStatusOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
this.siloStatusOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
this.siloStatusOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <DeploymentLoadPublisher>());
var reminderTable = Services.GetService <IReminderTable>();
if (reminderTable != null)
{
logger.LogInformation("Creating reminder grain service for type {ReminderTableType}", reminderTable.GetType());
// Start the reminder service system target
var timerFactory = this.Services.GetRequiredService <IAsyncTimerFactory>();
reminderService = new LocalReminderService(this, reminderTable, this.initTimeout, this.loggerFactory, timerFactory);
RegisterSystemTarget((SystemTarget)reminderService);
}
// SystemTarget for provider init calls
this.fallbackScheduler = Services.GetRequiredService <FallbackSystemTarget>();
RegisterSystemTarget(fallbackScheduler);
}
public IndexModel(
IReminderService reminderService,
IStringLocalizer <SharedResource> sharedLocalizer)
{
_reminderService = reminderService;
_localizer = sharedLocalizer;
}
public EventsController(
IEventsService <Event> eventsService,
IMediaHelper mediaHelper,
IIntranetMemberService <IIntranetMember> intranetMemberService,
IReminderService reminderService,
IActivityTypeProvider activityTypeProvider,
IDocumentIndexer documentIndexer,
IGroupActivityService groupActivityService,
IActivityLinkService activityLinkService,
IActivityTagsHelper activityTagsHelper,
IGroupMemberService groupMemberService,
IContextTypeProvider contextTypeProvider,
IActivityPageHelperFactory activityPageHelperFactory,
IMentionService mentionService)
: base(eventsService, mediaHelper, intranetMemberService, activityTypeProvider, activityLinkService, contextTypeProvider, activityPageHelperFactory)
{
_eventsService = eventsService;
_intranetMemberService = intranetMemberService;
_reminderService = reminderService;
_documentIndexer = documentIndexer;
_groupActivityService = groupActivityService;
_activityLinkService = activityLinkService;
_activityTagsHelper = activityTagsHelper;
_groupMemberService = groupMemberService;
_mentionService = mentionService;
}
public GameServiceTest()
{
_dataContextConnection = A.Fake <IDataContextConnection>();
_reminderService = A.Fake <IReminderService>();
_teamApi = A.Fake <ITeamApi>();
_competitionApi = A.Fake <ICompetitionApi>();
_matchApi = A.Fake <IMatchApi>();
}
public ConfigurationController(ICalendarConfigurationService calendarConfigurationService,
ICalendarService calendarService,
IReminderService reminderService)
{
this.calendarConfigurationService = calendarConfigurationService;
this.calendarService = calendarService;
this.reminderService = reminderService;
}
public CallbackController(ICalendarService calendarService,
ILogger <CallbackController> logger,
IReminderService reminderService)
{
this.calendarService = calendarService;
this.logger = logger;
this.reminderService = reminderService;
}
public WM_TaskController(IWM_TaskService _WM_TaskService, ISY_UserService _SY_UserService, IOS_PlayerService _OS_PlayerService, IReminderService _ReminderService, ISY_ReminderSystemService _SY_ReminderSystemService)
{
this._WM_TaskService = _WM_TaskService;
this._SY_UserService = _SY_UserService;
this._OS_PlayerService = _OS_PlayerService;
this._ReminderService = _ReminderService;
this._SY_ReminderSystemService = _SY_ReminderSystemService;
}
public PM_ProjectController(IPM_ProjectService _PM_ProjectService, IPM_ComponentService _PM_ComponentService, IPM_WorkService _PM_WorkService, ISY_UserService _SY_UserService, IOS_PlayerService _OS_PlayerService, IReminderService _ReminderService)
{
this._PM_ProjectService = _PM_ProjectService;
this._PM_ComponentService = _PM_ComponentService;
this._PM_WorkService = _PM_WorkService;
this._SY_UserService = _SY_UserService;
this._OS_PlayerService = _OS_PlayerService;
this._ReminderService = _ReminderService;
}
public RecipeDetailViewModel(ILiveTileService tileService, IDialogService dialogService, INavigationService navigationService,
IReminderService reminderService, IShareService shareService)
{
this.LiveTileService = tileService;
this.DialogService = dialogService;
this.NavigationService = navigationService;
this.ReminderService = reminderService;
this.ShareService = shareService;
}
public DummySilo(
ILifecycleObservable lifecycle,
ILoggerFactory loggerFactory,
IMembershipOracle membershipOracle,
IReminderService reminderService,
IMessageCenter messageCenter,
IRuntime runtime)
{
logger = loggerFactory.CreateLogger <DummySilo>();
lifecycle.Subscribe(Initialize, Start, Stop);
}
public RecipeDetailViewModel(ILiveTileServiceWP8 tileService, IDialogService dialogService,
INavigationService navigationService,
IReminderService reminderService, IShareService shareService, ISpeechService speechService)
{
_liveTileService = tileService;
_dialogService = dialogService;
_navigationService = navigationService;
_reminderService = reminderService;
_shareService = shareService;
_speechService = speechService;
}
public GameService(IDataContextConnection db, IReminderService reminderService,
FootballDataApiV2.Interfaces.ICompetitionApi competitionApi,
FootballDataApiV2.Interfaces.ITeamApi teamApi,
FootballDataApiV2.Interfaces.IMatchApi matchApi)
{
_db = db.Database;
_reminderService = reminderService;
_competitionApi = competitionApi;
_teamApi = teamApi;
_matchApi = matchApi;
}
public Topic(
string id,
IActorSystem system,
ITimerService timers,
IReminderService reminders,
ITopicStorage storage)
: base(id, system)
{
this.timers = timers;
this.reminders = reminders;
this.storage = storage;
}
public ReminderJob(
IReminderService reminderService,
IActivitiesServiceFactory activitiesServiceFactory,
IConfigurationProvider <ReminderConfiguration> configurationProvider,
IExceptionLogger exceptionLogger, INotificationTypeProvider notificationTypeProvider)
{
_reminderService = reminderService;
_activitiesServiceFactory = activitiesServiceFactory;
_configurationProvider = configurationProvider;
_exceptionLogger = exceptionLogger;
_notificationTypeProvider = notificationTypeProvider;
}
public Topic(
string id,
IActorSystem system,
ITimerService timers,
IReminderService reminders,
ITopicStorage storage)
: base(id, system)
{
this.timers = timers;
this.reminders = reminders;
this.storage = storage;
}
public UsersController(
IUserService userService,
IMapper mapper,
IOptions <AppSettings> appSettings,
IReminderService reminderService,
INotificationService notificationService)
{
_userService = userService;
_mapper = mapper;
_appSettings = appSettings.Value;
_reminderService = reminderService;
_notificationService = notificationService;
}
public ReminderRunner(
IReminderService reminderService,
IActivitiesServiceFactory activitiesServiceFactory,
IConfigurationProvider <ReminderConfiguration> configurationProvider,
INotificationTypeProvider notificationTypeProvider,
ILogger logger)
{
_reminderService = reminderService;
_activitiesServiceFactory = activitiesServiceFactory;
_configurationProvider = configurationProvider;
_notificationTypeProvider = notificationTypeProvider;
_logger = logger;
}
public StartupService(
DiscordSocketClient discordSocketClient,
IConfiguration configuration,
ICommandStoreService commandStoreService,
ILogger logger,
IReminderService reminderService)
{
_discordSocketClient = discordSocketClient;
_configuration = configuration;
_commandStoreService = commandStoreService;
_logger = logger;
_reminderService = reminderService;
}
public ViewModelBase(INavigationService navigationService, IEventAggregator eventAggregator, IStoreManager storeManager, IToast toast, IFavoriteService favoriteService, ILoggerFacade logger, ILaunchTwitter twitter, ISSOClient ssoClient, IPushNotifications pushNotifications, IReminderService reminderService, IPageDialogService pageDialogService)
{
Navigation = navigationService;
EventAggregator = eventAggregator;
StoreManager = storeManager;
Toast = toast;
FavoriteService = favoriteService;
Logger = logger;
SSOClient = ssoClient;
PushNotifications = pushNotifications;
ReminderService = reminderService;
PageDialogService = pageDialogService;
LaunchTwitter = twitter;
}
public BaseViewModel()
{
patientService = new PatientService();
mdtService = new MDTService();
dentalProceduresService = new DentalProceduresService();
procedureCellService = new ProcedureCellService();
proceduresTableService = new ProceduresTableService();
dentistAppointmentsService = new DentistAppointmentService();
doctorService = new DoctorService();
activityService = new ActivityService();
reminderService = new ReminderService();
videoService = new VideoService();
diseaseService = new DiseaseService();
diagnoseService = new DiagnoseService();
}
/// <summary>
/// Initializes a new instance of the <see cref="StartupServicesProvider"/> class.
/// </summary>
/// <param name="applicationSettings">Application settings.</param>
/// <param name="settingsService">Setting service.</param>
/// <param name="viewModelBuilder">View model builder.</param>
/// <param name="emailDeliveryService">Email delivery service.</param>
/// <param name="reminderService">Reminder service.</param>
/// <param name="backupService">Backup service.</param>
public StartupServicesProvider(
IApplicationSettings applicationSettings,
ISettingsService settingsService,
IViewModelBuilder viewModelBuilder,
IEmailDeliveryService emailDeliveryService,
IReminderService reminderService,
IBackupService backupService)
{
this.applicationSettings = applicationSettings;
this.settingsService = settingsService;
this.viewModelBuilder = viewModelBuilder;
this.emailDeliveryService = emailDeliveryService;
this.reminderService = reminderService;
this.backupService = backupService;
}
public SessionViewModel(
INavigationService navigationService,
IConferenceRepository conferenceRepository,
IReminderService reminderService,
IContentDialogService contentDialogService,
IEventTracker eventTrackerService)
: base("SessionView", navigationService)
{
this.conferenceRepository = conferenceRepository;
this.reminderService = reminderService;
this.contentDialogService = contentDialogService;
this.eventTrackerService = eventTrackerService;
}
public EventController(
IEventRepository eventRepository,
UserManager <ApplicationUser> userManager,
IEventUsersRepository eventUsersRepository,
IMapper mapper,
IReminderService reminderService,
IMailService mailService,
INotificationService notificationService
)
{
_eventRepository = eventRepository;
_userManger = userManager;
_eventUsersRepository = eventUsersRepository;
_mapper = mapper;
_reminderService = reminderService;
_mailService = mailService;
_notificationService = notificationService;
}
public AppService(
IUnitOfWork unitOfWork,
IReminderService reminderService,
IItemService itemService,
IHttpContextAccessor accessor,
IStringLocalizer <SharedResource> localizer)
{
_itemService = itemService;
_reminderService = reminderService;
_localizer = localizer;
_users = unitOfWork.Set <User>();
var httpContext = accessor.HttpContext;
_baseUrl = $"{httpContext.Request.Scheme}://{httpContext.Request.Host.Host}:{httpContext.Request.Host.Port}/";
}
public ReminderController(
IReminderService reminderService,
INotificationTypeService notificationTypeService,
INotificationRoleService notificationRoleService,
IMeetingService meetingService,
ILogService logService,
ILoggerFactory logger,
IAuthenticationService authenticationService,
IMeetingAttachmentService meetingAttachmentService)
{
_reminderService = reminderService;
_notificationTypeService = notificationTypeService;
_meetingService = meetingService;
_logService = logService;
_authenticationService = authenticationService;
_meetingAttachmentService = meetingAttachmentService;
_logger = logger.CreateLogger("ReminderController");
}
private async Task InjectDependencies()
{
healthCheckParticipants.Add(membershipOracle);
catalog.SiloStatusOracle = this.membershipOracle;
this.membershipOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
messageCenter.SiloDeadOracle = this.membershipOracle.IsDeadSilo;
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
this.membershipOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
this.membershipOracle.SubscribeToSiloStatusEvents(typeManager);
this.membershipOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <DeploymentLoadPublisher>());
this.membershipOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <ClientObserverRegistrar>());
var reminderTable = Services.GetService <IReminderTable>();
if (reminderTable != null)
{
logger.Info($"Creating reminder grain service for type={reminderTable.GetType()}");
// Start the reminder service system target
reminderService = new LocalReminderService(this, reminderTable, this.initTimeout, this.loggerFactory);;
RegisterSystemTarget((SystemTarget)reminderService);
}
RegisterSystemTarget(catalog);
await scheduler.QueueAction(catalog.Start, catalog.SchedulingContext)
.WithTimeout(initTimeout, $"Starting Catalog failed due to timeout {initTimeout}");
// SystemTarget for provider init calls
this.fallbackScheduler = Services.GetRequiredService <FallbackSystemTarget>();
RegisterSystemTarget(fallbackScheduler);
// SystemTarget for startup tasks
var startupTaskTarget = Services.GetRequiredService <StartupTaskSystemTarget>();
RegisterSystemTarget(startupTaskTarget);
}
public EventsController(
IEventsService <Event> eventsService,
IMediaHelper mediaHelper,
IIntranetMemberService <IntranetMember> intranetMemberService,
IReminderService reminderService,
IGroupActivityService groupActivityService,
IActivityLinkService activityLinkService,
IActivityTagsHelper activityTagsHelper,
IMentionService mentionService,
IPermissionsService permissionsService)
{
_eventsService = eventsService;
_intranetMemberService = intranetMemberService;
_reminderService = reminderService;
_groupActivityService = groupActivityService;
_activityLinkService = activityLinkService;
_activityTagsHelper = activityTagsHelper;
_mentionService = mentionService;
_mediaHelper = mediaHelper;
_permissionsService = permissionsService;
}
private async Task InjectDependencies()
{
healthCheckParticipants.Add(membershipOracle);
catalog.SiloStatusOracle = this.membershipOracle;
this.membershipOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
messageCenter.SiloDeadOracle = this.membershipOracle.IsDeadSilo;
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
this.membershipOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
this.membershipOracle.SubscribeToSiloStatusEvents(typeManager);
this.membershipOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <DeploymentLoadPublisher>());
this.membershipOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService <ClientObserverRegistrar>());
IOptions <ReminderOptions> reminderOptions = this.Services.GetRequiredService <IOptions <ReminderOptions> >();
if (!reminderOptions.Value.ReminderService.Equals(ReminderOptions.BuiltIn.Disabled))
{
// start the reminder service system target
reminderService = Services.GetRequiredService <LocalReminderServiceFactory>()
.CreateReminderService(this, initTimeout, this.runtimeClient);
var reminderServiceSystemTarget = this.reminderService as SystemTarget;
if (reminderServiceSystemTarget != null)
{
RegisterSystemTarget(reminderServiceSystemTarget);
}
}
RegisterSystemTarget(catalog);
await scheduler.QueueAction(catalog.Start, catalog.SchedulingContext)
.WithTimeout(initTimeout, $"Starting Catalog failed due to timeout {initTimeout}");
// SystemTarget for provider init calls
this.fallbackScheduler = Services.GetRequiredService <FallbackSystemTarget>();
RegisterSystemTarget(fallbackScheduler);
}
public MainViewModel(IViewModelManager viewModelManager,
IViewModelFactory viewModelFactory,
INotificationManager notificationManager,
IReminderService reminderService,
IReactiveCommandFactory reactiveCommandFactory)
: base(viewModelManager, viewModelFactory, reactiveCommandFactory)
{
_notificationManager = notificationManager;
_reminderService = reminderService;
TrayNotificationEnabled = true;
TaskFactory factory = new TaskFactory(TaskScheduler.FromCurrentSynchronizationContext());
CreateReminderCommand = reactiveCommandFactory.CreateAsyncTask(async (o, token) =>
{
await factory.StartNew(() =>
{
var vm = viewModelFactory.Resolve<ReminderEditViewModel>();
vm.Show();
});
});
ShowReminderGridCommand = reactiveCommandFactory.CreateAsyncTask(async (o, token) =>
{
await factory.StartNew(() =>
{
var vm = viewModelFactory.Resolve<ReminderGridViewModel>();
vm.Show();
});
});
ExitApplicationCommand = reactiveCommandFactory.CreateAsyncTask(async (o, token) =>
{
await factory.StartNew(() =>
{
ApplicationInstanceProvider.Instance.ApplicationExit();
});
});
}
public RemindersController()
{
_reminderService = new ReminderService(new ReminderRepository());
var permissionRepository = new PermissionRepository();
_churchRepository = new ChurchRepository();
var personRepository = new PersonRepository(permissionRepository, _churchRepository);
_birthdayAndAnniversaryService = new BirthdayAndAnniversaryService(new BirthdayAndAniversaryRepository());
_emailSender = new EmailSender(new MessageRepository(), new MessageRecepientRepository(), new MessageAttachmentRepository(), personRepository);
_monthNames = new Dictionary<int, string>
{
{1, "January"},
{2, "February"},
{3, "March"},
{4, "April"},
{5, "May"},
{6, "June"},
{7, "July"},
{8, "August"},
{9, "September"},
{10, "October"},
{11, "November"},
{12, "December"}
};
}
public AjaxController()
{
var messageRepository = new MessageRepository();
var permissionRepository = new PermissionRepository();
var churchRepository = new ChurchRepository();
var personRepository = new PersonRepository(permissionRepository, churchRepository);
var uploadPhotoRepository = new PhotoRepository();
_familyRepository = new FamilyRepository(uploadPhotoRepository);
_usernamePasswordRepository = new UsernamePasswordRepository(permissionRepository);
var personGroupRepository = new PersonGroupRepository(personRepository);
_personGroupRepository = personGroupRepository;
var groupRepository = new GroupRepository();
var emailSender = new EmailSender(messageRepository, new MessageRecepientRepository(), new MessageAttachmentRepository(), personRepository);
var emailContentService = new EmailContentService(new EmailContentRepository());
var churchEmailTemplateRepository = new ChurchEmailTemplatesRepository();
_emailService = new EmailService(
_usernamePasswordRepository,
personRepository,
groupRepository,
emailSender,
emailContentService,
churchEmailTemplateRepository,
permissionRepository
);
_passwordService = new PasswordService(personRepository, churchRepository, _usernamePasswordRepository, _emailService);
_personService = new PersonService(
personRepository,
_personGroupRepository,
permissionRepository,
new PersonRoleRepository(),
new PersonOptionalFieldRepository(),
new RelationshipRepository(personRepository),
new ChurchMatcherRepository(),
groupRepository,
_familyRepository,
_emailService,
new AddressRepository(),
uploadPhotoRepository
);
_groupEventRepository = new GroupEventRepository(personRepository);
_systemAdministratorService = new SystemAdministratorService(churchRepository, permissionRepository);
_personGroupService = new PersonGroupService(_personGroupRepository);
_messageRecepientRepository = new MessageRecepientRepository();
var httpPostService = new HttpPostService();
_smsSender = new SmsSender(messageRepository, new MessageRecepientRepository(), personRepository, httpPostService);
_churchEventsReporitory = new ChurchEventsRepository();
_messageService = new MessageService(_messageRecepientRepository);
var birthdayRepository = new BirthdayAndAniversaryRepository();
var usernamePasswordRepository = new UsernamePasswordRepository(permissionRepository);
var churchEmailTemplatesRepository = new ChurchEmailTemplatesRepository();
var emailService = new EmailService(usernamePasswordRepository, personRepository, groupRepository, emailSender, emailContentService, churchEmailTemplatesRepository, permissionRepository);
var eventRepository = new EventRepository(birthdayRepository);
_eventService = new EventService(eventRepository, emailService, birthdayRepository);
_childReportsService = new ChildReportsService(new ChildrenReportsRepository(), _emailService);
_reminderService = new ReminderService(new ReminderRepository());
}
public Topic()
{
timers = new TimerService(this);
reminders = new ReminderService(this);
storage = ServiceLocator.TopicStorage;
}
private void InjectDependencies()
{
healthCheckParticipants.Add(membershipOracle);
catalog.SiloStatusOracle = LocalSiloStatusOracle;
localGrainDirectory.CatalogSiloStatusListener = catalog;
LocalSiloStatusOracle.SubscribeToSiloStatusEvents(localGrainDirectory);
messageCenter.SiloDeadOracle = LocalSiloStatusOracle.IsDeadSilo;
// consistentRingProvider is not a system target per say, but it behaves like the localGrainDirectory, so it is here
LocalSiloStatusOracle.SubscribeToSiloStatusEvents((ISiloStatusListener)RingProvider);
LocalSiloStatusOracle.SubscribeToSiloStatusEvents(typeManager);
LocalSiloStatusOracle.SubscribeToSiloStatusEvents(Services.GetRequiredService<DeploymentLoadPublisher>());
if (!GlobalConfig.ReminderServiceType.Equals(GlobalConfiguration.ReminderServiceProviderType.Disabled))
{
// start the reminder service system target
reminderService = Services.GetRequiredService<LocalReminderServiceFactory>()
.CreateReminderService(this, grainFactory, initTimeout, this.runtimeClient);
RegisterSystemTarget((SystemTarget) reminderService);
}
RegisterSystemTarget(catalog);
scheduler.QueueAction(catalog.Start, catalog.SchedulingContext)
.WaitWithThrow(initTimeout);
// SystemTarget for provider init calls
providerManagerSystemTarget = new ProviderManagerSystemTarget(this);
RegisterSystemTarget(providerManagerSystemTarget);
}
