public TransactionConfirmationWatcherTests()
        {
            this.callbackRepository = Substitute.For <ICallbackRepository>();
            this.ruleRepository     = Substitute.ForPartsOf <FakeRuleRepository>();

            this.blockStorage = Substitute.For <IBlocksStorage>();
            this.blockStorage
            .GetAsync(Arg.Any <uint256>(), Arg.Any <CancellationToken>())
            .Returns(info => mockedBlocks[info.ArgAt <uint256>(0)].ToValueTuple());

            this.callbackExecuter = Substitute.For <ICallbackExecuter>();
            this.logger           = Substitute.For <ILogger <TransactionConfirmationWatcher> >();
            this.watchRepository  = new FakeWatchRepository();

            this.handler = this.subject = new TransactionConfirmationWatcher
                                          (
                this.callbackRepository,
                this.ruleRepository,
                this.blockStorage,
                this.callbackExecuter,
                this.watchRepository,
                this.logger
                                          );
            this.blockListener = this.subject;
            this.defaultUrl    = new Uri("http://zcoin.io");

            MockCallbackRepository();
        }
Example #2
0
        public TransactionConfirmationWatcher(
            ICallbackRepository callbackRepository,
            IRuleRepository ruleRepository,
            IBlocksStorage blocks,
            ICallbackExecuter callbackExecuter,
            IWatchRepository watchRepository,
            ILogger <TransactionConfirmationWatcher> logger)
        {
            if (callbackRepository == null)
            {
                throw new ArgumentNullException(nameof(callbackRepository));
            }

            if (ruleRepository == null)
            {
                throw new ArgumentNullException(nameof(ruleRepository));
            }

            if (blocks == null)
            {
                throw new ArgumentNullException(nameof(blocks));
            }

            if (callbackExecuter == null)
            {
                throw new ArgumentNullException(nameof(callbackExecuter));
            }

            if (watchRepository == null)
            {
                throw new ArgumentNullException(nameof(watchRepository));
            }

            if (logger == null)
            {
                throw new ArgumentNullException(nameof(logger));
            }

            this.callbackRepository = callbackRepository;
            this.ruleRepository     = ruleRepository;
            this.watchRepository    = watchRepository;
            this.callbackExecuter   = callbackExecuter;
            this.logger             = logger;

            this.watcher = new Zcoin.Watching.TransactionConfirmationWatcher <Rule>
                           (
                this,
                blocks
                           );

            this.timers    = new Dictionary <uint256, Dictionary <Guid, Timer> >();
            this.timerLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
        }
 public WatchController(IWatchRepository repository)
 {
     _repository = repository;
 }
Example #4
0
 public CronController(IWatchRepository watchRepository, IEnumerable <IWatch> watches)
 {
     _watchRepository = watchRepository;
     _watches         = watches;
 }
 public WatchService(IWatchRepository watchRepo)
 {
     _watchRepo = watchRepo;
 }
Example #6
0
 public WatchController(IWatchRepository watchRepository, IApiConfiguration config)
 {
     _watchRepository = watchRepository;
     _config          = config;
 }
 public GetAllWatchs(IWatchRepository watchRepository)
 {
     _watchRepository = watchRepository;
 }
Example #8
0
        public TokenReceivingWatcher(
            PropertyId property,
            ILogger <TokenReceivingWatcher> logger,
            IBlocksStorage blocks,
            IReceivingAddressPool addressPool,
            ITransactionRetriever exodusRetriever,
            IRuleRepository rules,
            IWatchRepository watches,
            ICallbackRepository callbacks,
            ICallbackExecuter callbackExecutor,
            ITimerScheduler timerScheduler)
        {
            if (property == null)
            {
                throw new ArgumentNullException(nameof(property));
            }

            if (logger == null)
            {
                throw new ArgumentNullException(nameof(logger));
            }

            if (addressPool == null)
            {
                throw new ArgumentNullException(nameof(addressPool));
            }

            if (exodusRetriever == null)
            {
                throw new ArgumentNullException(nameof(exodusRetriever));
            }

            if (rules == null)
            {
                throw new ArgumentNullException(nameof(rules));
            }

            if (watches == null)
            {
                throw new ArgumentNullException(nameof(watches));
            }

            if (callbacks == null)
            {
                throw new ArgumentNullException(nameof(callbacks));
            }

            if (callbackExecutor == null)
            {
                throw new ArgumentNullException(nameof(callbackExecutor));
            }

            if (timerScheduler == null)
            {
                throw new ArgumentNullException(nameof(timerScheduler));
            }

            this.property         = property;
            this.logger           = logger;
            this.addressPool      = addressPool;
            this.exodusRetriever  = exodusRetriever;
            this.rules            = rules;
            this.watches          = watches;
            this.callbacks        = callbacks;
            this.callbackExecutor = callbackExecutor;
            this.timerScheduler   = timerScheduler;
            this.watchings        = new Dictionary <BitcoinAddress, Watching>();
            this.engine           = new BalanceWatcher <Rule, PropertyAmount>(this, blocks);
            this.semaphore        = new SemaphoreSlim(1, 1);
            this.stopped          = true;
        }
Example #9
0
 public WatchInfo(IWatchRepository watchRepository)
 {
     _watchRepository = watchRepository;
 }
 public WatchService(IWatchRepository watchRepository, IOrderWatchRepository orderWatchRepository)
 {
     _watchRepository = watchRepository;
     _orderWatchRepository = orderWatchRepository;
 }
Example #11
0
 public CartFactory(IWatchRepository watchRepository)
 {
     _watchRepository = watchRepository;
 }
Example #12
0
 public WatchService(IWatchRepository watchRepository)
 {
     this.WatchRepository = watchRepository;
 }