public VaultFileBackupRepositoryDecorator(IVaultRepository decoratedVaultRepository, string vaultBackupFolder, string vaultFileExtension, ISerializer serializer, IFileSystem fileSystem, ISymetricCryptographer symetricCryptographer, IClockProvider clockProvider, IVaultFileMetadataHandler vaultFileMetadataHandler) { GuardClauses.ArgumentIsNotNull(nameof(decoratedVaultRepository), decoratedVaultRepository); GuardClauses.ArgumentIsNotNull(nameof(vaultBackupFolder), vaultBackupFolder); GuardClauses.ArgumentIsNotNull(nameof(vaultFileExtension), vaultFileExtension); if (vaultFileExtension.StartsWith(".") == false) { throw new ArgumentException("File extension string must start with a dot. E.g. \".extension\"", nameof(vaultFileExtension)); } GuardClauses.ArgumentIsNotNull(nameof(symetricCryptographer), symetricCryptographer); GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider); GuardClauses.ArgumentIsNotNull(nameof(vaultFileMetadataHandler), vaultFileMetadataHandler); this.VaultRepository = decoratedVaultRepository; this.VaultBackupFolder = vaultBackupFolder; this.VaultFileExtension = vaultFileExtension; this.Serializer = serializer; this.FileSystem = fileSystem; this.SymetricCryptographer = symetricCryptographer; this.ClockProvider = clockProvider; this.VaultFileMetadataHandler = vaultFileMetadataHandler; }
public UserConfigAppService(ISettingDefinitionManager settingDefinitionManager, IIocResolver iocResolver, IClockProvider clockProvider, IRepository <UserSettingAttribute, long> userSettingAttributeRepository) { _settingDefinitionManager = settingDefinitionManager; _iocResolver = iocResolver; _clockProvider = clockProvider; _userSettingAttributeRepository = userSettingAttributeRepository; }
public UsersAcccountsManager(IClockProvider clockProvider, IUsersAccountsRepository usersAccountsRepository, IRepository <AccountHistory> accountsHistoryRepository) { _clockProvider = clockProvider; _accountsHistoryRepository = accountsHistoryRepository; _usersAccountsRepository = usersAccountsRepository; }
public ValidateToken(IClockProvider clockProvider, IEncryptionProvider encryptionProvider, IRequestTokenService requestTokenService) { _clockProvider = clockProvider; _encryptionProvider = encryptionProvider; _requestTokenService = requestTokenService; }
public VaultManipulator(Vault vault, IClockProvider clockProvider) { GuardClauses.ArgumentIsNotNull(nameof(vault), vault); GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider); Vault = vault; ClockProvider = clockProvider; }
/// <summary> /// Creates an instance of the virtual machine /// </summary> /// <param name="modelKey">The model key of the virtual machine</param> /// <param name="editionKey">The edition key of the virtual machine</param> /// <param name="devices">Devices to create the machine</param> private SpectrumMachine(string modelKey, string editionKey, DeviceInfoCollection devices) { // --- Store model information ModelKey = modelKey; EditionKey = editionKey; // --- Create the engine and set up properties SpectrumVm = new SpectrumEngine(devices); Cpu = new CpuZ80(SpectrumVm.Cpu); var roms = new List <ReadOnlyMemorySlice>(); for (var i = 0; i < SpectrumVm.RomConfiguration.NumberOfRoms; i++) { roms.Add(new ReadOnlyMemorySlice(SpectrumVm.RomDevice.GetRomBytes(i))); } Roms = new ReadOnlyCollection <ReadOnlyMemorySlice>(roms); PagingInfo = new MemoryPagingInfo(SpectrumVm.MemoryDevice); Memory = new SpectrumMemoryContents(SpectrumVm.MemoryDevice, SpectrumVm.Cpu); var ramBanks = new List <MemorySlice>(); if (SpectrumVm.MemoryConfiguration.RamBanks != null) { for (var i = 0; i < SpectrumVm.MemoryConfiguration.RamBanks; i++) { ramBanks.Add(new MemorySlice(SpectrumVm.MemoryDevice.GetRamBank(i))); } } RamBanks = new ReadOnlyCollection <MemorySlice>(ramBanks); Keyboard = new KeyboardEmulator(SpectrumVm); ScreenConfiguration = SpectrumVm.ScreenConfiguration; ScreenRenderingTable = new ScreenRenderingTable(SpectrumVm.ScreenDevice); ScreenBitmap = new ScreenBitmap(SpectrumVm.ScreenDevice); ScreenRenderingStatus = new ScreenRenderingStatus(SpectrumVm); BeeperConfiguration = SpectrumVm.AudioConfiguration; BeeperSamples = new AudioSamples(SpectrumVm.BeeperDevice); BeeperProvider = SpectrumVm.BeeperProvider; SoundConfiguration = SpectrumVm.SoundConfiguration; SoundProvider = SpectrumVm.SoundProvider; AudioSamples = new AudioSamples(SpectrumVm.SoundDevice); Breakpoints = new CodeBreakpoints(SpectrumVm.DebugInfoProvider); // --- Hook device events SpectrumVm.TapeLoadDevice.LoadCompleted += (s, e) => FastLoadCompleted?.Invoke(s, e); SpectrumVm.TapeSaveDevice.LeftSaveMode += (s, e) => LeftSaveMode?.Invoke(s, e); // --- Initialize machine state _clockProvider = GetProvider <IClockProvider>(); _physicalFrameClockCount = _clockProvider.GetFrequency() / (double)SpectrumVm.BaseClockFrequency * ScreenConfiguration.ScreenRenderingFrameTactCount; MachineState = VmState.None; ExecutionCompletionReason = ExecutionCompletionReason.None; }
public AuthenticationService(ILogger <AuthenticationService> logger, DatabaseContext context, IMediator mediator, ITokenHelper tokenHelper, IClockProvider clock) { _logger = logger; _context = context; _mediator = mediator; _tokenHelper = tokenHelper; _clock = clock; }
public TimeZoneSettingAppService( IClockProvider clockProvider, IRepository <UserSettingAttribute, long> userSettingAttributeRepository, ISettingManager settingManager) { _clockProvider = clockProvider; _userSettingAttributeRepository = userSettingAttributeRepository; _settingManager = settingManager; }
public CookieValidationService(IClockProvider clockProvider, ApplicationSettings applicationSettings, IEncryptionProvider encryptionProvider, IJsonWebTokenService jsonWebTokenService, IAccountService accountService) { _clockProvider = clockProvider; _cryptographySwitch = Switch.Create(applicationSettings.EncryptionKeys); _encryptionProvider = encryptionProvider; _jsonWebTokenService = jsonWebTokenService; _accountService = accountService; }
public CreateToken(IClockProvider clockProvider, IEncryptionProvider encryptionProvider, IRandomStringGenerator randomStringGenerator, IRequestTokenService requestTokenService) { _clockProvider = clockProvider; _encryptionProvider = encryptionProvider; _randomStringGenerator = randomStringGenerator; _requestTokenService = requestTokenService; }
public void Dispose() { if (_isDisposed) { return; } _isDisposed = true; _clockProvider?.Dispose(); _clockProvider = null; }
public MainWindow(IEliteProvider provider, IClockProvider clockProvider) { InitializeComponent(); _eliteProvider = provider ?? throw new ArgumentNullException(nameof(provider)); _clockProvider = clockProvider ?? throw new ArgumentNullException(nameof(clockProvider)); _currentDate = PlayerRankingDto.RankingStart[SelectedGame]; _timer = new Timer(TimerDelay); _timer.Elapsed += _timer_Elapsed; ChangeButtonStyle(false); RankingDatePicker.SelectedDate = _currentDate; }
internal TaskManager(Func <ITaskRepository> repositoryFactory, TaskManagerOptions options = null) { options = options ?? TaskManagerOptions.Default; _lockManager = new LockManager(repositoryFactory, minTimeout: new TimeSpan(TimeSpan.TicksPerSecond)); _repositoryFactory = repositoryFactory; _clockProvider = _lockManager.ClockProvider; _listener = new TaskManagerListener(this, options.MainLoopWait, options.MaxWorkerThreads); using (var repository = repositoryFactory()) { _connectionString = repository.Database.Connection.ConnectionString; } }
public ExecutionResultProcessorFixture() { PointerFactory = A.Fake <IExecutionPointerFactory>(); DateTimeProvider = A.Fake <IClockProvider>(); Options = new WorkflowOptions(); A.CallTo(() => DateTimeProvider.Now).Returns(DateTime.Now); //config logging var loggerFactory = new LoggerFactory(); Subject = new ExecutionResultProcessor(PointerFactory, Options, loggerFactory); }
public VaultFileRepositoryFactory(IFileSystem fileSystem, ISymetricCryptographer symetricCryptographer, ISerializer serializer, IClockProvider clockProvider, IVaultFileMetadataHandler vaultFileMetadataHandler) { GuardClauses.ArgumentIsNotNull(nameof(fileSystem), fileSystem); GuardClauses.ArgumentIsNotNull(nameof(symetricCryptographer), symetricCryptographer); GuardClauses.ArgumentIsNotNull(nameof(serializer), serializer); GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider); GuardClauses.ArgumentIsNotNull(nameof(vaultFileMetadataHandler), vaultFileMetadataHandler); this.FileSystem = fileSystem; this.SymetricCryptographer = symetricCryptographer; this.Serializer = serializer; this.ClockProvider = clockProvider; this.VaultFileMetadataHandler = vaultFileMetadataHandler; }
public WorkflowExecutorFixture() { Host = A.Fake <IWorkflowHost>(); PersistenceProvider = A.Fake <IPersistenceProvider>(); ServiceProvider = A.Fake <IServiceProvider>(); Registry = A.Fake <IWorkflowRegistry>(); ResultProcesser = A.Fake <IExecutionResultProcessor>(); DateTimeProvider = A.Fake <IClockProvider>(); Options = new WorkflowOptions(); A.CallTo(() => DateTimeProvider.Now).Returns(DateTime.Now); //config logging var loggerFactory = new LoggerFactory(); Subject = new WorkflowExecutor(Registry, ServiceProvider, ResultProcesser, Options, loggerFactory); }
public QueryHistoryAppService( IRepository <QueryHistory, long> acHistoryRepository, IRepository <QueryWorkerHistory, long> acWorkerHistoryRepository, IClockProvider clockProvider, ITimeZoneConverter timeZoneConverter, ICrawlerApiBackendClient crawlerApiBackendClient, IRepository <QuerySummary, long> querySummaryRepository, IRepository <QueryCrawlerSummary, long> queryCrawlerSummaryRepository, SummaryGenerator summaryGenerator) { _acHistoryRepository = acHistoryRepository; _acWorkerHistoryRepository = acWorkerHistoryRepository; _clockProvider = clockProvider; _timeZoneConverter = timeZoneConverter; _crawlerApiBackendClient = crawlerApiBackendClient; _querySummaryRepository = querySummaryRepository; _queryCrawlerSummaryRepository = queryCrawlerSummaryRepository; _summaryGenerator = summaryGenerator; }
internal LockManager(Func <IDistributedLockRepository> repositoryFactory, TimeSpan?minTimeout = null, TimeSpan?maxTimeout = null) { _minTimeout = minTimeout ?? new TimeSpan(DEFAULT_MIN_TIMEOUT_TICKS); _maxTimeout = maxTimeout ?? new TimeSpan(DEFAULT_MAX_TIMEOUT_TICKS); if (_minTimeout == TimeSpan.Zero || _maxTimeout < _minTimeout || _maxTimeout < defaultTimeout) { throw new ArgumentException("invalid minTimeout/maxTimeout pair."); } _machineName = Environment.MachineName.Truncate(100); _PID = Process.GetCurrentProcess().Id; _repositoryFactory = repositoryFactory; _clockProvider = DatabaseClockProvider.Create(repositoryFactory); _serialExecutionManager = SerialExecutionManager.Instance; using (var repository = repositoryFactory()) { _connectionString = repository.Database.Connection.ConnectionString; } }
public LevelHeatMapWindow(IEliteProvider eliteProvider, IClockProvider clockProvider) { InitializeComponent(); _eliteProvider = eliteProvider; _clockProvider = clockProvider; _timer = new Timer(2000); _timer.AutoReset = false; _timer.Elapsed += (a, b) => { Dispatcher.Invoke(() => { GridScreenshot(); MainGrid.Children.OfType <TextBox>().ToList().ForEach(t => t.Text = string.Empty); }); System.Threading.Thread.Sleep(2000); Dispatcher.Invoke(() => { GridScreenshot(); }); }; Task.Run(() => Initialize()); }
public UserService(DatabaseContext context, ILogger <UserService> log, IClockProvider clock) { _context = context; _log = log; _clock = clock; }
public TokenHelper(IClockProvider clock, IConfiguration config) { _clock = clock; _config = config; }
public VaultManipulatorFactory(IClockProvider clockProvider) { GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider); ClockProvider = clockProvider; }
static Clock() { Provider = new UnspecifiedClockProvider(); }
static Clock() { _clockProvider = new LocalClockProvider(); }
static DefaultLazyClockProvider() { LazyProvider = new DefaultClockProvider(); }
static Clock() { Provider = ClockProviders.Utc; }
static Clock() { Provider = ClockProviders.Unspecified; }
public MetaDataProvider(IClockProvider clockProvider) { _clockProvider = clockProvider; }
public PublicServiceListProjections(IClockProvider clockProvider) { When <Envelope <PublicServiceWasRegistered> >(async(context, message, ct) => { var publicServiceListItem = new PublicServiceListItem { PublicServiceId = message.Message.PublicServiceId, Name = message.Message.Name, Removed = false }; await context .PublicServiceList .AddAsync(publicServiceListItem, ct); }); When <Envelope <PublicServiceWasRenamed> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.Name = message.Message.NewName; }); When <Envelope <CompetentAuthorityWasAssigned> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.CompetentAuthorityCode = message.Message.CompetentAuthorityCode; publicServiceListItem.CompetentAuthorityName = message.Message.CompetentAuthorityName; }); When <Envelope <OrafinExportPropertyWasSet> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.ExportToOrafin = message.Message.ExportToOrafin; }); When <Envelope <PublicServiceWasRemoved> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.Removed = true; }); When <Envelope <StageWasAddedToLifeCycle> >(async(context, message, ct) => { await AddLifeCycleStage(message, context, ct); var period = new LifeCycleStagePeriod( new ValidFrom(message.Message.From), new ValidTo(message.Message.To)); if (!period.OverlapsWith(clockProvider.Today)) { return; } var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.CurrentLifeCycleStageType = message.Message.LifeCycleStageType; publicServiceListItem.CurrentLifeCycleStageId = message.Message.LifeCycleStageId; publicServiceListItem.CurrentLifeCycleStageEndsAt = message.Message.To; }); When <Envelope <PeriodOfLifeCycleStageWasChanged> >(async(context, message, ct) => { var publicServiceLifeCycleItem = await FindPublicServiceLifeCycleItemOrNull( context, message.Message.PublicServiceId, message.Message.LifeCycleStageId, ct); publicServiceLifeCycleItem.From = message.Message.From; publicServiceLifeCycleItem.To = message.Message.To; var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); var period = new LifeCycleStagePeriod(new ValidFrom(message.Message.From), new ValidTo(message.Message.To)); if (period.OverlapsWith(clockProvider.Today)) { publicServiceListItem.CurrentLifeCycleStageId = message.Message.LifeCycleStageId; publicServiceListItem.CurrentLifeCycleStageType = publicServiceLifeCycleItem.LifeCycleStageType; publicServiceListItem.CurrentLifeCycleStageEndsAt = message.Message.To; } else if (publicServiceListItem.CurrentLifeCycleStageId == message.Message.LifeCycleStageId && !period.OverlapsWith(clockProvider.Today)) { publicServiceListItem.CurrentLifeCycleStageId = null; publicServiceListItem.CurrentLifeCycleStageType = null; publicServiceListItem.CurrentLifeCycleStageEndsAt = null; } }); When <Envelope <LifeCycleStageWasRemoved> >(async(context, message, ct) => { var publicServiceLifeCycleItem = await FindPublicServiceLifeCycleItemOrNull( context, message.Message.PublicServiceId, message.Message.LifeCycleStageId, ct); // TODO: does this work properly in catch up mode? Implementing soft-delete might solve this indirectly context.LifeCycleStagesForPublicServiceList.Remove(publicServiceLifeCycleItem); var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); if (publicServiceListItem.CurrentLifeCycleStageId == publicServiceLifeCycleItem.LifeCycleStageId) { publicServiceListItem.CurrentLifeCycleStageId = null; publicServiceListItem.CurrentLifeCycleStageType = null; publicServiceListItem.CurrentLifeCycleStageEndsAt = null; } }); When <Envelope <IpdcCodeWasSet> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.IpdcCode = message.Message.IpdcCode; }); When <Envelope <LegislativeDocumentIdWasSet> >(async(context, message, ct) => { var publicServiceListItem = await FindPublicService( context, message.Message.PublicServiceId, ct); publicServiceListItem.LegislativeDocumentId = message.Message.LegislativeDocumentId; }); When <Envelope <ClockHasTicked> >(async(context, message, ct) => { var date = LocalDate.FromDateTime(message.Message.DateTime); var dateAsInt = date.ToInt(); // TODO: This needs to query on both local and db foreach (var publicServiceListItem in context.PublicServiceList.Where(item => item.CurrentLifeCycleStageEndsAtAsInt != null && item.CurrentLifeCycleStageEndsAtAsInt < dateAsInt)) { await UpdateCurrentLifeCycleStage(context, publicServiceListItem, date, ct); } }); }
public CustomerSaved(IClockProvider clockProvider, ICustomerService customerService, ICharacterHashService characterHashService) { _clockProvider = clockProvider; _customerService = customerService; _characterHashService = characterHashService; }
public SummaryGenerator(IClockProvider clockProvider) { _clockProvider = clockProvider; }
static ClockManager() { _provider = new LocalClockProvider(); }
/// <summary> /// 构造函数 /// </summary> static Clock() { Provider = ClockProviders.Unspecified; }
public RequestTokenService(IRepository <RequestToken> requestTokenRepository, IClockProvider clockProvider) { _requestTokenRepository = requestTokenRepository; _clockProvider = clockProvider; }