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;
 }
Exemple #3
0
 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;
 }
Exemple #5
0
        public VaultManipulator(Vault vault, IClockProvider clockProvider)
        {
            GuardClauses.ArgumentIsNotNull(nameof(vault), vault);
            GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider);

            Vault         = vault;
            ClockProvider = clockProvider;
        }
Exemple #6
0
        /// <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;
        }
Exemple #7
0
 public AuthenticationService(ILogger <AuthenticationService> logger, DatabaseContext context, IMediator mediator,
                              ITokenHelper tokenHelper, IClockProvider clock)
 {
     _logger      = logger;
     _context     = context;
     _mediator    = mediator;
     _tokenHelper = tokenHelper;
     _clock       = clock;
 }
Exemple #8
0
 public TimeZoneSettingAppService(
     IClockProvider clockProvider,
     IRepository <UserSettingAttribute, long> userSettingAttributeRepository,
     ISettingManager settingManager)
 {
     _clockProvider = clockProvider;
     _userSettingAttributeRepository = userSettingAttributeRepository;
     _settingManager = settingManager;
 }
Exemple #9
0
 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;
 }
Exemple #10
0
 public CreateToken(IClockProvider clockProvider,
                    IEncryptionProvider encryptionProvider,
                    IRandomStringGenerator randomStringGenerator,
                    IRequestTokenService requestTokenService)
 {
     _clockProvider         = clockProvider;
     _encryptionProvider    = encryptionProvider;
     _randomStringGenerator = randomStringGenerator;
     _requestTokenService   = requestTokenService;
 }
Exemple #11
0
        public void Dispose()
        {
            if (_isDisposed)
            {
                return;
            }

            _isDisposed = true;

            _clockProvider?.Dispose();
            _clockProvider = null;
        }
Exemple #12
0
        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;
            }
        }
Exemple #14
0
        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);
        }
Exemple #17
0
 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;
 }
Exemple #18
0
        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());
        }
Exemple #20
0
 public UserService(DatabaseContext context, ILogger <UserService> log, IClockProvider clock)
 {
     _context = context;
     _log     = log;
     _clock   = clock;
 }
Exemple #21
0
 public TokenHelper(IClockProvider clock, IConfiguration config)
 {
     _clock  = clock;
     _config = config;
 }
Exemple #22
0
        public VaultManipulatorFactory(IClockProvider clockProvider)
        {
            GuardClauses.ArgumentIsNotNull(nameof(clockProvider), clockProvider);

            ClockProvider = clockProvider;
        }
Exemple #23
0
 static Clock()
 {
     Provider = new UnspecifiedClockProvider();
 }
Exemple #24
0
 static Clock()
 {
     _clockProvider = new LocalClockProvider();
 }
 static DefaultLazyClockProvider()
 {
     LazyProvider = new DefaultClockProvider();
 }
 static Clock()
 {
     Provider = ClockProviders.Utc;
 }
Exemple #27
0
 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;
 }
Exemple #31
0
 static Clock()
 {
     _clockProvider = new LocalClockProvider();
 }
Exemple #32
0
 public SummaryGenerator(IClockProvider clockProvider)
 {
     _clockProvider = clockProvider;
 }
Exemple #33
0
 static ClockManager()
 {
     _provider = new LocalClockProvider();
 }
Exemple #34
0
 /// <summary>
 /// 构造函数
 /// </summary>
 static Clock()
 {
     Provider = ClockProviders.Unspecified;
 }
 public RequestTokenService(IRepository <RequestToken> requestTokenRepository, IClockProvider clockProvider)
 {
     _requestTokenRepository = requestTokenRepository;
     _clockProvider          = clockProvider;
 }